1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
128 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
130 /* A structure to record the sections mentioned in -j switches. */
133 const char * name
; /* The name of the section. */
134 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
135 struct only
* next
; /* Pointer to the next structure in the list. */
137 /* Pointer to an array of 'only' structures.
138 This pointer is NULL if the -j switch has not been used. */
139 static struct only
* only_list
= NULL
;
141 /* Variables for handling include file path table. */
142 static const char **include_paths
;
143 static int include_path_count
;
145 /* Extra info to pass to the section disassembler and address printing
147 struct objdump_disasm_info
150 bfd_boolean require_sec
;
151 arelent
** dynrelbuf
;
153 disassembler_ftype disassemble_fn
;
158 /* Architecture to disassemble for, or default if NULL. */
159 static char *machine
= NULL
;
161 /* Target specific options to the disassembler. */
162 static char *disassembler_options
= NULL
;
164 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
165 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
167 /* The symbol table. */
168 static asymbol
**syms
;
170 /* Number of symbols in `syms'. */
171 static long symcount
= 0;
173 /* The sorted symbol table. */
174 static asymbol
**sorted_syms
;
176 /* Number of symbols in `sorted_syms'. */
177 static long sorted_symcount
= 0;
179 /* The dynamic symbol table. */
180 static asymbol
**dynsyms
;
182 /* The synthetic symbol table. */
183 static asymbol
*synthsyms
;
184 static long synthcount
= 0;
186 /* Number of symbols in `dynsyms'. */
187 static long dynsymcount
= 0;
189 static bfd_byte
*stabs
;
190 static bfd_size_type stab_size
;
192 static bfd_byte
*strtab
;
193 static bfd_size_type stabstr_size
;
195 /* Handlers for -P/--private. */
196 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
198 OBJDUMP_PRIVATE_VECTORS
202 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
204 usage (FILE *stream
, int status
)
206 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
207 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
208 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
209 fprintf (stream
, _("\
210 -a, --archive-headers Display archive header information\n\
211 -f, --file-headers Display the contents of the overall file header\n\
212 -p, --private-headers Display object format specific file header contents\n\
213 -P, --private=OPT,OPT... Display object format specific contents\n\
214 -h, --[section-]headers Display the contents of the section headers\n\
215 -x, --all-headers Display the contents of all headers\n\
216 -d, --disassemble Display assembler contents of executable sections\n\
217 -D, --disassemble-all Display assembler contents of all sections\n\
218 --disassemble=<sym> Display assembler contents from <sym>\n\
219 -S, --source Intermix source code with disassembly\n\
220 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
221 -s, --full-contents Display the full contents of all sections requested\n\
222 -g, --debugging Display debug information in object file\n\
223 -e, --debugging-tags Display debug information using ctags style\n\
224 -G, --stabs Display (in raw form) any STABS info in the file\n\
225 -W[lLiaprmfFsoRtUuTgAckK] or\n\
226 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
227 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
228 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
229 =addr,=cu_index,=links,=follow-links]\n\
230 Display DWARF info in the file\n\
231 --ctf=SECTION Display CTF info from SECTION\n\
232 -t, --syms Display the contents of the symbol table(s)\n\
233 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
234 -r, --reloc Display the relocation entries in the file\n\
235 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
236 @<file> Read options from <file>\n\
237 -v, --version Display this program's version number\n\
238 -i, --info List object formats and architectures supported\n\
239 -H, --help Display this information\n\
243 const struct objdump_private_desc
* const *desc
;
245 fprintf (stream
, _("\n The following switches are optional:\n"));
246 fprintf (stream
, _("\
247 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
248 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
249 -j, --section=NAME Only display information for section NAME\n\
250 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
251 -EB --endian=big Assume big endian format when disassembling\n\
252 -EL --endian=little Assume little endian format when disassembling\n\
253 --file-start-context Include context from start of file (with -S)\n\
254 -I, --include=DIR Add DIR to search list for source files\n\
255 -l, --line-numbers Include line numbers and filenames in output\n\
256 -F, --file-offsets Include file offsets when displaying information\n\
257 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
258 The STYLE, if specified, can be `auto', `gnu',\n\
259 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
261 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
262 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
263 -w, --wide Format output for more than 80 columns\n\
264 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
265 --start-address=ADDR Only process data whose address is >= ADDR\n\
266 --stop-address=ADDR Only process data whose address is < ADDR\n\
267 --prefix-addresses Print complete address alongside disassembly\n\
268 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
269 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
270 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
271 --special-syms Include special symbols in symbol dumps\n\
272 --inlines Print all inlines for source line (with -l)\n\
273 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
274 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
275 fprintf (stream
, _("\
276 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
277 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
279 --dwarf-check Make additional dwarf internal consistency checks.\
281 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
282 list_supported_targets (program_name
, stream
);
283 list_supported_architectures (program_name
, stream
);
285 disassembler_usage (stream
);
287 if (objdump_private_vectors
[0] != NULL
)
290 _("\nOptions supported for -P/--private switch:\n"));
291 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
292 (*desc
)->help (stream
);
295 if (REPORT_BUGS_TO
[0] && status
== 0)
296 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
300 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
304 OPTION_START_ADDRESS
,
314 OPTION_RECURSE_LIMIT
,
315 OPTION_NO_RECURSE_LIMIT
,
317 OPTION_SOURCE_COMMENT
,
322 static struct option long_options
[]=
324 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
325 {"all-headers", no_argument
, NULL
, 'x'},
326 {"private-headers", no_argument
, NULL
, 'p'},
327 {"private", required_argument
, NULL
, 'P'},
328 {"architecture", required_argument
, NULL
, 'm'},
329 {"archive-headers", no_argument
, NULL
, 'a'},
330 {"debugging", no_argument
, NULL
, 'g'},
331 {"debugging-tags", no_argument
, NULL
, 'e'},
332 {"demangle", optional_argument
, NULL
, 'C'},
333 {"disassemble", optional_argument
, NULL
, 'd'},
334 {"disassemble-all", no_argument
, NULL
, 'D'},
335 {"disassembler-options", required_argument
, NULL
, 'M'},
336 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
337 {"dynamic-reloc", no_argument
, NULL
, 'R'},
338 {"dynamic-syms", no_argument
, NULL
, 'T'},
339 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
340 {"file-headers", no_argument
, NULL
, 'f'},
341 {"file-offsets", no_argument
, NULL
, 'F'},
342 {"file-start-context", no_argument
, &file_start_context
, 1},
343 {"full-contents", no_argument
, NULL
, 's'},
344 {"headers", no_argument
, NULL
, 'h'},
345 {"help", no_argument
, NULL
, 'H'},
346 {"info", no_argument
, NULL
, 'i'},
347 {"line-numbers", no_argument
, NULL
, 'l'},
348 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
349 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
350 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
351 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
352 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
353 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
354 {"reloc", no_argument
, NULL
, 'r'},
355 {"section", required_argument
, NULL
, 'j'},
356 {"section-headers", no_argument
, NULL
, 'h'},
357 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
358 {"source", no_argument
, NULL
, 'S'},
359 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
360 {"special-syms", no_argument
, &dump_special_syms
, 1},
361 {"include", required_argument
, NULL
, 'I'},
362 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
363 {"ctf", required_argument
, NULL
, OPTION_CTF
},
364 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
365 {"stabs", no_argument
, NULL
, 'G'},
366 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
367 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
368 {"syms", no_argument
, NULL
, 't'},
369 {"target", required_argument
, NULL
, 'b'},
370 {"version", no_argument
, NULL
, 'V'},
371 {"wide", no_argument
, NULL
, 'w'},
372 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
373 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
374 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
375 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
376 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
377 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
378 {"inlines", no_argument
, 0, OPTION_INLINES
},
379 {0, no_argument
, 0, 0}
383 nonfatal (const char *msg
)
389 /* Returns a version of IN with any control characters
390 replaced by escape sequences. Uses a static buffer
394 sanitize_string (const char * in
)
396 static char * buffer
= NULL
;
397 static size_t buffer_len
= 0;
398 const char * original
= in
;
405 /* See if any conversion is necessary. In the majority
406 of cases it will not be needed. */
419 /* Copy the input, translating as needed. */
421 if (buffer_len
< (strlen (in
) * 2))
423 free ((void *) buffer
);
424 buffer_len
= strlen (in
) * 2;
425 buffer
= xmalloc (buffer_len
+ 1);
451 /* Returns TRUE if the specified section should be dumped. */
454 process_section_p (asection
* section
)
458 if (only_list
== NULL
)
461 for (only
= only_list
; only
; only
= only
->next
)
462 if (strcmp (only
->name
, section
->name
) == 0)
471 /* Add an entry to the 'only' list. */
474 add_only (char * name
)
478 /* First check to make sure that we do not
479 already have an entry for this name. */
480 for (only
= only_list
; only
; only
= only
->next
)
481 if (strcmp (only
->name
, name
) == 0)
484 only
= xmalloc (sizeof * only
);
487 only
->next
= only_list
;
491 /* Release the memory used by the 'only' list.
492 PR 11225: Issue a warning message for unseen sections.
493 Only do this if none of the sections were seen. This is mainly to support
494 tools like the GAS testsuite where an object file is dumped with a list of
495 generic section names known to be present in a range of different file
499 free_only_list (void)
501 bfd_boolean at_least_one_seen
= FALSE
;
505 if (only_list
== NULL
)
508 for (only
= only_list
; only
; only
= only
->next
)
511 at_least_one_seen
= TRUE
;
515 for (only
= only_list
; only
; only
= next
)
517 if (! at_least_one_seen
)
519 non_fatal (_("section '%s' mentioned in a -j option, "
520 "but not found in any input file"),
531 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
534 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
535 int longest_section_name
= *((int *) data
);
537 /* Ignore linker created section. See elfNN_ia64_object_p in
539 if (section
->flags
& SEC_LINKER_CREATED
)
542 /* PR 10413: Skip sections that we are ignoring. */
543 if (! process_section_p (section
))
546 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
547 sanitize_string (bfd_section_name (section
)),
548 (unsigned long) bfd_section_size (section
) / opb
);
549 bfd_printf_vma (abfd
, bfd_section_vma (section
));
551 bfd_printf_vma (abfd
, section
->lma
);
552 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
553 bfd_section_alignment (section
));
559 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
561 PF (SEC_HAS_CONTENTS
, "CONTENTS");
562 PF (SEC_ALLOC
, "ALLOC");
563 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
564 PF (SEC_LOAD
, "LOAD");
565 PF (SEC_RELOC
, "RELOC");
566 PF (SEC_READONLY
, "READONLY");
567 PF (SEC_CODE
, "CODE");
568 PF (SEC_DATA
, "DATA");
570 PF (SEC_DEBUGGING
, "DEBUGGING");
571 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
572 PF (SEC_EXCLUDE
, "EXCLUDE");
573 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
574 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
576 PF (SEC_TIC54X_BLOCK
, "BLOCK");
577 PF (SEC_TIC54X_CLINK
, "CLINK");
579 PF (SEC_SMALL_DATA
, "SMALL_DATA");
580 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
582 PF (SEC_COFF_SHARED
, "SHARED");
583 PF (SEC_COFF_NOREAD
, "NOREAD");
585 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
587 PF (SEC_ELF_OCTETS
, "OCTETS");
588 PF (SEC_ELF_PURECODE
, "PURECODE");
590 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
591 PF (SEC_GROUP
, "GROUP");
592 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
594 PF (SEC_MEP_VLIW
, "VLIW");
597 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
600 struct coff_comdat_info
*comdat
;
602 switch (section
->flags
& SEC_LINK_DUPLICATES
)
606 case SEC_LINK_DUPLICATES_DISCARD
:
607 ls
= "LINK_ONCE_DISCARD";
609 case SEC_LINK_DUPLICATES_ONE_ONLY
:
610 ls
= "LINK_ONCE_ONE_ONLY";
612 case SEC_LINK_DUPLICATES_SAME_SIZE
:
613 ls
= "LINK_ONCE_SAME_SIZE";
615 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
616 ls
= "LINK_ONCE_SAME_CONTENTS";
619 printf ("%s%s", comma
, ls
);
621 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
623 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
632 /* Called on each SECTION in ABFD, update the int variable pointed to by
633 DATA which contains the string length of the longest section name. */
636 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
637 asection
*section
, void *data
)
639 int *longest_so_far
= (int *) data
;
643 /* Ignore linker created section. */
644 if (section
->flags
& SEC_LINKER_CREATED
)
647 /* Skip sections that we are ignoring. */
648 if (! process_section_p (section
))
651 name
= bfd_section_name (section
);
652 len
= (int) strlen (name
);
653 if (len
> *longest_so_far
)
654 *longest_so_far
= len
;
658 dump_headers (bfd
*abfd
)
660 /* The default width of 13 is just an arbitrary choice. */
661 int max_section_name_length
= 13;
667 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
668 if (bfd_get_arch_size (abfd
) == 32)
674 printf (_("Sections:\n"));
677 bfd_map_over_sections (abfd
, find_longest_section_name
,
678 &max_section_name_length
);
680 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
681 max_section_name_length
, "Name",
682 bfd_vma_width
, "VMA",
683 bfd_vma_width
, "LMA");
686 printf (_(" Flags"));
689 bfd_map_over_sections (abfd
, dump_section_header
,
690 &max_section_name_length
);
694 slurp_symtab (bfd
*abfd
)
699 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
705 storage
= bfd_get_symtab_upper_bound (abfd
);
708 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
709 bfd_fatal (_("error message was"));
713 off_t filesize
= bfd_get_file_size (abfd
);
717 && filesize
< storage
718 /* The MMO file format supports its own special compression
719 technique, so its sections can be larger than the file size. */
720 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
722 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
723 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
724 storage
, (long) filesize
);
730 sy
= (asymbol
**) xmalloc (storage
);
733 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
735 bfd_fatal (bfd_get_filename (abfd
));
739 /* Read in the dynamic symbols. */
742 slurp_dynamic_symtab (bfd
*abfd
)
747 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
750 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
752 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
758 bfd_fatal (bfd_get_filename (abfd
));
761 sy
= (asymbol
**) xmalloc (storage
);
763 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
765 bfd_fatal (bfd_get_filename (abfd
));
769 /* Some symbol names are significant and should be kept in the
770 table of sorted symbol names, even if they are marked as
771 debugging/section symbols. */
774 is_significant_symbol_name (const char * name
)
776 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
779 /* Filter out (in place) symbols that are useless for disassembly.
780 COUNT is the number of elements in SYMBOLS.
781 Return the number of useful symbols. */
784 remove_useless_symbols (asymbol
**symbols
, long count
)
786 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
790 asymbol
*sym
= *in_ptr
++;
792 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
794 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
795 && ! is_significant_symbol_name (sym
->name
))
797 if (bfd_is_und_section (sym
->section
)
798 || bfd_is_com_section (sym
->section
))
803 return out_ptr
- symbols
;
806 static const asection
*compare_section
;
808 /* Sort symbols into value order. */
811 compare_symbols (const void *ap
, const void *bp
)
813 const asymbol
*a
= * (const asymbol
**) ap
;
814 const asymbol
*b
= * (const asymbol
**) bp
;
819 bfd_boolean as
, af
, bs
, bf
;
823 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
825 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
828 /* Prefer symbols from the section currently being disassembled.
829 Don't sort symbols from other sections by section, since there
830 isn't much reason to prefer one section over another otherwise.
831 See sym_ok comment for why we compare by section name. */
832 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
833 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
839 an
= bfd_asymbol_name (a
);
840 bn
= bfd_asymbol_name (b
);
844 /* The symbols gnu_compiled and gcc2_compiled convey no real
845 information, so put them after other symbols with the same value. */
846 af
= (strstr (an
, "gnu_compiled") != NULL
847 || strstr (an
, "gcc2_compiled") != NULL
);
848 bf
= (strstr (bn
, "gnu_compiled") != NULL
849 || strstr (bn
, "gcc2_compiled") != NULL
);
856 /* We use a heuristic for the file name, to try to sort it after
857 more useful symbols. It may not work on non Unix systems, but it
858 doesn't really matter; the only difference is precisely which
859 symbol names get printed. */
861 #define file_symbol(s, sn, snl) \
862 (((s)->flags & BSF_FILE) != 0 \
864 && (sn)[(snl) - 2] == '.' \
865 && ((sn)[(snl) - 1] == 'o' \
866 || (sn)[(snl) - 1] == 'a')))
868 af
= file_symbol (a
, an
, anl
);
869 bf
= file_symbol (b
, bn
, bnl
);
876 /* Sort function and object symbols before global symbols before
877 local symbols before section symbols before debugging symbols. */
882 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
884 if ((aflags
& BSF_DEBUGGING
) != 0)
889 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
891 if ((aflags
& BSF_SECTION_SYM
) != 0)
896 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
898 if ((aflags
& BSF_FUNCTION
) != 0)
903 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
905 if ((aflags
& BSF_OBJECT
) != 0)
910 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
912 if ((aflags
& BSF_LOCAL
) != 0)
917 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
919 if ((aflags
& BSF_GLOBAL
) != 0)
925 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
926 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
931 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
932 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
934 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
935 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
937 return asz
> bsz
? -1 : 1;
940 /* Symbols that start with '.' might be section names, so sort them
941 after symbols that don't start with '.'. */
942 if (an
[0] == '.' && bn
[0] != '.')
944 if (an
[0] != '.' && bn
[0] == '.')
947 /* Finally, if we can't distinguish them in any other way, try to
948 get consistent results by sorting the symbols by name. */
949 return strcmp (an
, bn
);
952 /* Sort relocs into address order. */
955 compare_relocs (const void *ap
, const void *bp
)
957 const arelent
*a
= * (const arelent
**) ap
;
958 const arelent
*b
= * (const arelent
**) bp
;
960 if (a
->address
> b
->address
)
962 else if (a
->address
< b
->address
)
965 /* So that associated relocations tied to the same address show up
966 in the correct order, we don't do any further sorting. */
975 /* Print an address (VMA) to the output stream in INFO.
976 If SKIP_ZEROES is TRUE, omit leading zeroes. */
979 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
980 bfd_boolean skip_zeroes
)
984 struct objdump_disasm_info
*aux
;
986 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
987 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
992 for (p
= buf
; *p
== '0'; ++p
)
997 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1000 /* Print the name of a symbol. */
1003 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1007 const char *name
, *version_string
= NULL
;
1008 bfd_boolean hidden
= FALSE
;
1011 name
= bfd_asymbol_name (sym
);
1012 if (do_demangle
&& name
[0] != '\0')
1014 /* Demangle the name. */
1015 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1020 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1021 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1023 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1026 name
= sanitize_string (name
);
1030 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1031 if (version_string
&& *version_string
!= '\0')
1032 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1037 printf ("%s", name
);
1038 if (version_string
&& *version_string
!= '\0')
1039 printf (hidden
? "@%s" : "@@%s", version_string
);
1046 static inline bfd_boolean
1047 sym_ok (bfd_boolean want_section
,
1048 bfd
* abfd ATTRIBUTE_UNUSED
,
1051 struct disassemble_info
* inf
)
1055 /* Note - we cannot just compare section pointers because they could
1056 be different, but the same... Ie the symbol that we are trying to
1057 find could have come from a separate debug info file. Under such
1058 circumstances the symbol will be associated with a section in the
1059 debug info file, whilst the section we want is in a normal file.
1060 So the section pointers will be different, but the section names
1061 will be the same. */
1062 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1063 bfd_section_name (sec
)) != 0)
1067 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1070 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1071 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1072 require the symbol to be in the section. Returns NULL if there is no
1073 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1074 of the symbol in sorted_syms. */
1077 find_symbol_for_address (bfd_vma vma
,
1078 struct disassemble_info
*inf
,
1081 /* @@ Would it speed things up to cache the last two symbols returned,
1082 and maybe their address ranges? For many processors, only one memory
1083 operand can be present at a time, so the 2-entry cache wouldn't be
1084 constantly churned by code doing heavy memory accesses. */
1086 /* Indices in `sorted_syms'. */
1088 long max_count
= sorted_symcount
;
1090 struct objdump_disasm_info
*aux
;
1094 bfd_boolean want_section
;
1097 if (sorted_symcount
< 1)
1100 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1103 opb
= inf
->octets_per_byte
;
1105 /* Perform a binary search looking for the closest symbol to the
1106 required value. We are searching the range (min, max_count]. */
1107 while (min
+ 1 < max_count
)
1111 thisplace
= (max_count
+ min
) / 2;
1112 sym
= sorted_syms
[thisplace
];
1114 if (bfd_asymbol_value (sym
) > vma
)
1115 max_count
= thisplace
;
1116 else if (bfd_asymbol_value (sym
) < vma
)
1125 /* The symbol we want is now in min, the low end of the range we
1126 were searching. If there are several symbols with the same
1127 value, we want the first one. */
1129 while (thisplace
> 0
1130 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1131 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1134 /* Prefer a symbol in the current section if we have multple symbols
1135 with the same value, as can occur with overlays or zero size
1138 while (min
< max_count
1139 && (bfd_asymbol_value (sorted_syms
[min
])
1140 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1142 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1149 return sorted_syms
[thisplace
];
1154 /* If the file is relocatable, and the symbol could be from this
1155 section, prefer a symbol from this section over symbols from
1156 others, even if the other symbol's value might be closer.
1158 Note that this may be wrong for some symbol references if the
1159 sections have overlapping memory ranges, but in that case there's
1160 no way to tell what's desired without looking at the relocation
1163 Also give the target a chance to reject symbols. */
1164 want_section
= (aux
->require_sec
1165 || ((abfd
->flags
& HAS_RELOC
) != 0
1166 && vma
>= bfd_section_vma (sec
)
1167 && vma
< (bfd_section_vma (sec
)
1168 + bfd_section_size (sec
) / opb
)));
1170 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1173 long newplace
= sorted_symcount
;
1175 for (i
= min
- 1; i
>= 0; i
--)
1177 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1179 if (newplace
== sorted_symcount
)
1182 if (bfd_asymbol_value (sorted_syms
[i
])
1183 != bfd_asymbol_value (sorted_syms
[newplace
]))
1186 /* Remember this symbol and keep searching until we reach
1187 an earlier address. */
1192 if (newplace
!= sorted_symcount
)
1193 thisplace
= newplace
;
1196 /* We didn't find a good symbol with a smaller value.
1197 Look for one with a larger value. */
1198 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1200 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1208 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1209 /* There is no suitable symbol. */
1213 /* If we have not found an exact match for the specified address
1214 and we have dynamic relocations available, then we can produce
1215 a better result by matching a relocation to the address and
1216 using the symbol associated with that relocation. */
1217 rel_count
= aux
->dynrelcount
;
1219 && sorted_syms
[thisplace
]->value
!= vma
1221 && aux
->dynrelbuf
!= NULL
1222 && aux
->dynrelbuf
[0]->address
<= vma
1223 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1224 /* If we have matched a synthetic symbol, then stick with that. */
1225 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1228 arelent
** rel_high
;
1230 rel_low
= aux
->dynrelbuf
;
1231 rel_high
= rel_low
+ rel_count
- 1;
1232 while (rel_low
<= rel_high
)
1234 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1235 arelent
* rel
= *rel_mid
;
1237 if (rel
->address
== vma
)
1239 /* Absolute relocations do not provide a more helpful
1240 symbolic address. Find a non-absolute relocation
1241 with the same address. */
1242 arelent
**rel_vma
= rel_mid
;
1244 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1248 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1252 if (rel
->sym_ptr_ptr
!= NULL
1253 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1256 * place
= thisplace
;
1257 return * rel
->sym_ptr_ptr
;
1263 if (vma
< rel
->address
)
1265 else if (vma
>= rel_mid
[1]->address
)
1266 rel_low
= rel_mid
+ 1;
1275 return sorted_syms
[thisplace
];
1278 /* Print an address and the offset to the nearest symbol. */
1281 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1282 bfd_vma vma
, struct disassemble_info
*inf
,
1283 bfd_boolean skip_zeroes
)
1285 objdump_print_value (vma
, inf
, skip_zeroes
);
1291 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1292 sanitize_string (bfd_section_name (sec
)));
1293 secaddr
= bfd_section_vma (sec
);
1296 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1297 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1299 else if (vma
> secaddr
)
1301 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1302 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1304 (*inf
->fprintf_func
) (inf
->stream
, ">");
1308 (*inf
->fprintf_func
) (inf
->stream
, " <");
1310 objdump_print_symname (abfd
, inf
, sym
);
1312 if (bfd_asymbol_value (sym
) == vma
)
1314 /* Undefined symbols in an executables and dynamic objects do not have
1315 a value associated with them, so it does not make sense to display
1316 an offset relative to them. Normally we would not be provided with
1317 this kind of symbol, but the target backend might choose to do so,
1318 and the code in find_symbol_for_address might return an as yet
1319 unresolved symbol associated with a dynamic reloc. */
1320 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1321 && bfd_is_und_section (sym
->section
))
1323 else if (bfd_asymbol_value (sym
) > vma
)
1325 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1326 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1328 else if (vma
> bfd_asymbol_value (sym
))
1330 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1331 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1334 (*inf
->fprintf_func
) (inf
->stream
, ">");
1337 if (display_file_offsets
)
1338 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1339 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1342 /* Print an address (VMA), symbolically if possible.
1343 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1346 objdump_print_addr (bfd_vma vma
,
1347 struct disassemble_info
*inf
,
1348 bfd_boolean skip_zeroes
)
1350 struct objdump_disasm_info
*aux
;
1351 asymbol
*sym
= NULL
;
1352 bfd_boolean skip_find
= FALSE
;
1354 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1356 if (sorted_symcount
< 1)
1358 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1359 objdump_print_value (vma
, inf
, skip_zeroes
);
1361 if (display_file_offsets
)
1362 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1363 (long int) (inf
->section
->filepos
1364 + (vma
- inf
->section
->vma
)));
1368 if (aux
->reloc
!= NULL
1369 && aux
->reloc
->sym_ptr_ptr
!= NULL
1370 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1372 sym
= * aux
->reloc
->sym_ptr_ptr
;
1374 /* Adjust the vma to the reloc. */
1375 vma
+= bfd_asymbol_value (sym
);
1377 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1382 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1384 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1388 /* Print VMA to INFO. This function is passed to the disassembler
1392 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1394 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1397 /* Determine if the given address has a symbol associated with it. */
1400 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1404 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1406 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1409 /* Hold the last function name and the last line number we displayed
1410 in a disassembly. */
1412 static char *prev_functionname
;
1413 static unsigned int prev_line
;
1414 static unsigned int prev_discriminator
;
1416 /* We keep a list of all files that we have seen when doing a
1417 disassembly with source, so that we know how much of the file to
1418 display. This can be important for inlined functions. */
1420 struct print_file_list
1422 struct print_file_list
*next
;
1423 const char *filename
;
1424 const char *modname
;
1427 const char **linemap
;
1430 unsigned max_printed
;
1434 static struct print_file_list
*print_files
;
1436 /* The number of preceding context lines to show when we start
1437 displaying a file for the first time. */
1439 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1441 /* Read a complete file into memory. */
1444 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1447 int ps
= getpagesize ();
1451 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1455 if (fstat (fd
, fst
) < 0)
1460 *size
= fst
->st_size
;
1462 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1463 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1464 if (map
!= (char *) -1L)
1470 map
= (const char *) malloc (*size
);
1471 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1473 free ((void *) map
);
1480 #define line_map_decrease 5
1482 /* Precompute array of lines for a mapped file. */
1484 static const char **
1485 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1487 const char *p
, *lstart
, *end
;
1488 int chars_per_line
= 45; /* First iteration will use 40. */
1489 unsigned int lineno
;
1490 const char **linemap
= NULL
;
1491 unsigned long line_map_size
= 0;
1497 for (p
= map
; p
< end
; p
++)
1501 if (p
+ 1 < end
&& p
[1] == '\r')
1504 else if (*p
== '\r')
1506 if (p
+ 1 < end
&& p
[1] == '\n')
1512 /* End of line found. */
1514 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1516 unsigned long newsize
;
1518 chars_per_line
-= line_map_decrease
;
1519 if (chars_per_line
<= 1)
1521 line_map_size
= size
/ chars_per_line
+ 1;
1522 if (line_map_size
< lineno
+ 1)
1523 line_map_size
= lineno
+ 1;
1524 newsize
= line_map_size
* sizeof (char *);
1525 linemap
= (const char **) xrealloc (linemap
, newsize
);
1528 linemap
[lineno
++] = lstart
;
1536 /* Tries to open MODNAME, and if successful adds a node to print_files
1537 linked list and returns that node. Returns NULL on failure. */
1539 static struct print_file_list
*
1540 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1542 struct print_file_list
*p
;
1544 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1546 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1553 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1556 p
->filename
= origname
;
1557 p
->modname
= modname
;
1558 p
->next
= print_files
;
1564 /* If the source file, as described in the symtab, is not found
1565 try to locate it in one of the paths specified with -I
1566 If found, add location to print_files linked list. */
1568 static struct print_file_list
*
1569 update_source_path (const char *filename
, bfd
*abfd
)
1571 struct print_file_list
*p
;
1576 p
= try_print_file_open (filename
, filename
, &fst
);
1579 if (include_path_count
== 0)
1582 /* Get the name of the file. */
1583 fname
= lbasename (filename
);
1585 /* If file exists under a new path, we need to add it to the list
1586 so that show_line knows about it. */
1587 for (i
= 0; i
< include_path_count
; i
++)
1589 char *modname
= concat (include_paths
[i
], "/", fname
,
1592 p
= try_print_file_open (filename
, modname
, &fst
);
1602 long mtime
= bfd_get_mtime (abfd
);
1604 if (fst
.st_mtime
> mtime
)
1605 warn (_("source file %s is more recent than object file\n"),
1612 /* Print a source file line. */
1615 print_line (struct print_file_list
*p
, unsigned int linenum
)
1621 if (linenum
>= p
->maxline
)
1623 l
= p
->linemap
[linenum
];
1624 if (source_comment
!= NULL
&& strlen (l
) > 0)
1625 printf ("%s", source_comment
);
1626 len
= strcspn (l
, "\n\r");
1627 /* Test fwrite return value to quiet glibc warning. */
1628 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1632 /* Print a range of source code lines. */
1635 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1639 while (start
<= end
)
1641 print_line (p
, start
);
1646 /* Show the line number, or the source line, in a disassembly
1650 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1652 const char *filename
;
1653 const char *functionname
;
1654 unsigned int linenumber
;
1655 unsigned int discriminator
;
1659 if (! with_line_numbers
&& ! with_source_code
)
1662 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1663 &filename
, &functionname
,
1664 &linenumber
, &discriminator
))
1667 if (filename
!= NULL
&& *filename
== '\0')
1669 if (functionname
!= NULL
&& *functionname
== '\0')
1670 functionname
= NULL
;
1673 && IS_ABSOLUTE_PATH (filename
)
1677 const char *fname
= filename
;
1679 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1682 memcpy (path
, prefix
, prefix_length
);
1683 path_up
= path
+ prefix_length
;
1685 /* Build relocated filename, stripping off leading directories
1686 from the initial filename if requested. */
1687 if (prefix_strip
> 0)
1692 /* Skip selected directory levels. */
1693 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1694 if (IS_DIR_SEPARATOR(*s
))
1701 /* Update complete filename. */
1702 strncpy (path_up
, fname
, PATH_MAX
);
1703 path_up
[PATH_MAX
] = '\0';
1711 if (with_line_numbers
)
1713 if (functionname
!= NULL
1714 && (prev_functionname
== NULL
1715 || strcmp (functionname
, prev_functionname
) != 0))
1717 printf ("%s():\n", sanitize_string (functionname
));
1721 && (linenumber
!= prev_line
1722 || discriminator
!= prev_discriminator
))
1724 if (discriminator
> 0)
1725 printf ("%s:%u (discriminator %u)\n",
1726 filename
== NULL
? "???" : sanitize_string (filename
),
1727 linenumber
, discriminator
);
1729 printf ("%s:%u\n", filename
== NULL
1730 ? "???" : sanitize_string (filename
),
1735 const char *filename2
;
1736 const char *functionname2
;
1739 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1742 printf ("inlined by %s:%u",
1743 sanitize_string (filename2
), line2
);
1744 printf (" (%s)\n", sanitize_string (functionname2
));
1749 if (with_source_code
1753 struct print_file_list
**pp
, *p
;
1756 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1757 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1764 filename
= xstrdup (filename
);
1765 p
= update_source_path (filename
, abfd
);
1768 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1770 if (file_start_context
&& p
->first
)
1774 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1775 if (l
>= linenumber
)
1777 if (p
->max_printed
>= l
)
1779 if (p
->max_printed
< linenumber
)
1780 l
= p
->max_printed
+ 1;
1785 dump_lines (p
, l
, linenumber
);
1786 if (p
->max_printed
< linenumber
)
1787 p
->max_printed
= linenumber
;
1788 p
->last_line
= linenumber
;
1793 if (functionname
!= NULL
1794 && (prev_functionname
== NULL
1795 || strcmp (functionname
, prev_functionname
) != 0))
1797 if (prev_functionname
!= NULL
)
1798 free (prev_functionname
);
1799 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1800 strcpy (prev_functionname
, functionname
);
1803 if (linenumber
> 0 && linenumber
!= prev_line
)
1804 prev_line
= linenumber
;
1806 if (discriminator
!= prev_discriminator
)
1807 prev_discriminator
= discriminator
;
1813 /* Pseudo FILE object for strings. */
1821 /* sprintf to a "stream". */
1823 static int ATTRIBUTE_PRINTF_2
1824 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1831 size_t space
= f
->alloc
- f
->pos
;
1833 va_start (args
, format
);
1834 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1840 f
->alloc
= (f
->alloc
+ n
) * 2;
1841 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1848 /* The number of zeroes we want to see before we start skipping them.
1849 The number is arbitrarily chosen. */
1851 #define DEFAULT_SKIP_ZEROES 8
1853 /* The number of zeroes to skip at the end of a section. If the
1854 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1855 SKIP_ZEROES, they will be disassembled. If there are fewer than
1856 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1857 attempt to avoid disassembling zeroes inserted by section
1860 #define DEFAULT_SKIP_ZEROES_AT_END 3
1863 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1868 /* Disassemble some data in memory between given values. */
1871 disassemble_bytes (struct disassemble_info
* inf
,
1872 disassembler_ftype disassemble_fn
,
1875 bfd_vma start_offset
,
1876 bfd_vma stop_offset
,
1879 arelent
** relppend
)
1881 struct objdump_disasm_info
*aux
;
1883 int octets_per_line
;
1884 int skip_addr_chars
;
1885 bfd_vma addr_offset
;
1886 unsigned int opb
= inf
->octets_per_byte
;
1887 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1888 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1892 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1893 section
= inf
->section
;
1896 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1900 octets_per_line
= insn_width
;
1902 octets_per_line
= 4;
1904 octets_per_line
= 16;
1906 /* Figure out how many characters to skip at the start of an
1907 address, to make the disassembly look nicer. We discard leading
1908 zeroes in chunks of 4, ensuring that there is always a leading
1910 skip_addr_chars
= 0;
1911 if (! prefix_addresses
)
1915 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1917 while (buf
[skip_addr_chars
] == '0')
1920 /* Don't discard zeros on overflow. */
1921 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1922 skip_addr_chars
= 0;
1924 if (skip_addr_chars
!= 0)
1925 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1928 inf
->insn_info_valid
= 0;
1930 addr_offset
= start_offset
;
1931 while (addr_offset
< stop_offset
)
1934 bfd_boolean need_nl
= FALSE
;
1938 /* Make sure we don't use relocs from previous instructions. */
1941 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1943 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1946 if (! disassemble_zeroes
1947 && (inf
->insn_info_valid
== 0
1948 || inf
->branch_delay_insns
== 0)
1949 && (z
- addr_offset
* opb
>= skip_zeroes
1950 || (z
== stop_offset
* opb
&&
1951 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1953 /* If there are more nonzero octets to follow, we only skip
1954 zeroes in multiples of 4, to try to avoid running over
1955 the start of an instruction which happens to start with
1957 if (z
!= stop_offset
* opb
)
1958 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1960 octets
= z
- addr_offset
* opb
;
1962 /* If we are going to display more data, and we are displaying
1963 file offsets, then tell the user how many zeroes we skip
1964 and the file offset from where we resume dumping. */
1965 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1966 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1968 (unsigned long) (section
->filepos
1969 + (addr_offset
+ (octets
/ opb
))));
1979 if (with_line_numbers
|| with_source_code
)
1980 show_line (aux
->abfd
, section
, addr_offset
);
1982 if (! prefix_addresses
)
1986 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1987 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1991 printf ("%s:\t", buf
+ skip_addr_chars
);
1995 aux
->require_sec
= TRUE
;
1996 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1997 aux
->require_sec
= FALSE
;
2004 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2005 inf
->stream
= &sfile
;
2006 inf
->bytes_per_line
= 0;
2007 inf
->bytes_per_chunk
= 0;
2008 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2009 | (wide_output
? WIDE_OUTPUT
: 0));
2011 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2013 if (inf
->disassembler_needs_relocs
2014 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2015 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2016 && *relppp
< relppend
)
2018 bfd_signed_vma distance_to_rel
;
2020 int max_reloc_offset
2021 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2023 distance_to_rel
= ((**relppp
)->address
- rel_offset
2026 if (distance_to_rel
> 0
2027 && (max_reloc_offset
< 0
2028 || distance_to_rel
<= max_reloc_offset
))
2030 /* This reloc *might* apply to the current insn,
2031 starting somewhere inside it. Discover the length
2032 of the current insn so that the check below will
2035 insn_size
= insn_width
;
2038 /* We find the length by calling the dissassembler
2039 function with a dummy print handler. This should
2040 work unless the disassembler is not expecting to
2041 be called multiple times for the same address.
2043 This does mean disassembling the instruction
2044 twice, but we only do this when there is a high
2045 probability that there is a reloc that will
2046 affect the instruction. */
2047 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2048 insn_size
= disassemble_fn (section
->vma
2049 + addr_offset
, inf
);
2050 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2054 /* Check to see if the current reloc is associated with
2055 the instruction that we are about to disassemble. */
2056 if (distance_to_rel
== 0
2057 || (distance_to_rel
> 0
2058 && distance_to_rel
< insn_size
/ (int) opb
))
2060 inf
->flags
|= INSN_HAS_RELOC
;
2061 aux
->reloc
= **relppp
;
2065 if (! disassemble_all
2066 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2067 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2068 /* Set a stop_vma so that the disassembler will not read
2069 beyond the next symbol. We assume that symbols appear on
2070 the boundaries between instructions. We only do this when
2071 disassembling code of course, and when -D is in effect. */
2072 inf
->stop_vma
= section
->vma
+ stop_offset
;
2074 inf
->stop_offset
= stop_offset
;
2075 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2078 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2079 inf
->stream
= stdout
;
2080 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2081 octets_per_line
= inf
->bytes_per_line
;
2082 if (octets
< (int) opb
)
2085 printf ("%s\n", sfile
.buffer
);
2088 non_fatal (_("disassemble_fn returned length %d"),
2099 octets
= octets_per_line
;
2100 if (addr_offset
+ octets
/ opb
> stop_offset
)
2101 octets
= (stop_offset
- addr_offset
) * opb
;
2103 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2105 if (ISPRINT (data
[j
]))
2106 buf
[j
- addr_offset
* opb
] = data
[j
];
2108 buf
[j
- addr_offset
* opb
] = '.';
2110 buf
[j
- addr_offset
* opb
] = '\0';
2113 if (prefix_addresses
2115 : show_raw_insn
>= 0)
2119 /* If ! prefix_addresses and ! wide_output, we print
2120 octets_per_line octets per line. */
2122 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2123 pb
= octets_per_line
;
2125 if (inf
->bytes_per_chunk
)
2126 bpc
= inf
->bytes_per_chunk
;
2130 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2132 /* PR 21580: Check for a buffer ending early. */
2133 if (j
+ bpc
<= stop_offset
* opb
)
2137 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2139 for (k
= bpc
- 1; k
>= 0; k
--)
2140 printf ("%02x", (unsigned) data
[j
+ k
]);
2144 for (k
= 0; k
< bpc
; k
++)
2145 printf ("%02x", (unsigned) data
[j
+ k
]);
2151 for (; pb
< octets_per_line
; pb
+= bpc
)
2155 for (k
= 0; k
< bpc
; k
++)
2160 /* Separate raw data from instruction by extra space. */
2170 printf ("%s", sfile
.buffer
);
2172 if (prefix_addresses
2174 : show_raw_insn
>= 0)
2182 j
= addr_offset
* opb
+ pb
;
2184 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2185 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2189 printf ("%s:\t", buf
+ skip_addr_chars
);
2191 pb
+= octets_per_line
;
2194 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2196 /* PR 21619: Check for a buffer ending early. */
2197 if (j
+ bpc
<= stop_offset
* opb
)
2201 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2203 for (k
= bpc
- 1; k
>= 0; k
--)
2204 printf ("%02x", (unsigned) data
[j
+ k
]);
2208 for (k
= 0; k
< bpc
; k
++)
2209 printf ("%02x", (unsigned) data
[j
+ k
]);
2223 while ((*relppp
) < relppend
2224 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2226 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2237 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2240 if (q
->howto
== NULL
)
2241 printf (": *unknown*\t");
2242 else if (q
->howto
->name
)
2243 printf (": %s\t", q
->howto
->name
);
2245 printf (": %d\t", q
->howto
->type
);
2247 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2248 printf ("*unknown*");
2251 const char *sym_name
;
2253 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2254 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2255 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2260 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2261 sym_name
= bfd_section_name (sym_sec
);
2262 if (sym_name
== NULL
|| *sym_name
== '\0')
2263 sym_name
= "*unknown*";
2264 printf ("%s", sanitize_string (sym_name
));
2270 bfd_signed_vma addend
= q
->addend
;
2278 objdump_print_value (addend
, inf
, TRUE
);
2290 addr_offset
+= octets
/ opb
;
2293 free (sfile
.buffer
);
2297 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2299 const struct elf_backend_data
* bed
;
2300 bfd_vma sign_adjust
= 0;
2301 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2302 struct objdump_disasm_info
* paux
;
2303 unsigned int opb
= pinfo
->octets_per_byte
;
2304 bfd_byte
* data
= NULL
;
2305 bfd_size_type datasize
= 0;
2306 arelent
** rel_pp
= NULL
;
2307 arelent
** rel_ppstart
= NULL
;
2308 arelent
** rel_ppend
;
2309 bfd_vma stop_offset
;
2310 asymbol
* sym
= NULL
;
2314 unsigned long addr_offset
;
2315 bfd_boolean do_print
;
2318 stop_offset_reached
,
2323 /* Sections that do not contain machine
2324 code are not normally disassembled. */
2325 if (! disassemble_all
2326 && only_list
== NULL
2327 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2328 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2331 if (! process_section_p (section
))
2334 datasize
= bfd_section_size (section
);
2338 if (start_address
== (bfd_vma
) -1
2339 || start_address
< section
->vma
)
2342 addr_offset
= start_address
- section
->vma
;
2344 if (stop_address
== (bfd_vma
) -1)
2345 stop_offset
= datasize
/ opb
;
2348 if (stop_address
< section
->vma
)
2351 stop_offset
= stop_address
- section
->vma
;
2352 if (stop_offset
> datasize
/ opb
)
2353 stop_offset
= datasize
/ opb
;
2356 if (addr_offset
>= stop_offset
)
2359 /* Decide which set of relocs to use. Load them if necessary. */
2360 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2361 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2363 rel_pp
= paux
->dynrelbuf
;
2364 rel_count
= paux
->dynrelcount
;
2365 /* Dynamic reloc addresses are absolute, non-dynamic are section
2366 relative. REL_OFFSET specifies the reloc address corresponding
2367 to the start of this section. */
2368 rel_offset
= section
->vma
;
2376 if ((section
->flags
& SEC_RELOC
) != 0
2377 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2381 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2383 bfd_fatal (bfd_get_filename (abfd
));
2387 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2388 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2390 bfd_fatal (bfd_get_filename (abfd
));
2392 /* Sort the relocs by address. */
2393 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2397 rel_ppend
= rel_pp
+ rel_count
;
2399 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2401 non_fatal (_("Reading section %s failed because: %s"),
2402 section
->name
, bfd_errmsg (bfd_get_error ()));
2406 pinfo
->buffer
= data
;
2407 pinfo
->buffer_vma
= section
->vma
;
2408 pinfo
->buffer_length
= datasize
;
2409 pinfo
->section
= section
;
2411 /* Sort the symbols into value and section order. */
2412 compare_section
= section
;
2413 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2415 /* Skip over the relocs belonging to addresses below the
2417 while (rel_pp
< rel_ppend
2418 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2421 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2423 /* Find the nearest symbol forwards from our current position. */
2424 paux
->require_sec
= TRUE
;
2425 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2426 (struct disassemble_info
*) inf
,
2428 paux
->require_sec
= FALSE
;
2430 /* PR 9774: If the target used signed addresses then we must make
2431 sure that we sign extend the value that we calculate for 'addr'
2432 in the loop below. */
2433 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2434 && (bed
= get_elf_backend_data (abfd
)) != NULL
2435 && bed
->sign_extend_vma
)
2436 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2438 /* Disassemble a block of instructions up to the address associated with
2439 the symbol we have just found. Then print the symbol and find the
2440 next symbol on. Repeat until we have disassembled the entire section
2441 or we have reached the end of the address range we are interested in. */
2442 do_print
= paux
->symbol
== NULL
;
2443 loop_until
= stop_offset_reached
;
2445 while (addr_offset
< stop_offset
)
2449 bfd_vma nextstop_offset
;
2452 addr
= section
->vma
+ addr_offset
;
2453 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2455 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2460 (x
< sorted_symcount
2461 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2465 pinfo
->symbols
= sorted_syms
+ place
;
2466 pinfo
->num_symbols
= x
- place
;
2467 pinfo
->symtab_pos
= place
;
2471 pinfo
->symbols
= NULL
;
2472 pinfo
->num_symbols
= 0;
2473 pinfo
->symtab_pos
= -1;
2476 /* If we are only disassembling from a specific symbol,
2477 check to see if we should start or stop displaying. */
2478 if (sym
&& paux
->symbol
)
2482 /* See if we should stop printing. */
2486 if (sym
->flags
& BSF_FUNCTION
)
2490 case stop_offset_reached
:
2491 /* Handled by the while loop. */
2495 /* FIXME: There is an implicit assumption here
2496 that the name of sym is different from
2498 if (! bfd_is_local_label (abfd
, sym
))
2505 const char * name
= bfd_asymbol_name (sym
);
2506 char * alloc
= NULL
;
2508 if (do_demangle
&& name
[0] != '\0')
2510 /* Demangle the name. */
2511 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2516 /* We are not currently printing. Check to see
2517 if the current symbol matches the requested symbol. */
2518 if (streq (name
, paux
->symbol
))
2522 if (sym
->flags
& BSF_FUNCTION
)
2524 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2525 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2527 /* Sym is a function symbol with a size associated
2528 with it. Turn on automatic disassembly for the
2529 next VALUE bytes. */
2530 stop_offset
= addr_offset
2531 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2532 loop_until
= stop_offset_reached
;
2536 /* Otherwise we need to tell the loop heuristic to
2537 loop until the next function symbol is encountered. */
2538 loop_until
= function_sym
;
2543 /* Otherwise loop until the next symbol is encountered. */
2544 loop_until
= next_sym
;
2552 if (! prefix_addresses
&& do_print
)
2554 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2555 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2557 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2560 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2562 else if (sym
== NULL
)
2566 #define is_valid_next_sym(SYM) \
2567 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
2568 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2569 && pinfo->symbol_is_valid (SYM, pinfo))
2571 /* Search forward for the next appropriate symbol in
2572 SECTION. Note that all the symbols are sorted
2573 together into one big array, and that some sections
2574 may have overlapping addresses. */
2575 while (place
< sorted_symcount
2576 && ! is_valid_next_sym (sorted_syms
[place
]))
2579 if (place
>= sorted_symcount
)
2582 nextsym
= sorted_syms
[place
];
2585 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2586 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2587 else if (nextsym
== NULL
)
2588 nextstop_offset
= stop_offset
;
2590 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2592 if (nextstop_offset
> stop_offset
2593 || nextstop_offset
<= addr_offset
)
2594 nextstop_offset
= stop_offset
;
2596 /* If a symbol is explicitly marked as being an object
2597 rather than a function, just dump the bytes without
2598 disassembling them. */
2601 || sym
->section
!= section
2602 || bfd_asymbol_value (sym
) > addr
2603 || ((sym
->flags
& BSF_OBJECT
) == 0
2604 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2606 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2608 || (sym
->flags
& BSF_FUNCTION
) != 0)
2614 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2615 addr_offset
, nextstop_offset
,
2616 rel_offset
, &rel_pp
, rel_ppend
);
2618 addr_offset
= nextstop_offset
;
2624 if (rel_ppstart
!= NULL
)
2628 /* Disassemble the contents of an object file. */
2631 disassemble_data (bfd
*abfd
)
2633 struct disassemble_info disasm_info
;
2634 struct objdump_disasm_info aux
;
2638 prev_functionname
= NULL
;
2640 prev_discriminator
= 0;
2642 /* We make a copy of syms to sort. We don't want to sort syms
2643 because that will screw up the relocs. */
2644 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2645 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2646 * sizeof (asymbol
*));
2647 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2648 sorted_symcount
* sizeof (asymbol
*));
2650 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2652 for (i
= 0; i
< synthcount
; ++i
)
2654 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2658 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2660 disasm_info
.application_data
= (void *) &aux
;
2662 aux
.require_sec
= FALSE
;
2663 aux
.dynrelbuf
= NULL
;
2664 aux
.dynrelcount
= 0;
2666 aux
.symbol
= disasm_sym
;
2668 disasm_info
.print_address_func
= objdump_print_address
;
2669 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2671 if (machine
!= NULL
)
2673 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2676 fatal (_("can't use supplied machine %s"), machine
);
2678 abfd
->arch_info
= inf
;
2681 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2683 struct bfd_target
*xvec
;
2685 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2686 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2687 xvec
->byteorder
= endian
;
2691 /* Use libopcodes to locate a suitable disassembler. */
2692 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2693 bfd_big_endian (abfd
),
2694 bfd_get_mach (abfd
), abfd
);
2695 if (!aux
.disassemble_fn
)
2697 non_fatal (_("can't disassemble for architecture %s\n"),
2698 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2703 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2704 disasm_info
.arch
= bfd_get_arch (abfd
);
2705 disasm_info
.mach
= bfd_get_mach (abfd
);
2706 disasm_info
.disassembler_options
= disassembler_options
;
2707 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
2708 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2709 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2710 disasm_info
.disassembler_needs_relocs
= FALSE
;
2712 if (bfd_big_endian (abfd
))
2713 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2714 else if (bfd_little_endian (abfd
))
2715 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2717 /* ??? Aborting here seems too drastic. We could default to big or little
2719 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2721 /* Allow the target to customize the info structure. */
2722 disassemble_init_for_target (& disasm_info
);
2724 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2726 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2728 if (relsize
< 0 && dump_dynamic_reloc_info
)
2729 bfd_fatal (bfd_get_filename (abfd
));
2733 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2734 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2737 if (aux
.dynrelcount
< 0)
2738 bfd_fatal (bfd_get_filename (abfd
));
2740 /* Sort the relocs by address. */
2741 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2745 disasm_info
.symtab
= sorted_syms
;
2746 disasm_info
.symtab_size
= sorted_symcount
;
2748 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2750 if (aux
.dynrelbuf
!= NULL
)
2751 free (aux
.dynrelbuf
);
2753 disassemble_free_target (&disasm_info
);
2757 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2758 asection
*sec
, void *file
)
2760 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2761 bfd
*abfd
= (bfd
*) file
;
2766 if (section
->start
!= NULL
)
2768 /* If it is already loaded, do nothing. */
2769 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2771 free (section
->start
);
2774 section
->filename
= bfd_get_filename (abfd
);
2775 section
->reloc_info
= NULL
;
2776 section
->num_relocs
= 0;
2777 section
->address
= bfd_section_vma (sec
);
2778 section
->user_data
= sec
;
2779 section
->size
= bfd_section_size (sec
);
2780 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2781 alloced
= amt
= section
->size
+ 1;
2782 if (alloced
!= amt
|| alloced
== 0)
2784 section
->start
= NULL
;
2785 free_debug_section (debug
);
2786 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2787 sanitize_string (section
->name
),
2788 (unsigned long long) section
->size
);
2791 section
->start
= contents
= malloc (alloced
);
2792 if (section
->start
== NULL
2793 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2795 free_debug_section (debug
);
2796 printf (_("\nCan't get contents for section '%s'.\n"),
2797 sanitize_string (section
->name
));
2800 /* Ensure any string section has a terminating NUL. */
2801 section
->start
[section
->size
] = 0;
2803 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2804 && debug_displays
[debug
].relocate
)
2809 bfd_cache_section_contents (sec
, section
->start
);
2811 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2818 free_debug_section (debug
);
2819 printf (_("\nCan't get contents for section '%s'.\n"),
2820 sanitize_string (section
->name
));
2824 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2827 unsigned long reloc_count
;
2830 relocs
= (arelent
**) xmalloc (reloc_size
);
2832 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2833 if (reloc_count
== 0)
2837 section
->reloc_info
= relocs
;
2838 section
->num_relocs
= reloc_count
;
2847 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2852 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2855 relocs
= (arelent
**) dsec
->reloc_info
;
2857 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2858 if (rp
->address
== offset
)
2865 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2867 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2868 bfd
*abfd
= (bfd
*) file
;
2871 /* If it is already loaded, do nothing. */
2872 if (section
->start
!= NULL
)
2874 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2878 /* Locate the debug section. */
2879 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2881 section
->name
= section
->uncompressed_name
;
2884 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2886 section
->name
= section
->compressed_name
;
2891 return load_specific_debug_section (debug
, sec
, file
);
2895 free_debug_section (enum dwarf_section_display_enum debug
)
2897 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2899 if (section
->start
== NULL
)
2902 /* PR 17512: file: 0f67f69d. */
2903 if (section
->user_data
!= NULL
)
2905 asection
* sec
= (asection
*) section
->user_data
;
2907 /* If we are freeing contents that are also pointed to by the BFD
2908 library's section structure then make sure to update those pointers
2909 too. Otherwise, the next time we try to load data for this section
2910 we can end up using a stale pointer. */
2911 if (section
->start
== sec
->contents
)
2913 sec
->contents
= NULL
;
2914 sec
->flags
&= ~ SEC_IN_MEMORY
;
2915 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2919 free ((char *) section
->start
);
2920 section
->start
= NULL
;
2921 section
->address
= 0;
2926 close_debug_file (void * file
)
2928 bfd
* abfd
= (bfd
*) file
;
2934 open_debug_file (const char * pathname
)
2938 data
= bfd_openr (pathname
, NULL
);
2942 if (! bfd_check_format (data
, bfd_object
))
2948 #if HAVE_LIBDEBUGINFOD
2949 /* Return a hex string represention of the build-id. */
2952 get_build_id (void * data
)
2955 char * build_id_str
;
2956 bfd
* abfd
= (bfd
*) data
;
2957 const struct bfd_build_id
* build_id
;
2959 build_id
= abfd
->build_id
;
2960 if (build_id
== NULL
)
2963 build_id_str
= malloc (build_id
->size
* 2 + 1);
2964 if (build_id_str
== NULL
)
2967 for (i
= 0; i
< build_id
->size
; i
++)
2968 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
2969 build_id_str
[build_id
->size
* 2] = '\0';
2971 return (unsigned char *)build_id_str
;
2973 #endif /* HAVE_LIBDEBUGINFOD */
2976 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2977 void *arg ATTRIBUTE_UNUSED
)
2979 const char *name
= bfd_section_name (section
);
2983 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2984 match
= ".debug_info";
2988 for (i
= 0; i
< max
; i
++)
2989 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2990 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2991 && debug_displays
[i
].enabled
!= NULL
2992 && *debug_displays
[i
].enabled
)
2994 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2996 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2997 sec
->name
= sec
->uncompressed_name
;
2999 sec
->name
= sec
->compressed_name
;
3000 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3003 debug_displays
[i
].display (sec
, abfd
);
3005 if (i
!= info
&& i
!= abbrev
)
3006 free_debug_section ((enum dwarf_section_display_enum
) i
);
3012 /* Dump the dwarf debugging information. */
3015 dump_dwarf (bfd
*abfd
)
3017 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3018 if (byte_get
== NULL
)
3020 warn (_("File %s does not contain any dwarf debug information\n"),
3021 bfd_get_filename (abfd
));
3025 switch (bfd_get_arch (abfd
))
3028 /* S12Z has a 24 bit address space. But the only known
3029 producer of dwarf_info encodes addresses into 32 bits. */
3034 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3038 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3039 bfd_get_mach (abfd
));
3041 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3044 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3045 it. Return NULL on failure. */
3048 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3049 bfd_size_type
*entsize_ptr
)
3054 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3055 if (stabsect
== NULL
)
3057 printf (_("No %s section present\n\n"),
3058 sanitize_string (sect_name
));
3062 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3064 non_fatal (_("reading %s section of %s failed: %s"),
3065 sect_name
, bfd_get_filename (abfd
),
3066 bfd_errmsg (bfd_get_error ()));
3072 *size_ptr
= bfd_section_size (stabsect
);
3074 *entsize_ptr
= stabsect
->entsize
;
3079 /* Stabs entries use a 12 byte format:
3080 4 byte string table index
3082 1 byte stab other field
3083 2 byte stab desc field
3085 FIXME: This will have to change for a 64 bit object format. */
3087 #define STRDXOFF (0)
3089 #define OTHEROFF (5)
3092 #define STABSIZE (12)
3094 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3095 using string table section STRSECT_NAME (in `strtab'). */
3098 print_section_stabs (bfd
*abfd
,
3099 const char *stabsect_name
,
3100 unsigned *string_offset_ptr
)
3103 unsigned file_string_table_offset
= 0;
3104 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3105 bfd_byte
*stabp
, *stabs_end
;
3108 stabs_end
= stabp
+ stab_size
;
3110 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3111 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3113 /* Loop through all symbols and print them.
3115 We start the index at -1 because there is a dummy symbol on
3116 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3117 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3121 unsigned char type
, other
;
3122 unsigned short desc
;
3125 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3126 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3127 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3128 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3129 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3131 printf ("\n%-6d ", i
);
3132 /* Either print the stab name, or, if unnamed, print its number
3133 again (makes consistent formatting for tools like awk). */
3134 name
= bfd_get_stab_name (type
);
3136 printf ("%-6s", sanitize_string (name
));
3137 else if (type
== N_UNDF
)
3140 printf ("%-6d", type
);
3141 printf (" %-6d %-6d ", other
, desc
);
3142 bfd_printf_vma (abfd
, value
);
3143 printf (" %-6lu", strx
);
3145 /* Symbols with type == 0 (N_UNDF) specify the length of the
3146 string table associated with this file. We use that info
3147 to know how to relocate the *next* file's string table indices. */
3150 file_string_table_offset
= next_file_string_table_offset
;
3151 next_file_string_table_offset
+= value
;
3155 bfd_size_type amt
= strx
+ file_string_table_offset
;
3157 /* Using the (possibly updated) string table offset, print the
3158 string (if any) associated with this symbol. */
3159 if (amt
< stabstr_size
)
3160 /* PR 17512: file: 079-79389-0.001:0.1.
3161 FIXME: May need to sanitize this string before displaying. */
3162 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3168 *string_offset_ptr
= next_file_string_table_offset
;
3173 const char * section_name
;
3174 const char * string_section_name
;
3175 unsigned string_offset
;
3180 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3183 stab_section_names
* sought
= (stab_section_names
*) names
;
3185 /* Check for section names for which stabsect_name is a prefix, to
3186 handle .stab.N, etc. */
3187 len
= strlen (sought
->section_name
);
3189 /* If the prefix matches, and the files section name ends with a
3190 nul or a digit, then we match. I.e., we want either an exact
3191 match or a section followed by a number. */
3192 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3193 && (section
->name
[len
] == 0
3194 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3197 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3198 &stabstr_size
, NULL
);
3202 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3204 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3210 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3212 stab_section_names s
;
3214 s
.section_name
= stabsect_name
;
3215 s
.string_section_name
= strsect_name
;
3216 s
.string_offset
= 0;
3218 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3224 /* Dump the any sections containing stabs debugging information. */
3227 dump_stabs (bfd
*abfd
)
3229 dump_stabs_section (abfd
, ".stab", ".stabstr");
3230 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3231 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3234 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3236 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3240 dump_bfd_header (bfd
*abfd
)
3244 printf (_("architecture: %s, "),
3245 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3246 bfd_get_mach (abfd
)));
3247 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3249 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3250 PF (HAS_RELOC
, "HAS_RELOC");
3251 PF (EXEC_P
, "EXEC_P");
3252 PF (HAS_LINENO
, "HAS_LINENO");
3253 PF (HAS_DEBUG
, "HAS_DEBUG");
3254 PF (HAS_SYMS
, "HAS_SYMS");
3255 PF (HAS_LOCALS
, "HAS_LOCALS");
3256 PF (DYNAMIC
, "DYNAMIC");
3257 PF (WP_TEXT
, "WP_TEXT");
3258 PF (D_PAGED
, "D_PAGED");
3259 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3260 printf (_("\nstart address 0x"));
3261 bfd_printf_vma (abfd
, abfd
->start_address
);
3266 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3267 it is passed, or a pointer to newly-allocated storage, in which case
3268 dump_ctf() will free it when it no longer needs it. */
3271 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3274 const char *blanks
= arg
;
3277 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3282 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3284 make_ctfsect (const char *name
, bfd_byte
*data
,
3289 ctfsect
.cts_name
= name
;
3290 ctfsect
.cts_entsize
= 1;
3291 ctfsect
.cts_size
= size
;
3292 ctfsect
.cts_data
= data
;
3297 /* Dump one CTF archive member. */
3300 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3302 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3303 const char *things
[] = {"Header", "Labels", "Data objects",
3304 "Function objects", "Variables", "Types", "Strings",
3309 /* Only print out the name of non-default-named archive members.
3310 The name .ctf appears everywhere, even for things that aren't
3311 really archives, so printing it out is liable to be confusing.
3313 The parent, if there is one, is the default-owned archive member:
3314 avoid importing it into itself. (This does no harm, but looks
3317 if (strcmp (name
, ".ctf") != 0)
3319 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3320 ctf_import (ctf
, parent
);
3323 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
3325 ctf_dump_state_t
*s
= NULL
;
3328 printf ("\n %s:\n", *thing
);
3329 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3330 (void *) " ")) != NULL
)
3332 printf ("%s\n", item
);
3336 if (ctf_errno (ctf
))
3338 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3339 ctf_errmsg (ctf_errno (ctf
)));
3346 /* Dump the CTF debugging information. */
3349 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3351 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
3352 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3353 bfd_size_type ctfsize
, parentsize
;
3355 ctf_file_t
*parent
= NULL
;
3358 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3359 bfd_fatal (bfd_get_filename (abfd
));
3362 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3364 bfd_fatal (bfd_get_filename (abfd
));
3366 /* Load the CTF file and dump it. */
3368 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3369 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3371 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3372 bfd_fatal (bfd_get_filename (abfd
));
3377 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3378 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3380 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3381 bfd_fatal (bfd_get_filename (abfd
));
3384 lookparent
= parenta
;
3389 /* Assume that the applicable parent archive member is the default one.
3390 (This is what all known implementations are expected to do, if they
3391 put CTFs and their parents in archives together.) */
3392 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
3394 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3395 bfd_fatal (bfd_get_filename (abfd
));
3398 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3400 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3401 ctf_file_close (parent
);
3403 ctf_close (parenta
);
3410 dump_bfd_private_header (bfd
*abfd
)
3412 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3413 non_fatal (_("warning: private headers incomplete: %s"),
3414 bfd_errmsg (bfd_get_error ()));
3418 dump_target_specific (bfd
*abfd
)
3420 const struct objdump_private_desc
* const *desc
;
3421 struct objdump_private_option
*opt
;
3424 /* Find the desc. */
3425 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3426 if ((*desc
)->filter (abfd
))
3431 non_fatal (_("option -P/--private not supported by this file"));
3435 /* Clear all options. */
3436 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3437 opt
->selected
= FALSE
;
3439 /* Decode options. */
3440 b
= dump_private_options
;
3443 e
= strchr (b
, ',');
3448 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3449 if (strcmp (opt
->name
, b
) == 0)
3451 opt
->selected
= TRUE
;
3454 if (opt
->name
== NULL
)
3455 non_fatal (_("target specific dump '%s' not supported"), b
);
3466 (*desc
)->dump (abfd
);
3469 /* Display a section in hexadecimal format with associated characters.
3470 Each line prefixed by the zero padded address. */
3473 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3475 bfd_byte
*data
= NULL
;
3476 bfd_size_type datasize
;
3477 bfd_vma addr_offset
;
3478 bfd_vma start_offset
;
3479 bfd_vma stop_offset
;
3480 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
3481 /* Bytes per line. */
3482 const int onaline
= 16;
3487 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3490 if (! process_section_p (section
))
3493 if ((datasize
= bfd_section_size (section
)) == 0)
3496 /* Compute the address range to display. */
3497 if (start_address
== (bfd_vma
) -1
3498 || start_address
< section
->vma
)
3501 start_offset
= start_address
- section
->vma
;
3503 if (stop_address
== (bfd_vma
) -1)
3504 stop_offset
= datasize
/ opb
;
3507 if (stop_address
< section
->vma
)
3510 stop_offset
= stop_address
- section
->vma
;
3512 if (stop_offset
> datasize
/ opb
)
3513 stop_offset
= datasize
/ opb
;
3516 if (start_offset
>= stop_offset
)
3519 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3520 if (display_file_offsets
)
3521 printf (_(" (Starting at file offset: 0x%lx)"),
3522 (unsigned long) (section
->filepos
+ start_offset
));
3525 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3527 non_fatal (_("Reading section %s failed because: %s"),
3528 section
->name
, bfd_errmsg (bfd_get_error ()));
3534 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3535 if (strlen (buf
) >= sizeof (buf
))
3539 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3541 count
= strlen (buf
) - count
;
3545 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3546 if (strlen (buf
) >= sizeof (buf
))
3550 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3552 count
= strlen (buf
) - count
;
3556 for (addr_offset
= start_offset
;
3557 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3561 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3562 count
= strlen (buf
);
3563 if ((size_t) count
>= sizeof (buf
))
3567 while (count
< width
)
3572 fputs (buf
+ count
- width
, stdout
);
3575 for (j
= addr_offset
* opb
;
3576 j
< addr_offset
* opb
+ onaline
; j
++)
3578 if (j
< stop_offset
* opb
)
3579 printf ("%02x", (unsigned) (data
[j
]));
3587 for (j
= addr_offset
* opb
;
3588 j
< addr_offset
* opb
+ onaline
; j
++)
3590 if (j
>= stop_offset
* opb
)
3593 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3600 /* Actually display the various requested regions. */
3603 dump_data (bfd
*abfd
)
3605 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3608 /* Should perhaps share code and display with nm? */
3611 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3620 max_count
= dynsymcount
;
3621 printf ("DYNAMIC SYMBOL TABLE:\n");
3626 max_count
= symcount
;
3627 printf ("SYMBOL TABLE:\n");
3631 printf (_("no symbols\n"));
3633 for (count
= 0; count
< max_count
; count
++)
3637 if (*current
== NULL
)
3638 printf (_("no information for symbol number %ld\n"), count
);
3640 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3641 printf (_("could not determine the type of symbol number %ld\n"),
3644 else if (process_section_p ((* current
)->section
)
3645 && (dump_special_syms
3646 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3648 const char *name
= (*current
)->name
;
3650 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3654 /* If we want to demangle the name, we demangle it
3655 here, and temporarily clobber it while calling
3656 bfd_print_symbol. FIXME: This is a gross hack. */
3657 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3659 (*current
)->name
= alloc
;
3660 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3661 bfd_print_symbol_all
);
3664 (*current
)->name
= name
;
3669 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3670 bfd_print_symbol_all
);
3680 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3683 char *last_filename
, *last_functionname
;
3684 unsigned int last_line
;
3685 unsigned int last_discriminator
;
3687 /* Get column headers lined up reasonably. */
3695 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3696 width
= strlen (buf
) - 7;
3698 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3701 last_filename
= NULL
;
3702 last_functionname
= NULL
;
3704 last_discriminator
= 0;
3706 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3709 const char *filename
, *functionname
;
3710 unsigned int linenumber
;
3711 unsigned int discriminator
;
3712 const char *sym_name
;
3713 const char *section_name
;
3714 bfd_vma addend2
= 0;
3716 if (start_address
!= (bfd_vma
) -1
3717 && q
->address
< start_address
)
3719 if (stop_address
!= (bfd_vma
) -1
3720 && q
->address
> stop_address
)
3723 if (with_line_numbers
3725 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3726 &filename
, &functionname
,
3727 &linenumber
, &discriminator
))
3729 if (functionname
!= NULL
3730 && (last_functionname
== NULL
3731 || strcmp (functionname
, last_functionname
) != 0))
3733 printf ("%s():\n", sanitize_string (functionname
));
3734 if (last_functionname
!= NULL
)
3735 free (last_functionname
);
3736 last_functionname
= xstrdup (functionname
);
3740 && (linenumber
!= last_line
3741 || (filename
!= NULL
3742 && last_filename
!= NULL
3743 && filename_cmp (filename
, last_filename
) != 0)
3744 || (discriminator
!= last_discriminator
)))
3746 if (discriminator
> 0)
3747 printf ("%s:%u\n", filename
== NULL
? "???" :
3748 sanitize_string (filename
), linenumber
);
3750 printf ("%s:%u (discriminator %u)\n",
3751 filename
== NULL
? "???" : sanitize_string (filename
),
3752 linenumber
, discriminator
);
3753 last_line
= linenumber
;
3754 last_discriminator
= discriminator
;
3755 if (last_filename
!= NULL
)
3756 free (last_filename
);
3757 if (filename
== NULL
)
3758 last_filename
= NULL
;
3760 last_filename
= xstrdup (filename
);
3764 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3766 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3767 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3772 section_name
= NULL
;
3775 bfd_printf_vma (abfd
, q
->address
);
3776 if (q
->howto
== NULL
)
3777 printf (" *unknown* ");
3778 else if (q
->howto
->name
)
3780 const char *name
= q
->howto
->name
;
3782 /* R_SPARC_OLO10 relocations contain two addends.
3783 But because 'arelent' lacks enough storage to
3784 store them both, the 64-bit ELF Sparc backend
3785 records this as two relocations. One R_SPARC_LO10
3786 and one R_SPARC_13, both pointing to the same
3787 address. This is merely so that we have some
3788 place to store both addend fields.
3790 Undo this transformation, otherwise the output
3791 will be confusing. */
3792 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3793 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3795 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3797 arelent
*q2
= *(p
+ 1);
3800 && q
->address
== q2
->address
3801 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3803 name
= "R_SPARC_OLO10";
3804 addend2
= q2
->addend
;
3808 printf (" %-16s ", name
);
3811 printf (" %-16d ", q
->howto
->type
);
3815 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3819 if (section_name
== NULL
)
3820 section_name
= "*unknown*";
3821 printf ("[%s]", sanitize_string (section_name
));
3826 bfd_signed_vma addend
= q
->addend
;
3834 bfd_printf_vma (abfd
, addend
);
3839 bfd_printf_vma (abfd
, addend2
);
3845 if (last_filename
!= NULL
)
3846 free (last_filename
);
3847 if (last_functionname
!= NULL
)
3848 free (last_functionname
);
3852 dump_relocs_in_section (bfd
*abfd
,
3854 void *dummy ATTRIBUTE_UNUSED
)
3856 arelent
**relpp
= NULL
;
3860 if ( bfd_is_abs_section (section
)
3861 || bfd_is_und_section (section
)
3862 || bfd_is_com_section (section
)
3863 || (! process_section_p (section
))
3864 || ((section
->flags
& SEC_RELOC
) == 0))
3867 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3869 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3872 printf (" (none)\n\n");
3880 relpp
= (arelent
**) xmalloc (relsize
);
3881 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3887 non_fatal (_("failed to read relocs in: %s"),
3888 sanitize_string (bfd_get_filename (abfd
)));
3889 bfd_fatal (_("error message was"));
3891 else if (relcount
== 0)
3892 printf (" (none)\n\n");
3896 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3903 dump_relocs (bfd
*abfd
)
3905 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3909 dump_dynamic_relocs (bfd
*abfd
)
3915 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3917 bfd_fatal (bfd_get_filename (abfd
));
3919 printf ("DYNAMIC RELOCATION RECORDS");
3922 printf (" (none)\n\n");
3925 relpp
= (arelent
**) xmalloc (relsize
);
3926 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3929 bfd_fatal (bfd_get_filename (abfd
));
3930 else if (relcount
== 0)
3931 printf (" (none)\n\n");
3935 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3942 /* Creates a table of paths, to search for source files. */
3945 add_include_path (const char *path
)
3949 include_path_count
++;
3950 include_paths
= (const char **)
3951 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3952 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3953 if (path
[1] == ':' && path
[2] == 0)
3954 path
= concat (path
, ".", (const char *) 0);
3956 include_paths
[include_path_count
- 1] = path
;
3960 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3964 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3966 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3967 section
->vma
+= adjust_section_vma
;
3969 section
->lma
+= adjust_section_vma
;
3973 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3976 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3981 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3982 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3985 /* Dump selected contents of ABFD. */
3988 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3990 const struct elf_backend_data
* bed
;
3992 if (bfd_big_endian (abfd
))
3993 byte_get
= byte_get_big_endian
;
3994 else if (bfd_little_endian (abfd
))
3995 byte_get
= byte_get_little_endian
;
3999 /* Load any separate debug information files.
4000 We do this now and without checking do_follow_links because separate
4001 debug info files may contain symbol tables that we will need when
4002 displaying information about the main file. Any memory allocated by
4003 load_separate_debug_files will be released when we call
4004 free_debug_memory below.
4006 The test on is_mainfile is there because the chain of separate debug
4007 info files is a global variable shared by all invocations of dump_bfd. */
4010 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4012 /* If asked to do so, recursively dump the separate files. */
4013 if (do_follow_links
)
4017 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4018 dump_bfd (i
->handle
, FALSE
);
4022 /* Adjust user-specified start and stop limits for targets that use
4023 signed addresses. */
4024 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4025 && (bed
= get_elf_backend_data (abfd
)) != NULL
4026 && bed
->sign_extend_vma
)
4028 start_address
= sign_extend_address (abfd
, start_address
,
4030 stop_address
= sign_extend_address (abfd
, stop_address
,
4034 /* If we are adjusting section VMA's, change them all now. Changing
4035 the BFD information is a hack. However, we must do it, or
4036 bfd_find_nearest_line will not do the right thing. */
4037 if (adjust_section_vma
!= 0)
4039 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4040 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4043 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4044 printf (_("\n%s: file format %s\n"),
4045 sanitize_string (bfd_get_filename (abfd
)),
4048 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4049 if (dump_file_header
)
4050 dump_bfd_header (abfd
);
4051 if (dump_private_headers
)
4052 dump_bfd_private_header (abfd
);
4053 if (dump_private_options
!= NULL
)
4054 dump_target_specific (abfd
);
4055 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4062 || dump_dwarf_section_info
)
4064 syms
= slurp_symtab (abfd
);
4066 /* If following links, load any symbol tables from the linked files as well. */
4067 if (do_follow_links
&& is_mainfile
)
4071 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4073 asymbol
** extra_syms
;
4074 long old_symcount
= symcount
;
4076 extra_syms
= slurp_symtab (i
->handle
);
4080 if (old_symcount
== 0)
4086 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4087 memcpy (syms
+ old_symcount
,
4089 symcount
* sizeof (asymbol
*));
4093 symcount
+= old_symcount
;
4098 if (dump_section_headers
)
4099 dump_headers (abfd
);
4101 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4102 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4103 dynsyms
= slurp_dynamic_symtab (abfd
);
4107 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4108 dynsymcount
, dynsyms
, &synthsyms
);
4114 dump_symbols (abfd
, FALSE
);
4115 if (dump_dynamic_symtab
)
4116 dump_symbols (abfd
, TRUE
);
4117 if (dump_dwarf_section_info
)
4119 if (dump_ctf_section_info
)
4120 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4121 if (dump_stab_section_info
)
4123 if (dump_reloc_info
&& ! disassemble
)
4125 if (dump_dynamic_reloc_info
&& ! disassemble
)
4126 dump_dynamic_relocs (abfd
);
4127 if (dump_section_contents
)
4130 disassemble_data (abfd
);
4136 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4137 if (dhandle
!= NULL
)
4139 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4141 dump_debugging_tags
? TRUE
: FALSE
))
4143 non_fatal (_("%s: printing debugging information failed"),
4144 bfd_get_filename (abfd
));
4150 /* PR 6483: If there was no STABS debug info in the file, try
4152 else if (! dump_dwarf_section_info
)
4154 dwarf_select_sections_all ();
4182 free_debug_memory ();
4186 display_object_bfd (bfd
*abfd
)
4190 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4192 dump_bfd (abfd
, TRUE
);
4196 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4198 nonfatal (bfd_get_filename (abfd
));
4199 list_matching_formats (matching
);
4204 if (bfd_get_error () != bfd_error_file_not_recognized
)
4206 nonfatal (bfd_get_filename (abfd
));
4210 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4212 dump_bfd (abfd
, TRUE
);
4216 nonfatal (bfd_get_filename (abfd
));
4218 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4220 list_matching_formats (matching
);
4226 display_any_bfd (bfd
*file
, int level
)
4228 /* Decompress sections unless dumping the section contents. */
4229 if (!dump_section_contents
)
4230 file
->flags
|= BFD_DECOMPRESS
;
4232 /* If the file is an archive, process all of its elements. */
4233 if (bfd_check_format (file
, bfd_archive
))
4236 bfd
*last_arfile
= NULL
;
4239 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4240 else if (level
> 100)
4242 /* Prevent corrupted files from spinning us into an
4243 infinite loop. 100 is an arbitrary heuristic. */
4244 fatal (_("Archive nesting is too deep"));
4248 printf (_("In nested archive %s:\n"),
4249 sanitize_string (bfd_get_filename (file
)));
4253 bfd_set_error (bfd_error_no_error
);
4255 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4258 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4259 nonfatal (bfd_get_filename (file
));
4263 display_any_bfd (arfile
, level
+ 1);
4265 if (last_arfile
!= NULL
)
4267 bfd_close (last_arfile
);
4268 /* PR 17512: file: ac585d01. */
4269 if (arfile
== last_arfile
)
4275 last_arfile
= arfile
;
4278 if (last_arfile
!= NULL
)
4279 bfd_close (last_arfile
);
4282 display_object_bfd (file
);
4286 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4290 if (get_file_size (filename
) < 1)
4296 file
= bfd_openr (filename
, target
);
4299 nonfatal (filename
);
4303 display_any_bfd (file
, 0);
4305 /* This is an optimization to improve the speed of objdump, especially when
4306 dumping a file with lots of associated debug informatiom. Calling
4307 bfd_close on such a file can take a non-trivial amount of time as there
4308 are lots of lists to walk and buffers to free. This is only really
4309 necessary however if we are about to load another file and we need the
4310 memory back. Otherwise, if we are about to exit, then we can save (a lot
4311 of) time by only doing a quick close, and allowing the OS to reclaim the
4316 bfd_close_all_done (file
);
4320 main (int argc
, char **argv
)
4323 char *target
= default_target
;
4324 bfd_boolean seenflag
= FALSE
;
4326 #if defined (HAVE_SETLOCALE)
4327 #if defined (HAVE_LC_MESSAGES)
4328 setlocale (LC_MESSAGES
, "");
4330 setlocale (LC_CTYPE
, "");
4333 bindtextdomain (PACKAGE
, LOCALEDIR
);
4334 textdomain (PACKAGE
);
4336 program_name
= *argv
;
4337 xmalloc_set_program_name (program_name
);
4338 bfd_set_error_program_name (program_name
);
4340 START_PROGRESS (program_name
, 0);
4342 expandargv (&argc
, &argv
);
4344 if (bfd_init () != BFD_INIT_MAGIC
)
4345 fatal (_("fatal error: libbfd ABI mismatch"));
4346 set_default_bfd_target ();
4348 while ((c
= getopt_long (argc
, argv
,
4349 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4350 long_options
, (int *) 0))
4356 break; /* We've been given a long option. */
4363 if (disassembler_options
)
4364 /* Ignore potential memory leak for now. */
4365 options
= concat (disassembler_options
, ",",
4366 optarg
, (const char *) NULL
);
4369 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4376 display_file_offsets
= TRUE
;
4379 with_line_numbers
= TRUE
;
4388 enum demangling_styles style
;
4390 style
= cplus_demangle_name_to_style (optarg
);
4391 if (style
== unknown_demangling
)
4392 fatal (_("unknown demangling style `%s'"),
4395 cplus_demangle_set_style (style
);
4398 case OPTION_RECURSE_LIMIT
:
4399 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4401 case OPTION_NO_RECURSE_LIMIT
:
4402 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4405 do_wide
= wide_output
= TRUE
;
4407 case OPTION_ADJUST_VMA
:
4408 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4410 case OPTION_START_ADDRESS
:
4411 start_address
= parse_vma (optarg
, "--start-address");
4412 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4413 fatal (_("error: the start address should be before the end address"));
4415 case OPTION_STOP_ADDRESS
:
4416 stop_address
= parse_vma (optarg
, "--stop-address");
4417 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4418 fatal (_("error: the stop address should be after the start address"));
4422 prefix_length
= strlen (prefix
);
4423 /* Remove an unnecessary trailing '/' */
4424 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4427 case OPTION_PREFIX_STRIP
:
4428 prefix_strip
= atoi (optarg
);
4429 if (prefix_strip
< 0)
4430 fatal (_("error: prefix strip must be non-negative"));
4432 case OPTION_INSN_WIDTH
:
4433 insn_width
= strtoul (optarg
, NULL
, 0);
4434 if (insn_width
<= 0)
4435 fatal (_("error: instruction width must be positive"));
4437 case OPTION_INLINES
:
4438 unwind_inlines
= TRUE
;
4441 if (strcmp (optarg
, "B") == 0)
4442 endian
= BFD_ENDIAN_BIG
;
4443 else if (strcmp (optarg
, "L") == 0)
4444 endian
= BFD_ENDIAN_LITTLE
;
4447 nonfatal (_("unrecognized -E option"));
4452 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4453 endian
= BFD_ENDIAN_BIG
;
4454 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4455 endian
= BFD_ENDIAN_LITTLE
;
4458 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4465 dump_file_header
= TRUE
;
4469 formats_info
= TRUE
;
4473 add_include_path (optarg
);
4476 dump_private_headers
= TRUE
;
4480 dump_private_options
= optarg
;
4484 dump_private_headers
= TRUE
;
4486 dump_reloc_info
= TRUE
;
4487 dump_file_header
= TRUE
;
4488 dump_ar_hdrs
= TRUE
;
4489 dump_section_headers
= TRUE
;
4497 dump_dynamic_symtab
= TRUE
;
4503 disasm_sym
= optarg
;
4506 disassemble_zeroes
= TRUE
;
4510 disassemble_all
= TRUE
;
4515 with_source_code
= TRUE
;
4518 case OPTION_SOURCE_COMMENT
:
4520 with_source_code
= TRUE
;
4523 source_comment
= xstrdup (sanitize_string (optarg
));
4525 source_comment
= xstrdup ("# ");
4533 dump_debugging_tags
= 1;
4538 dump_dwarf_section_info
= TRUE
;
4541 dwarf_select_sections_by_letters (optarg
);
4543 dwarf_select_sections_all ();
4546 dump_dwarf_section_info
= TRUE
;
4549 dwarf_select_sections_by_names (optarg
);
4551 dwarf_select_sections_all ();
4553 case OPTION_DWARF_DEPTH
:
4556 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4559 case OPTION_DWARF_START
:
4562 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4563 suppress_bfd_header
= 1;
4566 case OPTION_DWARF_CHECK
:
4570 dump_ctf_section_info
= TRUE
;
4571 dump_ctf_section_name
= xstrdup (optarg
);
4574 case OPTION_CTF_PARENT
:
4575 dump_ctf_parent_name
= xstrdup (optarg
);
4578 dump_stab_section_info
= TRUE
;
4582 dump_section_contents
= TRUE
;
4586 dump_reloc_info
= TRUE
;
4590 dump_dynamic_reloc_info
= TRUE
;
4594 dump_ar_hdrs
= TRUE
;
4598 dump_section_headers
= TRUE
;
4603 show_version
= TRUE
;
4609 /* No need to set seenflag or to break - usage() does not return. */
4616 print_version ("objdump");
4622 exit_status
= display_info ();
4626 display_file ("a.out", target
, TRUE
);
4628 for (; optind
< argc
;)
4630 display_file (argv
[optind
], target
, optind
== argc
- 1);
4636 free (dump_ctf_section_name
);
4637 free (dump_ctf_parent_name
);
4638 free ((void *) source_comment
);
4640 END_PROGRESS (program_name
);