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
);
2736 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2737 asection
*sec
, void *file
)
2739 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2740 bfd
*abfd
= (bfd
*) file
;
2745 if (section
->start
!= NULL
)
2747 /* If it is already loaded, do nothing. */
2748 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2750 free (section
->start
);
2753 section
->filename
= bfd_get_filename (abfd
);
2754 section
->reloc_info
= NULL
;
2755 section
->num_relocs
= 0;
2756 section
->address
= bfd_section_vma (sec
);
2757 section
->user_data
= sec
;
2758 section
->size
= bfd_section_size (sec
);
2759 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2760 alloced
= amt
= section
->size
+ 1;
2761 if (alloced
!= amt
|| alloced
== 0)
2763 section
->start
= NULL
;
2764 free_debug_section (debug
);
2765 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2766 sanitize_string (section
->name
),
2767 (unsigned long long) section
->size
);
2770 section
->start
= contents
= malloc (alloced
);
2771 if (section
->start
== NULL
2772 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2774 free_debug_section (debug
);
2775 printf (_("\nCan't get contents for section '%s'.\n"),
2776 sanitize_string (section
->name
));
2779 /* Ensure any string section has a terminating NUL. */
2780 section
->start
[section
->size
] = 0;
2782 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2783 && debug_displays
[debug
].relocate
)
2788 bfd_cache_section_contents (sec
, section
->start
);
2790 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2797 free_debug_section (debug
);
2798 printf (_("\nCan't get contents for section '%s'.\n"),
2799 sanitize_string (section
->name
));
2803 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2806 unsigned long reloc_count
;
2809 relocs
= (arelent
**) xmalloc (reloc_size
);
2811 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2812 if (reloc_count
== 0)
2816 section
->reloc_info
= relocs
;
2817 section
->num_relocs
= reloc_count
;
2826 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2831 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2834 relocs
= (arelent
**) dsec
->reloc_info
;
2836 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2837 if (rp
->address
== offset
)
2844 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2846 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2847 bfd
*abfd
= (bfd
*) file
;
2850 /* If it is already loaded, do nothing. */
2851 if (section
->start
!= NULL
)
2853 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2857 /* Locate the debug section. */
2858 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2860 section
->name
= section
->uncompressed_name
;
2863 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2865 section
->name
= section
->compressed_name
;
2870 return load_specific_debug_section (debug
, sec
, file
);
2874 free_debug_section (enum dwarf_section_display_enum debug
)
2876 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2878 if (section
->start
== NULL
)
2881 /* PR 17512: file: 0f67f69d. */
2882 if (section
->user_data
!= NULL
)
2884 asection
* sec
= (asection
*) section
->user_data
;
2886 /* If we are freeing contents that are also pointed to by the BFD
2887 library's section structure then make sure to update those pointers
2888 too. Otherwise, the next time we try to load data for this section
2889 we can end up using a stale pointer. */
2890 if (section
->start
== sec
->contents
)
2892 sec
->contents
= NULL
;
2893 sec
->flags
&= ~ SEC_IN_MEMORY
;
2894 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2898 free ((char *) section
->start
);
2899 section
->start
= NULL
;
2900 section
->address
= 0;
2905 close_debug_file (void * file
)
2907 bfd
* abfd
= (bfd
*) file
;
2913 open_debug_file (const char * pathname
)
2917 data
= bfd_openr (pathname
, NULL
);
2921 if (! bfd_check_format (data
, bfd_object
))
2928 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2929 void *arg ATTRIBUTE_UNUSED
)
2931 const char *name
= bfd_section_name (section
);
2935 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2936 match
= ".debug_info";
2940 for (i
= 0; i
< max
; i
++)
2941 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2942 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2943 && debug_displays
[i
].enabled
!= NULL
2944 && *debug_displays
[i
].enabled
)
2946 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2948 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2949 sec
->name
= sec
->uncompressed_name
;
2951 sec
->name
= sec
->compressed_name
;
2952 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2955 debug_displays
[i
].display (sec
, abfd
);
2957 if (i
!= info
&& i
!= abbrev
)
2958 free_debug_section ((enum dwarf_section_display_enum
) i
);
2964 /* Dump the dwarf debugging information. */
2967 dump_dwarf (bfd
*abfd
)
2969 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2970 if (byte_get
== NULL
)
2972 warn (_("File %s does not contain any dwarf debug information\n"),
2973 bfd_get_filename (abfd
));
2977 switch (bfd_get_arch (abfd
))
2980 /* S12Z has a 24 bit address space. But the only known
2981 producer of dwarf_info encodes addresses into 32 bits. */
2986 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2990 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
2991 bfd_get_mach (abfd
));
2993 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2996 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2997 it. Return NULL on failure. */
3000 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3001 bfd_size_type
*entsize_ptr
)
3006 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3007 if (stabsect
== NULL
)
3009 printf (_("No %s section present\n\n"),
3010 sanitize_string (sect_name
));
3014 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3016 non_fatal (_("reading %s section of %s failed: %s"),
3017 sect_name
, bfd_get_filename (abfd
),
3018 bfd_errmsg (bfd_get_error ()));
3024 *size_ptr
= bfd_section_size (stabsect
);
3026 *entsize_ptr
= stabsect
->entsize
;
3031 /* Stabs entries use a 12 byte format:
3032 4 byte string table index
3034 1 byte stab other field
3035 2 byte stab desc field
3037 FIXME: This will have to change for a 64 bit object format. */
3039 #define STRDXOFF (0)
3041 #define OTHEROFF (5)
3044 #define STABSIZE (12)
3046 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3047 using string table section STRSECT_NAME (in `strtab'). */
3050 print_section_stabs (bfd
*abfd
,
3051 const char *stabsect_name
,
3052 unsigned *string_offset_ptr
)
3055 unsigned file_string_table_offset
= 0;
3056 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3057 bfd_byte
*stabp
, *stabs_end
;
3060 stabs_end
= stabp
+ stab_size
;
3062 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3063 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3065 /* Loop through all symbols and print them.
3067 We start the index at -1 because there is a dummy symbol on
3068 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3069 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3073 unsigned char type
, other
;
3074 unsigned short desc
;
3077 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3078 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3079 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3080 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3081 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3083 printf ("\n%-6d ", i
);
3084 /* Either print the stab name, or, if unnamed, print its number
3085 again (makes consistent formatting for tools like awk). */
3086 name
= bfd_get_stab_name (type
);
3088 printf ("%-6s", sanitize_string (name
));
3089 else if (type
== N_UNDF
)
3092 printf ("%-6d", type
);
3093 printf (" %-6d %-6d ", other
, desc
);
3094 bfd_printf_vma (abfd
, value
);
3095 printf (" %-6lu", strx
);
3097 /* Symbols with type == 0 (N_UNDF) specify the length of the
3098 string table associated with this file. We use that info
3099 to know how to relocate the *next* file's string table indices. */
3102 file_string_table_offset
= next_file_string_table_offset
;
3103 next_file_string_table_offset
+= value
;
3107 bfd_size_type amt
= strx
+ file_string_table_offset
;
3109 /* Using the (possibly updated) string table offset, print the
3110 string (if any) associated with this symbol. */
3111 if (amt
< stabstr_size
)
3112 /* PR 17512: file: 079-79389-0.001:0.1.
3113 FIXME: May need to sanitize this string before displaying. */
3114 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3120 *string_offset_ptr
= next_file_string_table_offset
;
3125 const char * section_name
;
3126 const char * string_section_name
;
3127 unsigned string_offset
;
3132 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3135 stab_section_names
* sought
= (stab_section_names
*) names
;
3137 /* Check for section names for which stabsect_name is a prefix, to
3138 handle .stab.N, etc. */
3139 len
= strlen (sought
->section_name
);
3141 /* If the prefix matches, and the files section name ends with a
3142 nul or a digit, then we match. I.e., we want either an exact
3143 match or a section followed by a number. */
3144 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3145 && (section
->name
[len
] == 0
3146 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3149 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3150 &stabstr_size
, NULL
);
3154 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3156 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3162 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3164 stab_section_names s
;
3166 s
.section_name
= stabsect_name
;
3167 s
.string_section_name
= strsect_name
;
3168 s
.string_offset
= 0;
3170 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3176 /* Dump the any sections containing stabs debugging information. */
3179 dump_stabs (bfd
*abfd
)
3181 dump_stabs_section (abfd
, ".stab", ".stabstr");
3182 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3183 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3186 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3188 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3192 dump_bfd_header (bfd
*abfd
)
3196 printf (_("architecture: %s, "),
3197 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3198 bfd_get_mach (abfd
)));
3199 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3201 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3202 PF (HAS_RELOC
, "HAS_RELOC");
3203 PF (EXEC_P
, "EXEC_P");
3204 PF (HAS_LINENO
, "HAS_LINENO");
3205 PF (HAS_DEBUG
, "HAS_DEBUG");
3206 PF (HAS_SYMS
, "HAS_SYMS");
3207 PF (HAS_LOCALS
, "HAS_LOCALS");
3208 PF (DYNAMIC
, "DYNAMIC");
3209 PF (WP_TEXT
, "WP_TEXT");
3210 PF (D_PAGED
, "D_PAGED");
3211 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3212 printf (_("\nstart address 0x"));
3213 bfd_printf_vma (abfd
, abfd
->start_address
);
3218 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3219 it is passed, or a pointer to newly-allocated storage, in which case
3220 dump_ctf() will free it when it no longer needs it. */
3223 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3226 const char *blanks
= arg
;
3229 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3234 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3236 make_ctfsect (const char *name
, bfd_byte
*data
,
3241 ctfsect
.cts_name
= name
;
3242 ctfsect
.cts_entsize
= 1;
3243 ctfsect
.cts_size
= size
;
3244 ctfsect
.cts_data
= data
;
3249 /* Dump one CTF archive member. */
3252 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3254 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3255 const char *things
[] = {"Header", "Labels", "Data objects",
3256 "Function objects", "Variables", "Types", "Strings",
3261 /* Only print out the name of non-default-named archive members.
3262 The name .ctf appears everywhere, even for things that aren't
3263 really archives, so printing it out is liable to be confusing.
3265 The parent, if there is one, is the default-owned archive member:
3266 avoid importing it into itself. (This does no harm, but looks
3269 if (strcmp (name
, ".ctf") != 0)
3271 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3272 ctf_import (ctf
, parent
);
3275 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
3277 ctf_dump_state_t
*s
= NULL
;
3280 printf ("\n %s:\n", *thing
);
3281 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3282 (void *) " ")) != NULL
)
3284 printf ("%s\n", item
);
3288 if (ctf_errno (ctf
))
3290 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3291 ctf_errmsg (ctf_errno (ctf
)));
3298 /* Dump the CTF debugging information. */
3301 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3303 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
3304 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3305 bfd_size_type ctfsize
, parentsize
;
3307 ctf_file_t
*parent
= NULL
;
3310 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3311 bfd_fatal (bfd_get_filename (abfd
));
3314 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3316 bfd_fatal (bfd_get_filename (abfd
));
3318 /* Load the CTF file and dump it. */
3320 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3321 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3323 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3324 bfd_fatal (bfd_get_filename (abfd
));
3329 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3330 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3332 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3333 bfd_fatal (bfd_get_filename (abfd
));
3336 lookparent
= parenta
;
3341 /* Assume that the applicable parent archive member is the default one.
3342 (This is what all known implementations are expected to do, if they
3343 put CTFs and their parents in archives together.) */
3344 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
3346 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3347 bfd_fatal (bfd_get_filename (abfd
));
3350 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3352 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3353 ctf_file_close (parent
);
3355 ctf_close (parenta
);
3362 dump_bfd_private_header (bfd
*abfd
)
3364 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3365 non_fatal (_("warning: private headers incomplete: %s"),
3366 bfd_errmsg (bfd_get_error ()));
3370 dump_target_specific (bfd
*abfd
)
3372 const struct objdump_private_desc
* const *desc
;
3373 struct objdump_private_option
*opt
;
3376 /* Find the desc. */
3377 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3378 if ((*desc
)->filter (abfd
))
3383 non_fatal (_("option -P/--private not supported by this file"));
3387 /* Clear all options. */
3388 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3389 opt
->selected
= FALSE
;
3391 /* Decode options. */
3392 b
= dump_private_options
;
3395 e
= strchr (b
, ',');
3400 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3401 if (strcmp (opt
->name
, b
) == 0)
3403 opt
->selected
= TRUE
;
3406 if (opt
->name
== NULL
)
3407 non_fatal (_("target specific dump '%s' not supported"), b
);
3418 (*desc
)->dump (abfd
);
3421 /* Display a section in hexadecimal format with associated characters.
3422 Each line prefixed by the zero padded address. */
3425 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3427 bfd_byte
*data
= NULL
;
3428 bfd_size_type datasize
;
3429 bfd_vma addr_offset
;
3430 bfd_vma start_offset
;
3431 bfd_vma stop_offset
;
3432 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
3433 /* Bytes per line. */
3434 const int onaline
= 16;
3439 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3442 if (! process_section_p (section
))
3445 if ((datasize
= bfd_section_size (section
)) == 0)
3448 /* Compute the address range to display. */
3449 if (start_address
== (bfd_vma
) -1
3450 || start_address
< section
->vma
)
3453 start_offset
= start_address
- section
->vma
;
3455 if (stop_address
== (bfd_vma
) -1)
3456 stop_offset
= datasize
/ opb
;
3459 if (stop_address
< section
->vma
)
3462 stop_offset
= stop_address
- section
->vma
;
3464 if (stop_offset
> datasize
/ opb
)
3465 stop_offset
= datasize
/ opb
;
3468 if (start_offset
>= stop_offset
)
3471 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3472 if (display_file_offsets
)
3473 printf (_(" (Starting at file offset: 0x%lx)"),
3474 (unsigned long) (section
->filepos
+ start_offset
));
3477 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3479 non_fatal (_("Reading section %s failed because: %s"),
3480 section
->name
, bfd_errmsg (bfd_get_error ()));
3486 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3487 if (strlen (buf
) >= sizeof (buf
))
3491 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3493 count
= strlen (buf
) - count
;
3497 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3498 if (strlen (buf
) >= sizeof (buf
))
3502 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3504 count
= strlen (buf
) - count
;
3508 for (addr_offset
= start_offset
;
3509 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3513 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3514 count
= strlen (buf
);
3515 if ((size_t) count
>= sizeof (buf
))
3519 while (count
< width
)
3524 fputs (buf
+ count
- width
, stdout
);
3527 for (j
= addr_offset
* opb
;
3528 j
< addr_offset
* opb
+ onaline
; j
++)
3530 if (j
< stop_offset
* opb
)
3531 printf ("%02x", (unsigned) (data
[j
]));
3539 for (j
= addr_offset
* opb
;
3540 j
< addr_offset
* opb
+ onaline
; j
++)
3542 if (j
>= stop_offset
* opb
)
3545 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3552 /* Actually display the various requested regions. */
3555 dump_data (bfd
*abfd
)
3557 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3560 /* Should perhaps share code and display with nm? */
3563 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3572 max_count
= dynsymcount
;
3573 printf ("DYNAMIC SYMBOL TABLE:\n");
3578 max_count
= symcount
;
3579 printf ("SYMBOL TABLE:\n");
3583 printf (_("no symbols\n"));
3585 for (count
= 0; count
< max_count
; count
++)
3589 if (*current
== NULL
)
3590 printf (_("no information for symbol number %ld\n"), count
);
3592 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3593 printf (_("could not determine the type of symbol number %ld\n"),
3596 else if (process_section_p ((* current
)->section
)
3597 && (dump_special_syms
3598 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3600 const char *name
= (*current
)->name
;
3602 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3606 /* If we want to demangle the name, we demangle it
3607 here, and temporarily clobber it while calling
3608 bfd_print_symbol. FIXME: This is a gross hack. */
3609 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3611 (*current
)->name
= alloc
;
3612 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3613 bfd_print_symbol_all
);
3616 (*current
)->name
= name
;
3621 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3622 bfd_print_symbol_all
);
3632 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3635 char *last_filename
, *last_functionname
;
3636 unsigned int last_line
;
3637 unsigned int last_discriminator
;
3639 /* Get column headers lined up reasonably. */
3647 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3648 width
= strlen (buf
) - 7;
3650 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3653 last_filename
= NULL
;
3654 last_functionname
= NULL
;
3656 last_discriminator
= 0;
3658 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3661 const char *filename
, *functionname
;
3662 unsigned int linenumber
;
3663 unsigned int discriminator
;
3664 const char *sym_name
;
3665 const char *section_name
;
3666 bfd_vma addend2
= 0;
3668 if (start_address
!= (bfd_vma
) -1
3669 && q
->address
< start_address
)
3671 if (stop_address
!= (bfd_vma
) -1
3672 && q
->address
> stop_address
)
3675 if (with_line_numbers
3677 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3678 &filename
, &functionname
,
3679 &linenumber
, &discriminator
))
3681 if (functionname
!= NULL
3682 && (last_functionname
== NULL
3683 || strcmp (functionname
, last_functionname
) != 0))
3685 printf ("%s():\n", sanitize_string (functionname
));
3686 if (last_functionname
!= NULL
)
3687 free (last_functionname
);
3688 last_functionname
= xstrdup (functionname
);
3692 && (linenumber
!= last_line
3693 || (filename
!= NULL
3694 && last_filename
!= NULL
3695 && filename_cmp (filename
, last_filename
) != 0)
3696 || (discriminator
!= last_discriminator
)))
3698 if (discriminator
> 0)
3699 printf ("%s:%u\n", filename
== NULL
? "???" :
3700 sanitize_string (filename
), linenumber
);
3702 printf ("%s:%u (discriminator %u)\n",
3703 filename
== NULL
? "???" : sanitize_string (filename
),
3704 linenumber
, discriminator
);
3705 last_line
= linenumber
;
3706 last_discriminator
= discriminator
;
3707 if (last_filename
!= NULL
)
3708 free (last_filename
);
3709 if (filename
== NULL
)
3710 last_filename
= NULL
;
3712 last_filename
= xstrdup (filename
);
3716 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3718 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3719 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3724 section_name
= NULL
;
3727 bfd_printf_vma (abfd
, q
->address
);
3728 if (q
->howto
== NULL
)
3729 printf (" *unknown* ");
3730 else if (q
->howto
->name
)
3732 const char *name
= q
->howto
->name
;
3734 /* R_SPARC_OLO10 relocations contain two addends.
3735 But because 'arelent' lacks enough storage to
3736 store them both, the 64-bit ELF Sparc backend
3737 records this as two relocations. One R_SPARC_LO10
3738 and one R_SPARC_13, both pointing to the same
3739 address. This is merely so that we have some
3740 place to store both addend fields.
3742 Undo this transformation, otherwise the output
3743 will be confusing. */
3744 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3745 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3747 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3749 arelent
*q2
= *(p
+ 1);
3752 && q
->address
== q2
->address
3753 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3755 name
= "R_SPARC_OLO10";
3756 addend2
= q2
->addend
;
3760 printf (" %-16s ", name
);
3763 printf (" %-16d ", q
->howto
->type
);
3767 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3771 if (section_name
== NULL
)
3772 section_name
= "*unknown*";
3773 printf ("[%s]", sanitize_string (section_name
));
3778 bfd_signed_vma addend
= q
->addend
;
3786 bfd_printf_vma (abfd
, addend
);
3791 bfd_printf_vma (abfd
, addend2
);
3797 if (last_filename
!= NULL
)
3798 free (last_filename
);
3799 if (last_functionname
!= NULL
)
3800 free (last_functionname
);
3804 dump_relocs_in_section (bfd
*abfd
,
3806 void *dummy ATTRIBUTE_UNUSED
)
3808 arelent
**relpp
= NULL
;
3812 if ( bfd_is_abs_section (section
)
3813 || bfd_is_und_section (section
)
3814 || bfd_is_com_section (section
)
3815 || (! process_section_p (section
))
3816 || ((section
->flags
& SEC_RELOC
) == 0))
3819 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3821 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3824 printf (" (none)\n\n");
3832 relpp
= (arelent
**) xmalloc (relsize
);
3833 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3839 non_fatal (_("failed to read relocs in: %s"),
3840 sanitize_string (bfd_get_filename (abfd
)));
3841 bfd_fatal (_("error message was"));
3843 else if (relcount
== 0)
3844 printf (" (none)\n\n");
3848 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3855 dump_relocs (bfd
*abfd
)
3857 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3861 dump_dynamic_relocs (bfd
*abfd
)
3867 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3869 bfd_fatal (bfd_get_filename (abfd
));
3871 printf ("DYNAMIC RELOCATION RECORDS");
3874 printf (" (none)\n\n");
3877 relpp
= (arelent
**) xmalloc (relsize
);
3878 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3881 bfd_fatal (bfd_get_filename (abfd
));
3882 else if (relcount
== 0)
3883 printf (" (none)\n\n");
3887 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3894 /* Creates a table of paths, to search for source files. */
3897 add_include_path (const char *path
)
3901 include_path_count
++;
3902 include_paths
= (const char **)
3903 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3904 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3905 if (path
[1] == ':' && path
[2] == 0)
3906 path
= concat (path
, ".", (const char *) 0);
3908 include_paths
[include_path_count
- 1] = path
;
3912 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3916 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3918 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3919 section
->vma
+= adjust_section_vma
;
3921 section
->lma
+= adjust_section_vma
;
3925 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3928 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3933 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3934 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3937 /* Dump selected contents of ABFD. */
3940 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3942 const struct elf_backend_data
* bed
;
3944 if (bfd_big_endian (abfd
))
3945 byte_get
= byte_get_big_endian
;
3946 else if (bfd_little_endian (abfd
))
3947 byte_get
= byte_get_little_endian
;
3951 /* Load any separate debug information files.
3952 We do this now and without checking do_follow_links because separate
3953 debug info files may contain symbol tables that we will need when
3954 displaying information about the main file. Any memory allocated by
3955 load_separate_debug_files will be released when we call
3956 free_debug_memory below.
3958 The test on is_mainfile is there because the chain of separate debug
3959 info files is a global variable shared by all invocations of dump_bfd. */
3962 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3964 /* If asked to do so, recursively dump the separate files. */
3965 if (do_follow_links
)
3969 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3970 dump_bfd (i
->handle
, FALSE
);
3974 /* Adjust user-specified start and stop limits for targets that use
3975 signed addresses. */
3976 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3977 && (bed
= get_elf_backend_data (abfd
)) != NULL
3978 && bed
->sign_extend_vma
)
3980 start_address
= sign_extend_address (abfd
, start_address
,
3982 stop_address
= sign_extend_address (abfd
, stop_address
,
3986 /* If we are adjusting section VMA's, change them all now. Changing
3987 the BFD information is a hack. However, we must do it, or
3988 bfd_find_nearest_line will not do the right thing. */
3989 if (adjust_section_vma
!= 0)
3991 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3992 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3995 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3996 printf (_("\n%s: file format %s\n"),
3997 sanitize_string (bfd_get_filename (abfd
)),
4000 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4001 if (dump_file_header
)
4002 dump_bfd_header (abfd
);
4003 if (dump_private_headers
)
4004 dump_bfd_private_header (abfd
);
4005 if (dump_private_options
!= NULL
)
4006 dump_target_specific (abfd
);
4007 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4014 || dump_dwarf_section_info
)
4016 syms
= slurp_symtab (abfd
);
4018 /* If following links, load any symbol tables from the linked files as well. */
4019 if (do_follow_links
&& is_mainfile
)
4023 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4025 asymbol
** extra_syms
;
4026 long old_symcount
= symcount
;
4028 extra_syms
= slurp_symtab (i
->handle
);
4032 if (old_symcount
== 0)
4038 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4039 memcpy (syms
+ old_symcount
,
4041 symcount
* sizeof (asymbol
*));
4045 symcount
+= old_symcount
;
4050 if (dump_section_headers
)
4051 dump_headers (abfd
);
4053 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4054 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4055 dynsyms
= slurp_dynamic_symtab (abfd
);
4059 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4060 dynsymcount
, dynsyms
, &synthsyms
);
4066 dump_symbols (abfd
, FALSE
);
4067 if (dump_dynamic_symtab
)
4068 dump_symbols (abfd
, TRUE
);
4069 if (dump_dwarf_section_info
)
4071 if (dump_ctf_section_info
)
4072 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4073 if (dump_stab_section_info
)
4075 if (dump_reloc_info
&& ! disassemble
)
4077 if (dump_dynamic_reloc_info
&& ! disassemble
)
4078 dump_dynamic_relocs (abfd
);
4079 if (dump_section_contents
)
4082 disassemble_data (abfd
);
4088 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4089 if (dhandle
!= NULL
)
4091 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4093 dump_debugging_tags
? TRUE
: FALSE
))
4095 non_fatal (_("%s: printing debugging information failed"),
4096 bfd_get_filename (abfd
));
4102 /* PR 6483: If there was no STABS debug info in the file, try
4104 else if (! dump_dwarf_section_info
)
4106 dwarf_select_sections_all ();
4134 free_debug_memory ();
4138 display_object_bfd (bfd
*abfd
)
4142 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4144 dump_bfd (abfd
, TRUE
);
4148 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4150 nonfatal (bfd_get_filename (abfd
));
4151 list_matching_formats (matching
);
4156 if (bfd_get_error () != bfd_error_file_not_recognized
)
4158 nonfatal (bfd_get_filename (abfd
));
4162 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4164 dump_bfd (abfd
, TRUE
);
4168 nonfatal (bfd_get_filename (abfd
));
4170 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4172 list_matching_formats (matching
);
4178 display_any_bfd (bfd
*file
, int level
)
4180 /* Decompress sections unless dumping the section contents. */
4181 if (!dump_section_contents
)
4182 file
->flags
|= BFD_DECOMPRESS
;
4184 /* If the file is an archive, process all of its elements. */
4185 if (bfd_check_format (file
, bfd_archive
))
4188 bfd
*last_arfile
= NULL
;
4191 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4192 else if (level
> 100)
4194 /* Prevent corrupted files from spinning us into an
4195 infinite loop. 100 is an arbitrary heuristic. */
4196 fatal (_("Archive nesting is too deep"));
4200 printf (_("In nested archive %s:\n"),
4201 sanitize_string (bfd_get_filename (file
)));
4205 bfd_set_error (bfd_error_no_error
);
4207 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4210 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4211 nonfatal (bfd_get_filename (file
));
4215 display_any_bfd (arfile
, level
+ 1);
4217 if (last_arfile
!= NULL
)
4219 bfd_close (last_arfile
);
4220 /* PR 17512: file: ac585d01. */
4221 if (arfile
== last_arfile
)
4227 last_arfile
= arfile
;
4230 if (last_arfile
!= NULL
)
4231 bfd_close (last_arfile
);
4234 display_object_bfd (file
);
4238 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4242 if (get_file_size (filename
) < 1)
4248 file
= bfd_openr (filename
, target
);
4251 nonfatal (filename
);
4255 display_any_bfd (file
, 0);
4257 /* This is an optimization to improve the speed of objdump, especially when
4258 dumping a file with lots of associated debug informatiom. Calling
4259 bfd_close on such a file can take a non-trivial amount of time as there
4260 are lots of lists to walk and buffers to free. This is only really
4261 necessary however if we are about to load another file and we need the
4262 memory back. Otherwise, if we are about to exit, then we can save (a lot
4263 of) time by only doing a quick close, and allowing the OS to reclaim the
4268 bfd_close_all_done (file
);
4272 main (int argc
, char **argv
)
4275 char *target
= default_target
;
4276 bfd_boolean seenflag
= FALSE
;
4278 #if defined (HAVE_SETLOCALE)
4279 #if defined (HAVE_LC_MESSAGES)
4280 setlocale (LC_MESSAGES
, "");
4282 setlocale (LC_CTYPE
, "");
4285 bindtextdomain (PACKAGE
, LOCALEDIR
);
4286 textdomain (PACKAGE
);
4288 program_name
= *argv
;
4289 xmalloc_set_program_name (program_name
);
4290 bfd_set_error_program_name (program_name
);
4292 START_PROGRESS (program_name
, 0);
4294 expandargv (&argc
, &argv
);
4296 if (bfd_init () != BFD_INIT_MAGIC
)
4297 fatal (_("fatal error: libbfd ABI mismatch"));
4298 set_default_bfd_target ();
4300 while ((c
= getopt_long (argc
, argv
,
4301 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4302 long_options
, (int *) 0))
4308 break; /* We've been given a long option. */
4315 if (disassembler_options
)
4316 /* Ignore potential memory leak for now. */
4317 options
= concat (disassembler_options
, ",",
4318 optarg
, (const char *) NULL
);
4321 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4328 display_file_offsets
= TRUE
;
4331 with_line_numbers
= TRUE
;
4340 enum demangling_styles style
;
4342 style
= cplus_demangle_name_to_style (optarg
);
4343 if (style
== unknown_demangling
)
4344 fatal (_("unknown demangling style `%s'"),
4347 cplus_demangle_set_style (style
);
4350 case OPTION_RECURSE_LIMIT
:
4351 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4353 case OPTION_NO_RECURSE_LIMIT
:
4354 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4357 do_wide
= wide_output
= TRUE
;
4359 case OPTION_ADJUST_VMA
:
4360 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4362 case OPTION_START_ADDRESS
:
4363 start_address
= parse_vma (optarg
, "--start-address");
4364 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4365 fatal (_("error: the start address should be before the end address"));
4367 case OPTION_STOP_ADDRESS
:
4368 stop_address
= parse_vma (optarg
, "--stop-address");
4369 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4370 fatal (_("error: the stop address should be after the start address"));
4374 prefix_length
= strlen (prefix
);
4375 /* Remove an unnecessary trailing '/' */
4376 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4379 case OPTION_PREFIX_STRIP
:
4380 prefix_strip
= atoi (optarg
);
4381 if (prefix_strip
< 0)
4382 fatal (_("error: prefix strip must be non-negative"));
4384 case OPTION_INSN_WIDTH
:
4385 insn_width
= strtoul (optarg
, NULL
, 0);
4386 if (insn_width
<= 0)
4387 fatal (_("error: instruction width must be positive"));
4389 case OPTION_INLINES
:
4390 unwind_inlines
= TRUE
;
4393 if (strcmp (optarg
, "B") == 0)
4394 endian
= BFD_ENDIAN_BIG
;
4395 else if (strcmp (optarg
, "L") == 0)
4396 endian
= BFD_ENDIAN_LITTLE
;
4399 nonfatal (_("unrecognized -E option"));
4404 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4405 endian
= BFD_ENDIAN_BIG
;
4406 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4407 endian
= BFD_ENDIAN_LITTLE
;
4410 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4417 dump_file_header
= TRUE
;
4421 formats_info
= TRUE
;
4425 add_include_path (optarg
);
4428 dump_private_headers
= TRUE
;
4432 dump_private_options
= optarg
;
4436 dump_private_headers
= TRUE
;
4438 dump_reloc_info
= TRUE
;
4439 dump_file_header
= TRUE
;
4440 dump_ar_hdrs
= TRUE
;
4441 dump_section_headers
= TRUE
;
4449 dump_dynamic_symtab
= TRUE
;
4455 disasm_sym
= optarg
;
4458 disassemble_zeroes
= TRUE
;
4462 disassemble_all
= TRUE
;
4467 with_source_code
= TRUE
;
4470 case OPTION_SOURCE_COMMENT
:
4472 with_source_code
= TRUE
;
4475 source_comment
= xstrdup (sanitize_string (optarg
));
4477 source_comment
= xstrdup ("# ");
4485 dump_debugging_tags
= 1;
4490 dump_dwarf_section_info
= TRUE
;
4493 dwarf_select_sections_by_letters (optarg
);
4495 dwarf_select_sections_all ();
4498 dump_dwarf_section_info
= TRUE
;
4501 dwarf_select_sections_by_names (optarg
);
4503 dwarf_select_sections_all ();
4505 case OPTION_DWARF_DEPTH
:
4508 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4511 case OPTION_DWARF_START
:
4514 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4515 suppress_bfd_header
= 1;
4518 case OPTION_DWARF_CHECK
:
4522 dump_ctf_section_info
= TRUE
;
4523 dump_ctf_section_name
= xstrdup (optarg
);
4526 case OPTION_CTF_PARENT
:
4527 dump_ctf_parent_name
= xstrdup (optarg
);
4530 dump_stab_section_info
= TRUE
;
4534 dump_section_contents
= TRUE
;
4538 dump_reloc_info
= TRUE
;
4542 dump_dynamic_reloc_info
= TRUE
;
4546 dump_ar_hdrs
= TRUE
;
4550 dump_section_headers
= TRUE
;
4555 show_version
= TRUE
;
4561 /* No need to set seenflag or to break - usage() does not return. */
4568 print_version ("objdump");
4574 exit_status
= display_info ();
4578 display_file ("a.out", target
, TRUE
);
4580 for (; optind
< argc
;)
4582 display_file (argv
[optind
], target
, optind
== argc
- 1);
4588 free (dump_ctf_section_name
);
4589 free (dump_ctf_parent_name
);
4590 free ((void *) source_comment
);
4592 END_PROGRESS (program_name
);