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