1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2019 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
63 #include "safe-ctype.h"
65 #include "libiberty.h"
67 #include "filenames.h"
76 /* Internal headers for the ELF .stab-dump code - sorry. */
77 #define BYTES_IN_WORD 32
78 #include "aout/aout64.h"
81 static int exit_status
= 0;
83 static char *default_target
= NULL
; /* Default at runtime. */
85 /* The following variables are set based on arguments passed on the
87 static int show_version
= 0; /* Show the version number. */
88 static int dump_section_contents
; /* -s */
89 static int dump_section_headers
; /* -h */
90 static bfd_boolean dump_file_header
; /* -f */
91 static int dump_symtab
; /* -t */
92 static int dump_dynamic_symtab
; /* -T */
93 static int dump_reloc_info
; /* -r */
94 static int dump_dynamic_reloc_info
; /* -R */
95 static int dump_ar_hdrs
; /* -a */
96 static int dump_private_headers
; /* -p */
97 static char *dump_private_options
; /* -P */
98 static int prefix_addresses
; /* --prefix-addresses */
99 static int with_line_numbers
; /* -l */
100 static bfd_boolean with_source_code
; /* -S */
101 static int show_raw_insn
; /* --show-raw-insn */
102 static int dump_dwarf_section_info
; /* --dwarf */
103 static int dump_stab_section_info
; /* --stabs */
105 static int dump_ctf_section_info
; /* --ctf */
106 static char *dump_ctf_section_name
;
107 static char *dump_ctf_parent_name
; /* --ctf-parent */
109 static int do_demangle
; /* -C, --demangle */
110 static bfd_boolean disassemble
; /* -d */
111 static bfd_boolean disassemble_all
; /* -D */
112 static int disassemble_zeroes
; /* --disassemble-zeroes */
113 static bfd_boolean formats_info
; /* -i */
114 static int wide_output
; /* -w */
115 static int insn_width
; /* --insn-width */
116 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
117 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
118 static int dump_debugging
; /* --debugging */
119 static int dump_debugging_tags
; /* --debugging-tags */
120 static int suppress_bfd_header
;
121 static int dump_special_syms
= 0; /* --special-syms */
122 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
123 static int file_start_context
= 0; /* --file-start-context */
124 static bfd_boolean display_file_offsets
;/* -F */
125 static const char *prefix
; /* --prefix */
126 static int prefix_strip
; /* --prefix-strip */
127 static size_t prefix_length
;
128 static bfd_boolean unwind_inlines
; /* --inlines. */
129 static const char * disasm_sym
; /* Disassembly start symbol. */
131 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
133 /* A structure to record the sections mentioned in -j switches. */
136 const char * name
; /* The name of the section. */
137 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
138 struct only
* next
; /* Pointer to the next structure in the list. */
140 /* Pointer to an array of 'only' structures.
141 This pointer is NULL if the -j switch has not been used. */
142 static struct only
* only_list
= NULL
;
144 /* Variables for handling include file path table. */
145 static const char **include_paths
;
146 static int include_path_count
;
148 /* Extra info to pass to the section disassembler and address printing
150 struct objdump_disasm_info
154 bfd_boolean require_sec
;
155 arelent
** dynrelbuf
;
157 disassembler_ftype disassemble_fn
;
162 /* Architecture to disassemble for, or default if NULL. */
163 static char *machine
= NULL
;
165 /* Target specific options to the disassembler. */
166 static char *disassembler_options
= NULL
;
168 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
169 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
171 /* The symbol table. */
172 static asymbol
**syms
;
174 /* Number of symbols in `syms'. */
175 static long symcount
= 0;
177 /* The sorted symbol table. */
178 static asymbol
**sorted_syms
;
180 /* Number of symbols in `sorted_syms'. */
181 static long sorted_symcount
= 0;
183 /* The dynamic symbol table. */
184 static asymbol
**dynsyms
;
186 /* The synthetic symbol table. */
187 static asymbol
*synthsyms
;
188 static long synthcount
= 0;
190 /* Number of symbols in `dynsyms'. */
191 static long dynsymcount
= 0;
193 static bfd_byte
*stabs
;
194 static bfd_size_type stab_size
;
196 static bfd_byte
*strtab
;
197 static bfd_size_type stabstr_size
;
199 static bfd_boolean is_relocatable
= FALSE
;
201 /* Handlers for -P/--private. */
202 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
204 OBJDUMP_PRIVATE_VECTORS
208 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
210 usage (FILE *stream
, int status
)
212 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
213 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
214 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
215 fprintf (stream
, _("\
216 -a, --archive-headers Display archive header information\n\
217 -f, --file-headers Display the contents of the overall file header\n\
218 -p, --private-headers Display object format specific file header contents\n\
219 -P, --private=OPT,OPT... Display object format specific contents\n\
220 -h, --[section-]headers Display the contents of the section headers\n\
221 -x, --all-headers Display the contents of all headers\n\
222 -d, --disassemble Display assembler contents of executable sections\n\
223 -D, --disassemble-all Display assembler contents of all sections\n\
224 --disassemble=<sym> Display assembler contents from <sym>\n\
225 -S, --source Intermix source code with disassembly\n\
226 -s, --full-contents Display the full contents of all sections requested\n\
227 -g, --debugging Display debug information in object file\n\
228 -e, --debugging-tags Display debug information using ctags style\n\
229 -G, --stabs Display (in raw form) any STABS info in the file\n\
230 -W[lLiaprmfFsoRtUuTgAckK] or\n\
231 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
232 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
233 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
234 =addr,=cu_index,=links,=follow-links]\n\
235 Display DWARF info in the file\n"));
237 fprintf (stream
, _("\
238 --ctf=SECTION Display CTF info from SECTION\n"));
240 fprintf (stream
, _("\
241 -t, --syms Display the contents of the symbol table(s)\n\
242 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
243 -r, --reloc Display the relocation entries in the file\n\
244 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
245 @<file> Read options from <file>\n\
246 -v, --version Display this program's version number\n\
247 -i, --info List object formats and architectures supported\n\
248 -H, --help Display this information\n\
252 const struct objdump_private_desc
* const *desc
;
254 fprintf (stream
, _("\n The following switches are optional:\n"));
255 fprintf (stream
, _("\
256 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
257 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
258 -j, --section=NAME Only display information for section NAME\n\
259 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
260 -EB --endian=big Assume big endian format when disassembling\n\
261 -EL --endian=little Assume little endian format when disassembling\n\
262 --file-start-context Include context from start of file (with -S)\n\
263 -I, --include=DIR Add DIR to search list for source files\n\
264 -l, --line-numbers Include line numbers and filenames in output\n\
265 -F, --file-offsets Include file offsets when displaying information\n\
266 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
267 The STYLE, if specified, can be `auto', `gnu',\n\
268 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
270 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
271 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
272 -w, --wide Format output for more than 80 columns\n\
273 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
274 --start-address=ADDR Only process data whose address is >= ADDR\n\
275 --stop-address=ADDR Only process data whose address is <= ADDR\n\
276 --prefix-addresses Print complete address alongside disassembly\n\
277 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
278 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
279 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
280 --special-syms Include special symbols in symbol dumps\n\
281 --inlines Print all inlines for source line (with -l)\n\
282 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
283 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
284 fprintf (stream
, _("\
285 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
286 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
288 --dwarf-check Make additional dwarf internal consistency checks.\
291 fprintf (stream
, _("\
292 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
294 list_supported_targets (program_name
, stream
);
295 list_supported_architectures (program_name
, stream
);
297 disassembler_usage (stream
);
299 if (objdump_private_vectors
[0] != NULL
)
302 _("\nOptions supported for -P/--private switch:\n"));
303 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
304 (*desc
)->help (stream
);
307 if (REPORT_BUGS_TO
[0] && status
== 0)
308 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
312 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
316 OPTION_START_ADDRESS
,
326 OPTION_RECURSE_LIMIT
,
327 OPTION_NO_RECURSE_LIMIT
,
335 static struct option long_options
[]=
337 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
338 {"all-headers", no_argument
, NULL
, 'x'},
339 {"private-headers", no_argument
, NULL
, 'p'},
340 {"private", required_argument
, NULL
, 'P'},
341 {"architecture", required_argument
, NULL
, 'm'},
342 {"archive-headers", no_argument
, NULL
, 'a'},
343 {"debugging", no_argument
, NULL
, 'g'},
344 {"debugging-tags", no_argument
, NULL
, 'e'},
345 {"demangle", optional_argument
, NULL
, 'C'},
346 {"disassemble", optional_argument
, NULL
, 'd'},
347 {"disassemble-all", no_argument
, NULL
, 'D'},
348 {"disassembler-options", required_argument
, NULL
, 'M'},
349 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
350 {"dynamic-reloc", no_argument
, NULL
, 'R'},
351 {"dynamic-syms", no_argument
, NULL
, 'T'},
352 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
353 {"file-headers", no_argument
, NULL
, 'f'},
354 {"file-offsets", no_argument
, NULL
, 'F'},
355 {"file-start-context", no_argument
, &file_start_context
, 1},
356 {"full-contents", no_argument
, NULL
, 's'},
357 {"headers", no_argument
, NULL
, 'h'},
358 {"help", no_argument
, NULL
, 'H'},
359 {"info", no_argument
, NULL
, 'i'},
360 {"line-numbers", no_argument
, NULL
, 'l'},
361 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
362 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
363 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
364 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
365 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
366 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
367 {"reloc", no_argument
, NULL
, 'r'},
368 {"section", required_argument
, NULL
, 'j'},
369 {"section-headers", no_argument
, NULL
, 'h'},
370 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
371 {"source", no_argument
, NULL
, 'S'},
372 {"special-syms", no_argument
, &dump_special_syms
, 1},
373 {"include", required_argument
, NULL
, 'I'},
374 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
376 {"ctf", required_argument
, NULL
, OPTION_CTF
},
377 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
379 {"stabs", no_argument
, NULL
, 'G'},
380 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
381 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
382 {"syms", no_argument
, NULL
, 't'},
383 {"target", required_argument
, NULL
, 'b'},
384 {"version", no_argument
, NULL
, 'V'},
385 {"wide", no_argument
, NULL
, 'w'},
386 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
387 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
388 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
389 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
390 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
391 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
392 {"inlines", no_argument
, 0, OPTION_INLINES
},
393 {0, no_argument
, 0, 0}
397 nonfatal (const char *msg
)
403 /* Returns a version of IN with any control characters
404 replaced by escape sequences. Uses a static buffer
408 sanitize_string (const char * in
)
410 static char * buffer
= NULL
;
411 static size_t buffer_len
= 0;
412 const char * original
= in
;
419 /* See if any conversion is necessary. In the majority
420 of cases it will not be needed. */
433 /* Copy the input, translating as needed. */
435 if (buffer_len
< (strlen (in
) * 2))
437 free ((void *) buffer
);
438 buffer_len
= strlen (in
) * 2;
439 buffer
= xmalloc (buffer_len
+ 1);
465 /* Returns TRUE if the specified section should be dumped. */
468 process_section_p (asection
* section
)
472 if (only_list
== NULL
)
475 for (only
= only_list
; only
; only
= only
->next
)
476 if (strcmp (only
->name
, section
->name
) == 0)
485 /* Add an entry to the 'only' list. */
488 add_only (char * name
)
492 /* First check to make sure that we do not
493 already have an entry for this name. */
494 for (only
= only_list
; only
; only
= only
->next
)
495 if (strcmp (only
->name
, name
) == 0)
498 only
= xmalloc (sizeof * only
);
501 only
->next
= only_list
;
505 /* Release the memory used by the 'only' list.
506 PR 11225: Issue a warning message for unseen sections.
507 Only do this if none of the sections were seen. This is mainly to support
508 tools like the GAS testsuite where an object file is dumped with a list of
509 generic section names known to be present in a range of different file
513 free_only_list (void)
515 bfd_boolean at_least_one_seen
= FALSE
;
519 if (only_list
== NULL
)
522 for (only
= only_list
; only
; only
= only
->next
)
525 at_least_one_seen
= TRUE
;
529 for (only
= only_list
; only
; only
= next
)
531 if (! at_least_one_seen
)
533 non_fatal (_("section '%s' mentioned in a -j option, "
534 "but not found in any input file"),
545 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
548 unsigned int opb
= bfd_octets_per_byte (abfd
);
549 int longest_section_name
= *((int *) data
);
551 /* Ignore linker created section. See elfNN_ia64_object_p in
553 if (section
->flags
& SEC_LINKER_CREATED
)
556 /* PR 10413: Skip sections that we are ignoring. */
557 if (! process_section_p (section
))
560 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
561 sanitize_string (bfd_get_section_name (abfd
, section
)),
562 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
563 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
565 bfd_printf_vma (abfd
, section
->lma
);
566 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
567 bfd_get_section_alignment (abfd
, section
));
573 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
575 PF (SEC_HAS_CONTENTS
, "CONTENTS");
576 PF (SEC_ALLOC
, "ALLOC");
577 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
578 PF (SEC_LOAD
, "LOAD");
579 PF (SEC_RELOC
, "RELOC");
580 PF (SEC_READONLY
, "READONLY");
581 PF (SEC_CODE
, "CODE");
582 PF (SEC_DATA
, "DATA");
584 PF (SEC_DEBUGGING
, "DEBUGGING");
585 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
586 PF (SEC_EXCLUDE
, "EXCLUDE");
587 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
588 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
590 PF (SEC_TIC54X_BLOCK
, "BLOCK");
591 PF (SEC_TIC54X_CLINK
, "CLINK");
593 PF (SEC_SMALL_DATA
, "SMALL_DATA");
594 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
596 PF (SEC_COFF_SHARED
, "SHARED");
597 PF (SEC_COFF_NOREAD
, "NOREAD");
599 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
600 PF (SEC_ELF_PURECODE
, "PURECODE");
601 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
602 PF (SEC_GROUP
, "GROUP");
603 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
605 PF (SEC_MEP_VLIW
, "VLIW");
608 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
611 struct coff_comdat_info
*comdat
;
613 switch (section
->flags
& SEC_LINK_DUPLICATES
)
617 case SEC_LINK_DUPLICATES_DISCARD
:
618 ls
= "LINK_ONCE_DISCARD";
620 case SEC_LINK_DUPLICATES_ONE_ONLY
:
621 ls
= "LINK_ONCE_ONE_ONLY";
623 case SEC_LINK_DUPLICATES_SAME_SIZE
:
624 ls
= "LINK_ONCE_SAME_SIZE";
626 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
627 ls
= "LINK_ONCE_SAME_CONTENTS";
630 printf ("%s%s", comma
, ls
);
632 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
634 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
643 /* Called on each SECTION in ABFD, update the int variable pointed to by
644 DATA which contains the string length of the longest section name. */
647 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
649 int *longest_so_far
= (int *) data
;
653 /* Ignore linker created section. */
654 if (section
->flags
& SEC_LINKER_CREATED
)
657 /* Skip sections that we are ignoring. */
658 if (! process_section_p (section
))
661 name
= bfd_get_section_name (abfd
, section
);
662 len
= (int) strlen (name
);
663 if (len
> *longest_so_far
)
664 *longest_so_far
= len
;
668 dump_headers (bfd
*abfd
)
670 /* The default width of 13 is just an arbitrary choice. */
671 int max_section_name_length
= 13;
677 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
678 if (bfd_get_arch_size (abfd
) == 32)
684 printf (_("Sections:\n"));
687 bfd_map_over_sections (abfd
, find_longest_section_name
,
688 &max_section_name_length
);
690 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
691 max_section_name_length
, "Name",
692 bfd_vma_width
, "VMA",
693 bfd_vma_width
, "LMA");
696 printf (_(" Flags"));
699 bfd_map_over_sections (abfd
, dump_section_header
,
700 &max_section_name_length
);
704 slurp_symtab (bfd
*abfd
)
709 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
715 storage
= bfd_get_symtab_upper_bound (abfd
);
718 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
719 bfd_fatal (_("error message was"));
722 sy
= (asymbol
**) xmalloc (storage
);
724 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
726 bfd_fatal (bfd_get_filename (abfd
));
730 /* Read in the dynamic symbols. */
733 slurp_dynamic_symtab (bfd
*abfd
)
738 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
741 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
743 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
749 bfd_fatal (bfd_get_filename (abfd
));
752 sy
= (asymbol
**) xmalloc (storage
);
754 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
756 bfd_fatal (bfd_get_filename (abfd
));
760 /* Some symbol names are significant and should be kept in the
761 table of sorted symbol names, even if they are marked as
762 debugging/section symbols. */
765 is_significant_symbol_name (const char * name
)
767 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
770 /* Filter out (in place) symbols that are useless for disassembly.
771 COUNT is the number of elements in SYMBOLS.
772 Return the number of useful symbols. */
775 remove_useless_symbols (asymbol
**symbols
, long count
)
777 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
781 asymbol
*sym
= *in_ptr
++;
783 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
785 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
786 && ! is_significant_symbol_name (sym
->name
))
788 if (bfd_is_und_section (sym
->section
)
789 || bfd_is_com_section (sym
->section
))
794 return out_ptr
- symbols
;
797 /* Sort symbols into value order. */
800 compare_symbols (const void *ap
, const void *bp
)
802 const asymbol
*a
= * (const asymbol
**) ap
;
803 const asymbol
*b
= * (const asymbol
**) bp
;
813 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
815 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
818 if (a
->section
> b
->section
)
820 else if (a
->section
< b
->section
)
823 an
= bfd_asymbol_name (a
);
824 bn
= bfd_asymbol_name (b
);
828 /* The symbols gnu_compiled and gcc2_compiled convey no real
829 information, so put them after other symbols with the same value. */
830 af
= (strstr (an
, "gnu_compiled") != NULL
831 || strstr (an
, "gcc2_compiled") != NULL
);
832 bf
= (strstr (bn
, "gnu_compiled") != NULL
833 || strstr (bn
, "gcc2_compiled") != NULL
);
840 /* We use a heuristic for the file name, to try to sort it after
841 more useful symbols. It may not work on non Unix systems, but it
842 doesn't really matter; the only difference is precisely which
843 symbol names get printed. */
845 #define file_symbol(s, sn, snl) \
846 (((s)->flags & BSF_FILE) != 0 \
847 || ((sn)[(snl) - 2] == '.' \
848 && ((sn)[(snl) - 1] == 'o' \
849 || (sn)[(snl) - 1] == 'a')))
851 af
= file_symbol (a
, an
, anl
);
852 bf
= file_symbol (b
, bn
, bnl
);
859 /* Try to sort global symbols before local symbols before function
860 symbols before debugging symbols. */
865 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
867 if ((aflags
& BSF_DEBUGGING
) != 0)
872 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
874 if ((aflags
& BSF_FUNCTION
) != 0)
879 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
881 if ((aflags
& BSF_LOCAL
) != 0)
886 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
888 if ((aflags
& BSF_GLOBAL
) != 0)
894 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
895 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
900 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
901 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
903 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
904 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
906 return asz
> bsz
? -1 : 1;
909 /* Symbols that start with '.' might be section names, so sort them
910 after symbols that don't start with '.'. */
911 if (an
[0] == '.' && bn
[0] != '.')
913 if (an
[0] != '.' && bn
[0] == '.')
916 /* Finally, if we can't distinguish them in any other way, try to
917 get consistent results by sorting the symbols by name. */
918 return strcmp (an
, bn
);
921 /* Sort relocs into address order. */
924 compare_relocs (const void *ap
, const void *bp
)
926 const arelent
*a
= * (const arelent
**) ap
;
927 const arelent
*b
= * (const arelent
**) bp
;
929 if (a
->address
> b
->address
)
931 else if (a
->address
< b
->address
)
934 /* So that associated relocations tied to the same address show up
935 in the correct order, we don't do any further sorting. */
944 /* Print an address (VMA) to the output stream in INFO.
945 If SKIP_ZEROES is TRUE, omit leading zeroes. */
948 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
949 bfd_boolean skip_zeroes
)
953 struct objdump_disasm_info
*aux
;
955 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
956 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
961 for (p
= buf
; *p
== '0'; ++p
)
966 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
969 /* Print the name of a symbol. */
972 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
976 const char *name
, *version_string
= NULL
;
977 bfd_boolean hidden
= FALSE
;
980 name
= bfd_asymbol_name (sym
);
981 if (do_demangle
&& name
[0] != '\0')
983 /* Demangle the name. */
984 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
989 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
990 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
992 if (bfd_is_und_section (bfd_get_section (sym
)))
995 name
= sanitize_string (name
);
999 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1000 if (version_string
&& *version_string
!= '\0')
1001 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1006 printf ("%s", name
);
1007 if (version_string
&& *version_string
!= '\0')
1008 printf (hidden
? "@%s" : "@@%s", version_string
);
1015 static inline bfd_boolean
1016 sym_ok (bfd_boolean want_section
,
1017 bfd
* abfd ATTRIBUTE_UNUSED
,
1020 struct disassemble_info
* inf
)
1024 /* Note - we cannot just compare section pointers because they could
1025 be different, but the same... Ie the symbol that we are trying to
1026 find could have come from a separate debug info file. Under such
1027 circumstances the symbol will be associated with a section in the
1028 debug info file, whilst the section we want is in a normal file.
1029 So the section pointers will be different, but the section names
1030 will be the same. */
1031 if (strcmp (bfd_section_name (abfd
, sorted_syms
[place
]->section
),
1032 bfd_section_name (abfd
, sec
)) != 0)
1036 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1039 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1040 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1041 require the symbol to be in the section. Returns NULL if there is no
1042 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1043 of the symbol in sorted_syms. */
1046 find_symbol_for_address (bfd_vma vma
,
1047 struct disassemble_info
*inf
,
1050 /* @@ Would it speed things up to cache the last two symbols returned,
1051 and maybe their address ranges? For many processors, only one memory
1052 operand can be present at a time, so the 2-entry cache wouldn't be
1053 constantly churned by code doing heavy memory accesses. */
1055 /* Indices in `sorted_syms'. */
1057 long max_count
= sorted_symcount
;
1059 struct objdump_disasm_info
*aux
;
1063 bfd_boolean want_section
;
1066 if (sorted_symcount
< 1)
1069 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1072 opb
= inf
->octets_per_byte
;
1074 /* Perform a binary search looking for the closest symbol to the
1075 required value. We are searching the range (min, max_count]. */
1076 while (min
+ 1 < max_count
)
1080 thisplace
= (max_count
+ min
) / 2;
1081 sym
= sorted_syms
[thisplace
];
1083 if (bfd_asymbol_value (sym
) > vma
)
1084 max_count
= thisplace
;
1085 else if (bfd_asymbol_value (sym
) < vma
)
1094 /* The symbol we want is now in min, the low end of the range we
1095 were searching. If there are several symbols with the same
1096 value, we want the first (non-section/non-debugging) one. */
1098 while (thisplace
> 0
1099 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1100 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1101 && ((sorted_syms
[thisplace
- 1]->flags
1102 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1106 /* Prefer a symbol in the current section if we have multple symbols
1107 with the same value, as can occur with overlays or zero size
1110 while (min
< max_count
1111 && (bfd_asymbol_value (sorted_syms
[min
])
1112 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1114 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1121 return sorted_syms
[thisplace
];
1126 /* If the file is relocatable, and the symbol could be from this
1127 section, prefer a symbol from this section over symbols from
1128 others, even if the other symbol's value might be closer.
1130 Note that this may be wrong for some symbol references if the
1131 sections have overlapping memory ranges, but in that case there's
1132 no way to tell what's desired without looking at the relocation
1135 Also give the target a chance to reject symbols. */
1136 want_section
= (aux
->require_sec
1137 || ((abfd
->flags
& HAS_RELOC
) != 0
1138 && vma
>= bfd_get_section_vma (abfd
, sec
)
1139 && vma
< (bfd_get_section_vma (abfd
, sec
)
1140 + bfd_section_size (abfd
, sec
) / opb
)));
1142 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1145 long newplace
= sorted_symcount
;
1147 for (i
= min
- 1; i
>= 0; i
--)
1149 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1151 if (newplace
== sorted_symcount
)
1154 if (bfd_asymbol_value (sorted_syms
[i
])
1155 != bfd_asymbol_value (sorted_syms
[newplace
]))
1158 /* Remember this symbol and keep searching until we reach
1159 an earlier address. */
1164 if (newplace
!= sorted_symcount
)
1165 thisplace
= newplace
;
1168 /* We didn't find a good symbol with a smaller value.
1169 Look for one with a larger value. */
1170 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1172 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1180 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1181 /* There is no suitable symbol. */
1185 /* If we have not found an exact match for the specified address
1186 and we have dynamic relocations available, then we can produce
1187 a better result by matching a relocation to the address and
1188 using the symbol associated with that relocation. */
1189 rel_count
= aux
->dynrelcount
;
1191 && sorted_syms
[thisplace
]->value
!= vma
1193 && aux
->dynrelbuf
!= NULL
1194 && aux
->dynrelbuf
[0]->address
<= vma
1195 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1196 /* If we have matched a synthetic symbol, then stick with that. */
1197 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1200 arelent
** rel_high
;
1202 rel_low
= aux
->dynrelbuf
;
1203 rel_high
= rel_low
+ rel_count
- 1;
1204 while (rel_low
<= rel_high
)
1206 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1207 arelent
* rel
= *rel_mid
;
1209 if (rel
->address
== vma
)
1211 /* Absolute relocations do not provide a more helpful
1212 symbolic address. Find a non-absolute relocation
1213 with the same address. */
1214 arelent
**rel_vma
= rel_mid
;
1216 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1220 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1224 if (rel
->sym_ptr_ptr
!= NULL
1225 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1228 * place
= thisplace
;
1229 return * rel
->sym_ptr_ptr
;
1235 if (vma
< rel
->address
)
1237 else if (vma
>= rel_mid
[1]->address
)
1238 rel_low
= rel_mid
+ 1;
1247 return sorted_syms
[thisplace
];
1250 /* Print an address and the offset to the nearest symbol. */
1253 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1254 bfd_vma vma
, struct disassemble_info
*inf
,
1255 bfd_boolean skip_zeroes
)
1257 objdump_print_value (vma
, inf
, skip_zeroes
);
1263 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1264 sanitize_string (bfd_get_section_name (abfd
, sec
)));
1265 secaddr
= bfd_get_section_vma (abfd
, sec
);
1268 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1269 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1271 else if (vma
> secaddr
)
1273 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1274 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1276 (*inf
->fprintf_func
) (inf
->stream
, ">");
1280 (*inf
->fprintf_func
) (inf
->stream
, " <");
1282 objdump_print_symname (abfd
, inf
, sym
);
1284 if (bfd_asymbol_value (sym
) == vma
)
1286 /* Undefined symbols in an executables and dynamic objects do not have
1287 a value associated with them, so it does not make sense to display
1288 an offset relative to them. Normally we would not be provided with
1289 this kind of symbol, but the target backend might choose to do so,
1290 and the code in find_symbol_for_address might return an as yet
1291 unresolved symbol associated with a dynamic reloc. */
1292 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1293 && bfd_is_und_section (sym
->section
))
1295 else if (bfd_asymbol_value (sym
) > vma
)
1297 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1298 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1300 else if (vma
> bfd_asymbol_value (sym
))
1302 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1303 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1306 (*inf
->fprintf_func
) (inf
->stream
, ">");
1309 if (display_file_offsets
)
1310 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1311 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1314 /* Print an address (VMA), symbolically if possible.
1315 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1318 objdump_print_addr (bfd_vma vma
,
1319 struct disassemble_info
*inf
,
1320 bfd_boolean skip_zeroes
)
1322 struct objdump_disasm_info
*aux
;
1323 asymbol
*sym
= NULL
;
1324 bfd_boolean skip_find
= FALSE
;
1326 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1328 if (sorted_symcount
< 1)
1330 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1331 objdump_print_value (vma
, inf
, skip_zeroes
);
1333 if (display_file_offsets
)
1334 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1335 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1339 if (aux
->reloc
!= NULL
1340 && aux
->reloc
->sym_ptr_ptr
!= NULL
1341 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1343 sym
= * aux
->reloc
->sym_ptr_ptr
;
1345 /* Adjust the vma to the reloc. */
1346 vma
+= bfd_asymbol_value (sym
);
1348 if (bfd_is_und_section (bfd_get_section (sym
)))
1353 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1355 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1359 /* Print VMA to INFO. This function is passed to the disassembler
1363 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1365 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1368 /* Determine if the given address has a symbol associated with it. */
1371 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1375 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1377 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1380 /* Hold the last function name and the last line number we displayed
1381 in a disassembly. */
1383 static char *prev_functionname
;
1384 static unsigned int prev_line
;
1385 static unsigned int prev_discriminator
;
1387 /* We keep a list of all files that we have seen when doing a
1388 disassembly with source, so that we know how much of the file to
1389 display. This can be important for inlined functions. */
1391 struct print_file_list
1393 struct print_file_list
*next
;
1394 const char *filename
;
1395 const char *modname
;
1398 const char **linemap
;
1401 unsigned max_printed
;
1405 static struct print_file_list
*print_files
;
1407 /* The number of preceding context lines to show when we start
1408 displaying a file for the first time. */
1410 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1412 /* Read a complete file into memory. */
1415 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1418 int ps
= getpagesize ();
1422 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1426 if (fstat (fd
, fst
) < 0)
1431 *size
= fst
->st_size
;
1433 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1434 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1435 if (map
!= (char *) -1L)
1441 map
= (const char *) malloc (*size
);
1442 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1444 free ((void *) map
);
1451 #define line_map_decrease 5
1453 /* Precompute array of lines for a mapped file. */
1455 static const char **
1456 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1458 const char *p
, *lstart
, *end
;
1459 int chars_per_line
= 45; /* First iteration will use 40. */
1460 unsigned int lineno
;
1461 const char **linemap
= NULL
;
1462 unsigned long line_map_size
= 0;
1468 for (p
= map
; p
< end
; p
++)
1472 if (p
+ 1 < end
&& p
[1] == '\r')
1475 else if (*p
== '\r')
1477 if (p
+ 1 < end
&& p
[1] == '\n')
1483 /* End of line found. */
1485 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1487 unsigned long newsize
;
1489 chars_per_line
-= line_map_decrease
;
1490 if (chars_per_line
<= 1)
1492 line_map_size
= size
/ chars_per_line
+ 1;
1493 if (line_map_size
< lineno
+ 1)
1494 line_map_size
= lineno
+ 1;
1495 newsize
= line_map_size
* sizeof (char *);
1496 linemap
= (const char **) xrealloc (linemap
, newsize
);
1499 linemap
[lineno
++] = lstart
;
1507 /* Tries to open MODNAME, and if successful adds a node to print_files
1508 linked list and returns that node. Returns NULL on failure. */
1510 static struct print_file_list
*
1511 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1513 struct print_file_list
*p
;
1515 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1517 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1524 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1527 p
->filename
= origname
;
1528 p
->modname
= modname
;
1529 p
->next
= print_files
;
1535 /* If the source file, as described in the symtab, is not found
1536 try to locate it in one of the paths specified with -I
1537 If found, add location to print_files linked list. */
1539 static struct print_file_list
*
1540 update_source_path (const char *filename
, bfd
*abfd
)
1542 struct print_file_list
*p
;
1547 p
= try_print_file_open (filename
, filename
, &fst
);
1550 if (include_path_count
== 0)
1553 /* Get the name of the file. */
1554 fname
= lbasename (filename
);
1556 /* If file exists under a new path, we need to add it to the list
1557 so that show_line knows about it. */
1558 for (i
= 0; i
< include_path_count
; i
++)
1560 char *modname
= concat (include_paths
[i
], "/", fname
,
1563 p
= try_print_file_open (filename
, modname
, &fst
);
1573 long mtime
= bfd_get_mtime (abfd
);
1575 if (fst
.st_mtime
> mtime
)
1576 warn (_("source file %s is more recent than object file\n"),
1583 /* Print a source file line. */
1586 print_line (struct print_file_list
*p
, unsigned int linenum
)
1592 if (linenum
>= p
->maxline
)
1594 l
= p
->linemap
[linenum
];
1595 /* Test fwrite return value to quiet glibc warning. */
1596 len
= strcspn (l
, "\n\r");
1597 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1601 /* Print a range of source code lines. */
1604 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1608 while (start
<= end
)
1610 print_line (p
, start
);
1615 /* Show the line number, or the source line, in a disassembly
1619 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1621 const char *filename
;
1622 const char *functionname
;
1623 unsigned int linenumber
;
1624 unsigned int discriminator
;
1628 if (! with_line_numbers
&& ! with_source_code
)
1631 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1632 &filename
, &functionname
,
1633 &linenumber
, &discriminator
))
1636 if (filename
!= NULL
&& *filename
== '\0')
1638 if (functionname
!= NULL
&& *functionname
== '\0')
1639 functionname
= NULL
;
1642 && IS_ABSOLUTE_PATH (filename
)
1646 const char *fname
= filename
;
1648 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1651 memcpy (path
, prefix
, prefix_length
);
1652 path_up
= path
+ prefix_length
;
1654 /* Build relocated filename, stripping off leading directories
1655 from the initial filename if requested. */
1656 if (prefix_strip
> 0)
1661 /* Skip selected directory levels. */
1662 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1663 if (IS_DIR_SEPARATOR(*s
))
1670 /* Update complete filename. */
1671 strncpy (path_up
, fname
, PATH_MAX
);
1672 path_up
[PATH_MAX
] = '\0';
1680 if (with_line_numbers
)
1682 if (functionname
!= NULL
1683 && (prev_functionname
== NULL
1684 || strcmp (functionname
, prev_functionname
) != 0))
1686 printf ("%s():\n", sanitize_string (functionname
));
1690 && (linenumber
!= prev_line
1691 || discriminator
!= prev_discriminator
))
1693 if (discriminator
> 0)
1694 printf ("%s:%u (discriminator %u)\n",
1695 filename
== NULL
? "???" : sanitize_string (filename
),
1696 linenumber
, discriminator
);
1698 printf ("%s:%u\n", filename
== NULL
1699 ? "???" : sanitize_string (filename
),
1704 const char *filename2
;
1705 const char *functionname2
;
1708 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1711 printf ("inlined by %s:%u",
1712 sanitize_string (filename2
), line2
);
1713 printf (" (%s)\n", sanitize_string (functionname2
));
1718 if (with_source_code
1722 struct print_file_list
**pp
, *p
;
1725 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1726 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1733 filename
= xstrdup (filename
);
1734 p
= update_source_path (filename
, abfd
);
1737 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1739 if (file_start_context
&& p
->first
)
1743 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1744 if (l
>= linenumber
)
1746 if (p
->max_printed
>= l
)
1748 if (p
->max_printed
< linenumber
)
1749 l
= p
->max_printed
+ 1;
1754 dump_lines (p
, l
, linenumber
);
1755 if (p
->max_printed
< linenumber
)
1756 p
->max_printed
= linenumber
;
1757 p
->last_line
= linenumber
;
1762 if (functionname
!= NULL
1763 && (prev_functionname
== NULL
1764 || strcmp (functionname
, prev_functionname
) != 0))
1766 if (prev_functionname
!= NULL
)
1767 free (prev_functionname
);
1768 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1769 strcpy (prev_functionname
, functionname
);
1772 if (linenumber
> 0 && linenumber
!= prev_line
)
1773 prev_line
= linenumber
;
1775 if (discriminator
!= prev_discriminator
)
1776 prev_discriminator
= discriminator
;
1782 /* Pseudo FILE object for strings. */
1790 /* sprintf to a "stream". */
1792 static int ATTRIBUTE_PRINTF_2
1793 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1800 size_t space
= f
->alloc
- f
->pos
;
1802 va_start (args
, format
);
1803 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1809 f
->alloc
= (f
->alloc
+ n
) * 2;
1810 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1817 /* The number of zeroes we want to see before we start skipping them.
1818 The number is arbitrarily chosen. */
1820 #define DEFAULT_SKIP_ZEROES 8
1822 /* The number of zeroes to skip at the end of a section. If the
1823 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1824 SKIP_ZEROES, they will be disassembled. If there are fewer than
1825 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1826 attempt to avoid disassembling zeroes inserted by section
1829 #define DEFAULT_SKIP_ZEROES_AT_END 3
1831 /* Disassemble some data in memory between given values. */
1834 disassemble_bytes (struct disassemble_info
* inf
,
1835 disassembler_ftype disassemble_fn
,
1838 bfd_vma start_offset
,
1839 bfd_vma stop_offset
,
1842 arelent
** relppend
)
1844 struct objdump_disasm_info
*aux
;
1846 int octets_per_line
;
1847 int skip_addr_chars
;
1848 bfd_vma addr_offset
;
1849 unsigned int opb
= inf
->octets_per_byte
;
1850 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1851 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1855 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1859 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1863 octets_per_line
= insn_width
;
1865 octets_per_line
= 4;
1867 octets_per_line
= 16;
1869 /* Figure out how many characters to skip at the start of an
1870 address, to make the disassembly look nicer. We discard leading
1871 zeroes in chunks of 4, ensuring that there is always a leading
1873 skip_addr_chars
= 0;
1874 if (! prefix_addresses
)
1878 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1880 while (buf
[skip_addr_chars
] == '0')
1883 /* Don't discard zeros on overflow. */
1884 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1885 skip_addr_chars
= 0;
1887 if (skip_addr_chars
!= 0)
1888 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1891 inf
->insn_info_valid
= 0;
1893 addr_offset
= start_offset
;
1894 while (addr_offset
< stop_offset
)
1897 bfd_boolean need_nl
= FALSE
;
1898 int previous_octets
;
1900 /* Remember the length of the previous instruction. */
1901 previous_octets
= octets
;
1904 /* Make sure we don't use relocs from previous instructions. */
1907 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1909 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1912 if (! disassemble_zeroes
1913 && (inf
->insn_info_valid
== 0
1914 || inf
->branch_delay_insns
== 0)
1915 && (z
- addr_offset
* opb
>= skip_zeroes
1916 || (z
== stop_offset
* opb
&&
1917 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1919 /* If there are more nonzero octets to follow, we only skip
1920 zeroes in multiples of 4, to try to avoid running over
1921 the start of an instruction which happens to start with
1923 if (z
!= stop_offset
* opb
)
1924 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1926 octets
= z
- addr_offset
* opb
;
1928 /* If we are going to display more data, and we are displaying
1929 file offsets, then tell the user how many zeroes we skip
1930 and the file offset from where we resume dumping. */
1931 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1932 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1934 (unsigned long) (section
->filepos
1935 + (addr_offset
+ (octets
/ opb
))));
1945 if (with_line_numbers
|| with_source_code
)
1946 show_line (aux
->abfd
, section
, addr_offset
);
1948 if (! prefix_addresses
)
1952 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1953 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1957 printf ("%s:\t", buf
+ skip_addr_chars
);
1961 aux
->require_sec
= TRUE
;
1962 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1963 aux
->require_sec
= FALSE
;
1970 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1971 inf
->stream
= &sfile
;
1972 inf
->bytes_per_line
= 0;
1973 inf
->bytes_per_chunk
= 0;
1974 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1975 | (wide_output
? WIDE_OUTPUT
: 0));
1977 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1979 if (inf
->disassembler_needs_relocs
1980 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1981 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1982 && *relppp
< relppend
)
1984 bfd_signed_vma distance_to_rel
;
1986 distance_to_rel
= (**relppp
)->address
1987 - (rel_offset
+ addr_offset
);
1989 /* Check to see if the current reloc is associated with
1990 the instruction that we are about to disassemble. */
1991 if (distance_to_rel
== 0
1992 /* FIXME: This is wrong. We are trying to catch
1993 relocs that are addressed part way through the
1994 current instruction, as might happen with a packed
1995 VLIW instruction. Unfortunately we do not know the
1996 length of the current instruction since we have not
1997 disassembled it yet. Instead we take a guess based
1998 upon the length of the previous instruction. The
1999 proper solution is to have a new target-specific
2000 disassembler function which just returns the length
2001 of an instruction at a given address without trying
2002 to display its disassembly. */
2003 || (distance_to_rel
> 0
2004 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2006 inf
->flags
|= INSN_HAS_RELOC
;
2007 aux
->reloc
= **relppp
;
2011 if (! disassemble_all
2012 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2013 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2014 /* Set a stop_vma so that the disassembler will not read
2015 beyond the next symbol. We assume that symbols appear on
2016 the boundaries between instructions. We only do this when
2017 disassembling code of course, and when -D is in effect. */
2018 inf
->stop_vma
= section
->vma
+ stop_offset
;
2020 inf
->stop_offset
= stop_offset
;
2021 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2024 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2025 inf
->stream
= stdout
;
2026 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2027 octets_per_line
= inf
->bytes_per_line
;
2028 if (octets
< (int) opb
)
2031 printf ("%s\n", sfile
.buffer
);
2034 non_fatal (_("disassemble_fn returned length %d"),
2045 octets
= octets_per_line
;
2046 if (addr_offset
+ octets
/ opb
> stop_offset
)
2047 octets
= (stop_offset
- addr_offset
) * opb
;
2049 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2051 if (ISPRINT (data
[j
]))
2052 buf
[j
- addr_offset
* opb
] = data
[j
];
2054 buf
[j
- addr_offset
* opb
] = '.';
2056 buf
[j
- addr_offset
* opb
] = '\0';
2059 if (prefix_addresses
2061 : show_raw_insn
>= 0)
2065 /* If ! prefix_addresses and ! wide_output, we print
2066 octets_per_line octets per line. */
2068 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2069 pb
= octets_per_line
;
2071 if (inf
->bytes_per_chunk
)
2072 bpc
= inf
->bytes_per_chunk
;
2076 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2078 /* PR 21580: Check for a buffer ending early. */
2079 if (j
+ bpc
<= stop_offset
* opb
)
2083 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2085 for (k
= bpc
- 1; k
>= 0; k
--)
2086 printf ("%02x", (unsigned) data
[j
+ k
]);
2090 for (k
= 0; k
< bpc
; k
++)
2091 printf ("%02x", (unsigned) data
[j
+ k
]);
2097 for (; pb
< octets_per_line
; pb
+= bpc
)
2101 for (k
= 0; k
< bpc
; k
++)
2106 /* Separate raw data from instruction by extra space. */
2116 printf ("%s", sfile
.buffer
);
2118 if (prefix_addresses
2120 : show_raw_insn
>= 0)
2128 j
= addr_offset
* opb
+ pb
;
2130 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2131 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2135 printf ("%s:\t", buf
+ skip_addr_chars
);
2137 pb
+= octets_per_line
;
2140 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2142 /* PR 21619: Check for a buffer ending early. */
2143 if (j
+ bpc
<= stop_offset
* opb
)
2147 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2149 for (k
= bpc
- 1; k
>= 0; k
--)
2150 printf ("%02x", (unsigned) data
[j
+ k
]);
2154 for (k
= 0; k
< bpc
; k
++)
2155 printf ("%02x", (unsigned) data
[j
+ k
]);
2169 while ((*relppp
) < relppend
2170 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2172 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2183 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2186 if (q
->howto
== NULL
)
2187 printf (": *unknown*\t");
2188 else if (q
->howto
->name
)
2189 printf (": %s\t", q
->howto
->name
);
2191 printf (": %d\t", q
->howto
->type
);
2193 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2194 printf ("*unknown*");
2197 const char *sym_name
;
2199 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2200 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2201 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2206 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2207 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2208 if (sym_name
== NULL
|| *sym_name
== '\0')
2209 sym_name
= "*unknown*";
2210 printf ("%s", sanitize_string (sym_name
));
2216 bfd_signed_vma addend
= q
->addend
;
2224 objdump_print_value (addend
, inf
, TRUE
);
2236 addr_offset
+= octets
/ opb
;
2239 free (sfile
.buffer
);
2243 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2245 const struct elf_backend_data
* bed
;
2246 bfd_vma sign_adjust
= 0;
2247 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2248 struct objdump_disasm_info
* paux
;
2249 unsigned int opb
= pinfo
->octets_per_byte
;
2250 bfd_byte
* data
= NULL
;
2251 bfd_size_type datasize
= 0;
2252 arelent
** rel_pp
= NULL
;
2253 arelent
** rel_ppstart
= NULL
;
2254 arelent
** rel_ppend
;
2255 bfd_vma stop_offset
;
2256 asymbol
* sym
= NULL
;
2260 unsigned long addr_offset
;
2261 bfd_boolean do_print
;
2264 stop_offset_reached
,
2269 /* Sections that do not contain machine
2270 code are not normally disassembled. */
2271 if (! disassemble_all
2272 && only_list
== NULL
2273 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2274 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2277 if (! process_section_p (section
))
2280 datasize
= bfd_get_section_size (section
);
2284 if (start_address
== (bfd_vma
) -1
2285 || start_address
< section
->vma
)
2288 addr_offset
= start_address
- section
->vma
;
2290 if (stop_address
== (bfd_vma
) -1)
2291 stop_offset
= datasize
/ opb
;
2294 if (stop_address
< section
->vma
)
2297 stop_offset
= stop_address
- section
->vma
;
2298 if (stop_offset
> datasize
/ opb
)
2299 stop_offset
= datasize
/ opb
;
2302 if (addr_offset
>= stop_offset
)
2305 /* Decide which set of relocs to use. Load them if necessary. */
2306 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2307 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2309 rel_pp
= paux
->dynrelbuf
;
2310 rel_count
= paux
->dynrelcount
;
2311 /* Dynamic reloc addresses are absolute, non-dynamic are section
2312 relative. REL_OFFSET specifies the reloc address corresponding
2313 to the start of this section. */
2314 rel_offset
= section
->vma
;
2322 if ((section
->flags
& SEC_RELOC
) != 0
2323 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2327 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2329 bfd_fatal (bfd_get_filename (abfd
));
2333 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2334 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2336 bfd_fatal (bfd_get_filename (abfd
));
2338 /* Sort the relocs by address. */
2339 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2343 rel_ppend
= rel_pp
+ rel_count
;
2345 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2347 non_fatal (_("Reading section %s failed because: %s"),
2348 section
->name
, bfd_errmsg (bfd_get_error ()));
2352 paux
->sec
= section
;
2353 pinfo
->buffer
= data
;
2354 pinfo
->buffer_vma
= section
->vma
;
2355 pinfo
->buffer_length
= datasize
;
2356 pinfo
->section
= section
;
2358 /* Skip over the relocs belonging to addresses below the
2360 while (rel_pp
< rel_ppend
2361 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2364 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2366 /* Find the nearest symbol forwards from our current position. */
2367 paux
->require_sec
= TRUE
;
2368 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2369 (struct disassemble_info
*) inf
,
2371 paux
->require_sec
= FALSE
;
2373 /* PR 9774: If the target used signed addresses then we must make
2374 sure that we sign extend the value that we calculate for 'addr'
2375 in the loop below. */
2376 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2377 && (bed
= get_elf_backend_data (abfd
)) != NULL
2378 && bed
->sign_extend_vma
)
2379 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2381 /* Disassemble a block of instructions up to the address associated with
2382 the symbol we have just found. Then print the symbol and find the
2383 next symbol on. Repeat until we have disassembled the entire section
2384 or we have reached the end of the address range we are interested in. */
2385 do_print
= paux
->symbol
== NULL
;
2386 loop_until
= stop_offset_reached
;
2388 while (addr_offset
< stop_offset
)
2392 bfd_vma nextstop_offset
;
2395 addr
= section
->vma
+ addr_offset
;
2396 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2398 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2403 (x
< sorted_symcount
2404 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2408 pinfo
->symbols
= sorted_syms
+ place
;
2409 pinfo
->num_symbols
= x
- place
;
2410 pinfo
->symtab_pos
= place
;
2414 pinfo
->symbols
= NULL
;
2415 pinfo
->num_symbols
= 0;
2416 pinfo
->symtab_pos
= -1;
2419 /* If we are only disassembling from a specific symbol,
2420 check to see if we should start or stop displaying. */
2421 if (sym
&& paux
->symbol
)
2425 /* See if we should stop printing. */
2429 if (sym
->flags
& BSF_FUNCTION
)
2433 case stop_offset_reached
:
2434 /* Handled by the while loop. */
2438 /* FIXME: There is an implicit assumption here
2439 that the name of sym is different from
2441 if (! bfd_is_local_label (abfd
, sym
))
2448 const char * name
= bfd_asymbol_name (sym
);
2449 char * alloc
= NULL
;
2451 if (do_demangle
&& name
[0] != '\0')
2453 /* Demangle the name. */
2454 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2459 /* We are not currently printing. Check to see
2460 if the current symbol matches the requested symbol. */
2461 if (streq (name
, paux
->symbol
))
2465 if (sym
->flags
& BSF_FUNCTION
)
2467 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2468 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2470 /* Sym is a function symbol with a size associated
2471 with it. Turn on automatic disassembly for the
2472 next VALUE bytes. */
2473 stop_offset
= addr_offset
2474 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2475 loop_until
= stop_offset_reached
;
2479 /* Otherwise we need to tell the loop heuristic to
2480 loop until the next function symbol is encountered. */
2481 loop_until
= function_sym
;
2486 /* Otherwise loop until the next symbol is encountered. */
2487 loop_until
= next_sym
;
2495 if (! prefix_addresses
&& do_print
)
2497 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2498 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2500 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2503 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2505 else if (sym
== NULL
)
2509 #define is_valid_next_sym(SYM) \
2510 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2511 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2512 && pinfo->symbol_is_valid (SYM, pinfo))
2514 /* Search forward for the next appropriate symbol in
2515 SECTION. Note that all the symbols are sorted
2516 together into one big array, and that some sections
2517 may have overlapping addresses. */
2518 while (place
< sorted_symcount
2519 && ! is_valid_next_sym (sorted_syms
[place
]))
2522 if (place
>= sorted_symcount
)
2525 nextsym
= sorted_syms
[place
];
2528 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2529 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2530 else if (nextsym
== NULL
)
2531 nextstop_offset
= stop_offset
;
2533 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2535 if (nextstop_offset
> stop_offset
2536 || nextstop_offset
<= addr_offset
)
2537 nextstop_offset
= stop_offset
;
2539 /* If a symbol is explicitly marked as being an object
2540 rather than a function, just dump the bytes without
2541 disassembling them. */
2544 || sym
->section
!= section
2545 || bfd_asymbol_value (sym
) > addr
2546 || ((sym
->flags
& BSF_OBJECT
) == 0
2547 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2549 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2551 || (sym
->flags
& BSF_FUNCTION
) != 0)
2557 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2558 addr_offset
, nextstop_offset
,
2559 rel_offset
, &rel_pp
, rel_ppend
);
2561 addr_offset
= nextstop_offset
;
2567 if (rel_ppstart
!= NULL
)
2571 /* Disassemble the contents of an object file. */
2574 disassemble_data (bfd
*abfd
)
2576 struct disassemble_info disasm_info
;
2577 struct objdump_disasm_info aux
;
2581 prev_functionname
= NULL
;
2583 prev_discriminator
= 0;
2585 /* We make a copy of syms to sort. We don't want to sort syms
2586 because that will screw up the relocs. */
2587 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2588 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2589 * sizeof (asymbol
*));
2590 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2591 sorted_symcount
* sizeof (asymbol
*));
2593 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2595 for (i
= 0; i
< synthcount
; ++i
)
2597 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2601 /* Sort the symbols into section and symbol order. */
2602 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2604 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2606 disasm_info
.application_data
= (void *) &aux
;
2608 aux
.require_sec
= FALSE
;
2609 aux
.dynrelbuf
= NULL
;
2610 aux
.dynrelcount
= 0;
2612 aux
.symbol
= disasm_sym
;
2614 disasm_info
.print_address_func
= objdump_print_address
;
2615 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2617 if (machine
!= NULL
)
2619 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2622 fatal (_("can't use supplied machine %s"), machine
);
2624 abfd
->arch_info
= inf
;
2627 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2629 struct bfd_target
*xvec
;
2631 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2632 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2633 xvec
->byteorder
= endian
;
2637 /* Use libopcodes to locate a suitable disassembler. */
2638 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2639 bfd_big_endian (abfd
),
2640 bfd_get_mach (abfd
), abfd
);
2641 if (!aux
.disassemble_fn
)
2643 non_fatal (_("can't disassemble for architecture %s\n"),
2644 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2649 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2650 disasm_info
.arch
= bfd_get_arch (abfd
);
2651 disasm_info
.mach
= bfd_get_mach (abfd
);
2652 disasm_info
.disassembler_options
= disassembler_options
;
2653 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2654 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2655 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2656 disasm_info
.disassembler_needs_relocs
= FALSE
;
2658 if (bfd_big_endian (abfd
))
2659 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2660 else if (bfd_little_endian (abfd
))
2661 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2663 /* ??? Aborting here seems too drastic. We could default to big or little
2665 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2667 /* Allow the target to customize the info structure. */
2668 disassemble_init_for_target (& disasm_info
);
2670 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2672 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2674 if (relsize
< 0 && dump_dynamic_reloc_info
)
2675 bfd_fatal (bfd_get_filename (abfd
));
2679 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2680 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2683 if (aux
.dynrelcount
< 0)
2684 bfd_fatal (bfd_get_filename (abfd
));
2686 /* Sort the relocs by address. */
2687 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2691 disasm_info
.symtab
= sorted_syms
;
2692 disasm_info
.symtab_size
= sorted_symcount
;
2694 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2696 if (aux
.dynrelbuf
!= NULL
)
2697 free (aux
.dynrelbuf
);
2702 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2703 asection
*sec
, void *file
)
2705 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2706 bfd
*abfd
= (bfd
*) file
;
2711 if (section
->start
!= NULL
)
2713 /* If it is already loaded, do nothing. */
2714 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2716 free (section
->start
);
2719 section
->filename
= bfd_get_filename (abfd
);
2720 section
->reloc_info
= NULL
;
2721 section
->num_relocs
= 0;
2722 section
->address
= bfd_get_section_vma (abfd
, sec
);
2723 section
->user_data
= sec
;
2724 section
->size
= bfd_get_section_size (sec
);
2725 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2726 alloced
= amt
= section
->size
+ 1;
2727 if (alloced
!= amt
|| alloced
== 0)
2729 section
->start
= NULL
;
2730 free_debug_section (debug
);
2731 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2732 sanitize_string (section
->name
),
2733 (unsigned long long) section
->size
);
2736 section
->start
= contents
= malloc (alloced
);
2737 if (section
->start
== NULL
2738 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2740 free_debug_section (debug
);
2741 printf (_("\nCan't get contents for section '%s'.\n"),
2742 sanitize_string (section
->name
));
2745 /* Ensure any string section has a terminating NUL. */
2746 section
->start
[section
->size
] = 0;
2748 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2753 bfd_cache_section_contents (sec
, section
->start
);
2755 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2762 free_debug_section (debug
);
2763 printf (_("\nCan't get contents for section '%s'.\n"),
2764 sanitize_string (section
->name
));
2768 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2771 unsigned long reloc_count
;
2774 relocs
= (arelent
**) xmalloc (reloc_size
);
2776 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2777 if (reloc_count
== 0)
2781 section
->reloc_info
= relocs
;
2782 section
->num_relocs
= reloc_count
;
2791 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2796 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2799 relocs
= (arelent
**) dsec
->reloc_info
;
2801 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2802 if (rp
->address
== offset
)
2809 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2811 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2812 bfd
*abfd
= (bfd
*) file
;
2815 /* If it is already loaded, do nothing. */
2816 if (section
->start
!= NULL
)
2818 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2822 /* Locate the debug section. */
2823 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2825 section
->name
= section
->uncompressed_name
;
2828 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2830 section
->name
= section
->compressed_name
;
2835 return load_specific_debug_section (debug
, sec
, file
);
2839 free_debug_section (enum dwarf_section_display_enum debug
)
2841 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2843 if (section
->start
== NULL
)
2846 /* PR 17512: file: 0f67f69d. */
2847 if (section
->user_data
!= NULL
)
2849 asection
* sec
= (asection
*) section
->user_data
;
2851 /* If we are freeing contents that are also pointed to by the BFD
2852 library's section structure then make sure to update those pointers
2853 too. Otherwise, the next time we try to load data for this section
2854 we can end up using a stale pointer. */
2855 if (section
->start
== sec
->contents
)
2857 sec
->contents
= NULL
;
2858 sec
->flags
&= ~ SEC_IN_MEMORY
;
2859 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2863 free ((char *) section
->start
);
2864 section
->start
= NULL
;
2865 section
->address
= 0;
2870 close_debug_file (void * file
)
2872 bfd
* abfd
= (bfd
*) file
;
2878 open_debug_file (const char * pathname
)
2882 data
= bfd_openr (pathname
, NULL
);
2886 if (! bfd_check_format (data
, bfd_object
))
2893 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2894 void *arg ATTRIBUTE_UNUSED
)
2896 const char *name
= bfd_get_section_name (abfd
, section
);
2900 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2901 match
= ".debug_info";
2905 for (i
= 0; i
< max
; i
++)
2906 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2907 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2908 && debug_displays
[i
].enabled
!= NULL
2909 && *debug_displays
[i
].enabled
)
2911 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2913 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2914 sec
->name
= sec
->uncompressed_name
;
2916 sec
->name
= sec
->compressed_name
;
2917 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2920 debug_displays
[i
].display (sec
, abfd
);
2922 if (i
!= info
&& i
!= abbrev
)
2923 free_debug_section ((enum dwarf_section_display_enum
) i
);
2929 /* Dump the dwarf debugging information. */
2932 dump_dwarf (bfd
*abfd
)
2934 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2935 if (byte_get
== NULL
)
2937 warn (_("File %s does not contain any dwarf debug information\n"),
2938 bfd_get_filename (abfd
));
2942 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2944 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2946 switch (bfd_get_arch (abfd
))
2949 switch (bfd_get_mach (abfd
))
2951 case bfd_mach_x86_64
:
2952 case bfd_mach_x86_64_intel_syntax
:
2953 case bfd_mach_x86_64_nacl
:
2954 case bfd_mach_x64_32
:
2955 case bfd_mach_x64_32_intel_syntax
:
2956 case bfd_mach_x64_32_nacl
:
2957 init_dwarf_regnames_x86_64 ();
2961 init_dwarf_regnames_i386 ();
2966 case bfd_arch_iamcu
:
2967 init_dwarf_regnames_iamcu ();
2970 case bfd_arch_aarch64
:
2971 init_dwarf_regnames_aarch64();
2975 init_dwarf_regnames_s390 ();
2978 case bfd_arch_riscv
:
2979 init_dwarf_regnames_riscv ();
2983 /* S12Z has a 24 bit address space. But the only known
2984 producer of dwarf_info encodes addresses into 32 bits. */
2992 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2995 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2996 it. Return NULL on failure. */
2999 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3000 bfd_size_type
*entsize_ptr
)
3005 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3006 if (stabsect
== NULL
)
3008 printf (_("No %s section present\n\n"),
3009 sanitize_string (sect_name
));
3013 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3015 non_fatal (_("reading %s section of %s failed: %s"),
3016 sect_name
, bfd_get_filename (abfd
),
3017 bfd_errmsg (bfd_get_error ()));
3023 *size_ptr
= bfd_section_size (abfd
, stabsect
);
3025 *entsize_ptr
= stabsect
->entsize
;
3030 /* Stabs entries use a 12 byte format:
3031 4 byte string table index
3033 1 byte stab other field
3034 2 byte stab desc field
3036 FIXME: This will have to change for a 64 bit object format. */
3038 #define STRDXOFF (0)
3040 #define OTHEROFF (5)
3043 #define STABSIZE (12)
3045 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3046 using string table section STRSECT_NAME (in `strtab'). */
3049 print_section_stabs (bfd
*abfd
,
3050 const char *stabsect_name
,
3051 unsigned *string_offset_ptr
)
3054 unsigned file_string_table_offset
= 0;
3055 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3056 bfd_byte
*stabp
, *stabs_end
;
3059 stabs_end
= stabp
+ stab_size
;
3061 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3062 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3064 /* Loop through all symbols and print them.
3066 We start the index at -1 because there is a dummy symbol on
3067 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3068 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3072 unsigned char type
, other
;
3073 unsigned short desc
;
3076 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3077 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3078 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3079 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3080 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3082 printf ("\n%-6d ", i
);
3083 /* Either print the stab name, or, if unnamed, print its number
3084 again (makes consistent formatting for tools like awk). */
3085 name
= bfd_get_stab_name (type
);
3087 printf ("%-6s", sanitize_string (name
));
3088 else if (type
== N_UNDF
)
3091 printf ("%-6d", type
);
3092 printf (" %-6d %-6d ", other
, desc
);
3093 bfd_printf_vma (abfd
, value
);
3094 printf (" %-6lu", strx
);
3096 /* Symbols with type == 0 (N_UNDF) specify the length of the
3097 string table associated with this file. We use that info
3098 to know how to relocate the *next* file's string table indices. */
3101 file_string_table_offset
= next_file_string_table_offset
;
3102 next_file_string_table_offset
+= value
;
3106 bfd_size_type amt
= strx
+ file_string_table_offset
;
3108 /* Using the (possibly updated) string table offset, print the
3109 string (if any) associated with this symbol. */
3110 if (amt
< stabstr_size
)
3111 /* PR 17512: file: 079-79389-0.001:0.1.
3112 FIXME: May need to sanitize this string before displaying. */
3113 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3119 *string_offset_ptr
= next_file_string_table_offset
;
3124 const char * section_name
;
3125 const char * string_section_name
;
3126 unsigned string_offset
;
3131 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3134 stab_section_names
* sought
= (stab_section_names
*) names
;
3136 /* Check for section names for which stabsect_name is a prefix, to
3137 handle .stab.N, etc. */
3138 len
= strlen (sought
->section_name
);
3140 /* If the prefix matches, and the files section name ends with a
3141 nul or a digit, then we match. I.e., we want either an exact
3142 match or a section followed by a number. */
3143 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3144 && (section
->name
[len
] == 0
3145 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3148 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3149 &stabstr_size
, NULL
);
3153 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3155 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3161 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3163 stab_section_names s
;
3165 s
.section_name
= stabsect_name
;
3166 s
.string_section_name
= strsect_name
;
3167 s
.string_offset
= 0;
3169 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3175 /* Dump the any sections containing stabs debugging information. */
3178 dump_stabs (bfd
*abfd
)
3180 dump_stabs_section (abfd
, ".stab", ".stabstr");
3181 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3182 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3185 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3187 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3191 dump_bfd_header (bfd
*abfd
)
3195 printf (_("architecture: %s, "),
3196 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3197 bfd_get_mach (abfd
)));
3198 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3200 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3201 PF (HAS_RELOC
, "HAS_RELOC");
3202 PF (EXEC_P
, "EXEC_P");
3203 PF (HAS_LINENO
, "HAS_LINENO");
3204 PF (HAS_DEBUG
, "HAS_DEBUG");
3205 PF (HAS_SYMS
, "HAS_SYMS");
3206 PF (HAS_LOCALS
, "HAS_LOCALS");
3207 PF (DYNAMIC
, "DYNAMIC");
3208 PF (WP_TEXT
, "WP_TEXT");
3209 PF (D_PAGED
, "D_PAGED");
3210 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3211 printf (_("\nstart address 0x"));
3212 bfd_printf_vma (abfd
, abfd
->start_address
);
3218 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3219 it is passed, or a pointer to newly-allocated storage, in which case
3220 dump_ctf() will free it when it no longer needs it. */
3223 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3229 if (asprintf (&new_s
, "%s%s", spaces
, s
) < 0)
3234 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3237 make_ctfsect (const char *name
, bfd_byte
*data
,
3242 ctfsect
.cts_name
= name
;
3243 ctfsect
.cts_entsize
= 1;
3244 ctfsect
.cts_size
= size
;
3245 ctfsect
.cts_data
= data
;
3250 /* Dump one CTF archive member. */
3253 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3255 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3256 const char *things
[] = {"Labels", "Data objects", "Function objects",
3257 "Variables", "Types", "Strings", ""};
3261 /* Only print out the name of non-default-named archive members.
3262 The name .ctf appears everywhere, even for things that aren't
3263 really archives, so printing it out is liable to be confusing. */
3264 if (strcmp (name
, ".ctf") != 0)
3265 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3267 ctf_import (ctf
, parent
);
3268 for (i
= 1, thing
= things
; *thing
[0]; thing
++, i
++)
3270 ctf_dump_state_t
*s
= NULL
;
3273 printf ("\n %s:\n", *thing
);
3274 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3275 (void *) " ")) != NULL
)
3277 printf ("%s\n", item
);
3281 if (ctf_errno (ctf
))
3283 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3284 ctf_errmsg (ctf_errno (ctf
)));
3291 /* Dump the CTF debugging information. */
3294 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3296 ctf_archive_t
*ctfa
, *parenta
= NULL
;
3297 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3298 bfd_size_type ctfsize
, parentsize
;
3300 ctf_file_t
*parent
= NULL
;
3303 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3304 bfd_fatal (bfd_get_filename (abfd
));
3307 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3309 bfd_fatal (bfd_get_filename (abfd
));
3311 /* Load the CTF file and dump it. */
3313 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3314 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3316 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3317 bfd_fatal (bfd_get_filename (abfd
));
3322 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3323 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3325 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3326 bfd_fatal (bfd_get_filename (abfd
));
3329 /* Assume that the applicable parent archive member is the default one.
3330 (This is what all known implementations are expected to do, if they
3331 put CTFs and their parents in archives together.) */
3332 if ((parent
= ctf_arc_open_by_name (parenta
, NULL
, &err
)) == NULL
)
3334 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3335 bfd_fatal (bfd_get_filename (abfd
));
3339 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3341 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3342 ctf_file_close (parent
);
3344 ctf_close (parenta
);
3348 #endif /* HAVE_LIBCTF */
3351 dump_bfd_private_header (bfd
*abfd
)
3353 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3354 non_fatal (_("warning: private headers incomplete: %s"),
3355 bfd_errmsg (bfd_get_error ()));
3359 dump_target_specific (bfd
*abfd
)
3361 const struct objdump_private_desc
* const *desc
;
3362 struct objdump_private_option
*opt
;
3365 /* Find the desc. */
3366 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3367 if ((*desc
)->filter (abfd
))
3372 non_fatal (_("option -P/--private not supported by this file"));
3376 /* Clear all options. */
3377 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3378 opt
->selected
= FALSE
;
3380 /* Decode options. */
3381 b
= dump_private_options
;
3384 e
= strchr (b
, ',');
3389 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3390 if (strcmp (opt
->name
, b
) == 0)
3392 opt
->selected
= TRUE
;
3395 if (opt
->name
== NULL
)
3396 non_fatal (_("target specific dump '%s' not supported"), b
);
3407 (*desc
)->dump (abfd
);
3410 /* Display a section in hexadecimal format with associated characters.
3411 Each line prefixed by the zero padded address. */
3414 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3416 bfd_byte
*data
= NULL
;
3417 bfd_size_type datasize
;
3418 bfd_vma addr_offset
;
3419 bfd_vma start_offset
;
3420 bfd_vma stop_offset
;
3421 unsigned int opb
= bfd_octets_per_byte (abfd
);
3422 /* Bytes per line. */
3423 const int onaline
= 16;
3428 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3431 if (! process_section_p (section
))
3434 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3437 /* Compute the address range to display. */
3438 if (start_address
== (bfd_vma
) -1
3439 || start_address
< section
->vma
)
3442 start_offset
= start_address
- section
->vma
;
3444 if (stop_address
== (bfd_vma
) -1)
3445 stop_offset
= datasize
/ opb
;
3448 if (stop_address
< section
->vma
)
3451 stop_offset
= stop_address
- section
->vma
;
3453 if (stop_offset
> datasize
/ opb
)
3454 stop_offset
= datasize
/ opb
;
3457 if (start_offset
>= stop_offset
)
3460 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3461 if (display_file_offsets
)
3462 printf (_(" (Starting at file offset: 0x%lx)"),
3463 (unsigned long) (section
->filepos
+ start_offset
));
3466 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3468 non_fatal (_("Reading section %s failed because: %s"),
3469 section
->name
, bfd_errmsg (bfd_get_error ()));
3475 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3476 if (strlen (buf
) >= sizeof (buf
))
3480 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3482 count
= strlen (buf
) - count
;
3486 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3487 if (strlen (buf
) >= sizeof (buf
))
3491 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3493 count
= strlen (buf
) - count
;
3497 for (addr_offset
= start_offset
;
3498 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3502 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3503 count
= strlen (buf
);
3504 if ((size_t) count
>= sizeof (buf
))
3508 while (count
< width
)
3513 fputs (buf
+ count
- width
, stdout
);
3516 for (j
= addr_offset
* opb
;
3517 j
< addr_offset
* opb
+ onaline
; j
++)
3519 if (j
< stop_offset
* opb
)
3520 printf ("%02x", (unsigned) (data
[j
]));
3528 for (j
= addr_offset
* opb
;
3529 j
< addr_offset
* opb
+ onaline
; j
++)
3531 if (j
>= stop_offset
* opb
)
3534 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3541 /* Actually display the various requested regions. */
3544 dump_data (bfd
*abfd
)
3546 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3549 /* Should perhaps share code and display with nm? */
3552 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3561 max_count
= dynsymcount
;
3562 printf ("DYNAMIC SYMBOL TABLE:\n");
3567 max_count
= symcount
;
3568 printf ("SYMBOL TABLE:\n");
3572 printf (_("no symbols\n"));
3574 for (count
= 0; count
< max_count
; count
++)
3578 if (*current
== NULL
)
3579 printf (_("no information for symbol number %ld\n"), count
);
3581 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3582 printf (_("could not determine the type of symbol number %ld\n"),
3585 else if (process_section_p ((* current
)->section
)
3586 && (dump_special_syms
3587 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3589 const char *name
= (*current
)->name
;
3591 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3595 /* If we want to demangle the name, we demangle it
3596 here, and temporarily clobber it while calling
3597 bfd_print_symbol. FIXME: This is a gross hack. */
3598 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3600 (*current
)->name
= alloc
;
3601 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3602 bfd_print_symbol_all
);
3605 (*current
)->name
= name
;
3610 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3611 bfd_print_symbol_all
);
3621 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3624 char *last_filename
, *last_functionname
;
3625 unsigned int last_line
;
3626 unsigned int last_discriminator
;
3628 /* Get column headers lined up reasonably. */
3636 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3637 width
= strlen (buf
) - 7;
3639 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3642 last_filename
= NULL
;
3643 last_functionname
= NULL
;
3645 last_discriminator
= 0;
3647 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3650 const char *filename
, *functionname
;
3651 unsigned int linenumber
;
3652 unsigned int discriminator
;
3653 const char *sym_name
;
3654 const char *section_name
;
3655 bfd_vma addend2
= 0;
3657 if (start_address
!= (bfd_vma
) -1
3658 && q
->address
< start_address
)
3660 if (stop_address
!= (bfd_vma
) -1
3661 && q
->address
> stop_address
)
3664 if (with_line_numbers
3666 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3667 &filename
, &functionname
,
3668 &linenumber
, &discriminator
))
3670 if (functionname
!= NULL
3671 && (last_functionname
== NULL
3672 || strcmp (functionname
, last_functionname
) != 0))
3674 printf ("%s():\n", sanitize_string (functionname
));
3675 if (last_functionname
!= NULL
)
3676 free (last_functionname
);
3677 last_functionname
= xstrdup (functionname
);
3681 && (linenumber
!= last_line
3682 || (filename
!= NULL
3683 && last_filename
!= NULL
3684 && filename_cmp (filename
, last_filename
) != 0)
3685 || (discriminator
!= last_discriminator
)))
3687 if (discriminator
> 0)
3688 printf ("%s:%u\n", filename
== NULL
? "???" :
3689 sanitize_string (filename
), linenumber
);
3691 printf ("%s:%u (discriminator %u)\n",
3692 filename
== NULL
? "???" : sanitize_string (filename
),
3693 linenumber
, discriminator
);
3694 last_line
= linenumber
;
3695 last_discriminator
= discriminator
;
3696 if (last_filename
!= NULL
)
3697 free (last_filename
);
3698 if (filename
== NULL
)
3699 last_filename
= NULL
;
3701 last_filename
= xstrdup (filename
);
3705 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3707 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3708 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3713 section_name
= NULL
;
3716 bfd_printf_vma (abfd
, q
->address
);
3717 if (q
->howto
== NULL
)
3718 printf (" *unknown* ");
3719 else if (q
->howto
->name
)
3721 const char *name
= q
->howto
->name
;
3723 /* R_SPARC_OLO10 relocations contain two addends.
3724 But because 'arelent' lacks enough storage to
3725 store them both, the 64-bit ELF Sparc backend
3726 records this as two relocations. One R_SPARC_LO10
3727 and one R_SPARC_13, both pointing to the same
3728 address. This is merely so that we have some
3729 place to store both addend fields.
3731 Undo this transformation, otherwise the output
3732 will be confusing. */
3733 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3734 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3736 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3738 arelent
*q2
= *(p
+ 1);
3741 && q
->address
== q2
->address
3742 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3744 name
= "R_SPARC_OLO10";
3745 addend2
= q2
->addend
;
3749 printf (" %-16s ", name
);
3752 printf (" %-16d ", q
->howto
->type
);
3756 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3760 if (section_name
== NULL
)
3761 section_name
= "*unknown*";
3762 printf ("[%s]", sanitize_string (section_name
));
3767 bfd_signed_vma addend
= q
->addend
;
3775 bfd_printf_vma (abfd
, addend
);
3780 bfd_printf_vma (abfd
, addend2
);
3786 if (last_filename
!= NULL
)
3787 free (last_filename
);
3788 if (last_functionname
!= NULL
)
3789 free (last_functionname
);
3793 dump_relocs_in_section (bfd
*abfd
,
3795 void *dummy ATTRIBUTE_UNUSED
)
3797 arelent
**relpp
= NULL
;
3801 if ( bfd_is_abs_section (section
)
3802 || bfd_is_und_section (section
)
3803 || bfd_is_com_section (section
)
3804 || (! process_section_p (section
))
3805 || ((section
->flags
& SEC_RELOC
) == 0))
3808 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3810 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3813 printf (" (none)\n\n");
3821 relpp
= (arelent
**) xmalloc (relsize
);
3822 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3828 non_fatal (_("failed to read relocs in: %s"),
3829 sanitize_string (bfd_get_filename (abfd
)));
3830 bfd_fatal (_("error message was"));
3832 else if (relcount
== 0)
3833 printf (" (none)\n\n");
3837 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3844 dump_relocs (bfd
*abfd
)
3846 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3850 dump_dynamic_relocs (bfd
*abfd
)
3856 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3858 bfd_fatal (bfd_get_filename (abfd
));
3860 printf ("DYNAMIC RELOCATION RECORDS");
3863 printf (" (none)\n\n");
3866 relpp
= (arelent
**) xmalloc (relsize
);
3867 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3870 bfd_fatal (bfd_get_filename (abfd
));
3871 else if (relcount
== 0)
3872 printf (" (none)\n\n");
3876 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3883 /* Creates a table of paths, to search for source files. */
3886 add_include_path (const char *path
)
3890 include_path_count
++;
3891 include_paths
= (const char **)
3892 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3893 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3894 if (path
[1] == ':' && path
[2] == 0)
3895 path
= concat (path
, ".", (const char *) 0);
3897 include_paths
[include_path_count
- 1] = path
;
3901 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3905 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3907 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3908 section
->vma
+= adjust_section_vma
;
3910 section
->lma
+= adjust_section_vma
;
3914 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3917 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3922 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3923 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3926 /* Dump selected contents of ABFD. */
3929 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3931 const struct elf_backend_data
* bed
;
3933 if (bfd_big_endian (abfd
))
3934 byte_get
= byte_get_big_endian
;
3935 else if (bfd_little_endian (abfd
))
3936 byte_get
= byte_get_little_endian
;
3940 /* Load any separate debug information files.
3941 We do this now and without checking do_follow_links because separate
3942 debug info files may contain symbol tables that we will need when
3943 displaying information about the main file. Any memory allocated by
3944 load_separate_debug_files will be released when we call
3945 free_debug_memory below.
3947 The test on is_mainfile is there because the chain of separate debug
3948 info files is a global variable shared by all invocations of dump_bfd. */
3951 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3953 /* If asked to do so, recursively dump the separate files. */
3954 if (do_follow_links
)
3958 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3959 dump_bfd (i
->handle
, FALSE
);
3963 /* Adjust user-specified start and stop limits for targets that use
3964 signed addresses. */
3965 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3966 && (bed
= get_elf_backend_data (abfd
)) != NULL
3967 && bed
->sign_extend_vma
)
3969 start_address
= sign_extend_address (abfd
, start_address
,
3971 stop_address
= sign_extend_address (abfd
, stop_address
,
3975 /* If we are adjusting section VMA's, change them all now. Changing
3976 the BFD information is a hack. However, we must do it, or
3977 bfd_find_nearest_line will not do the right thing. */
3978 if (adjust_section_vma
!= 0)
3980 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3981 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3984 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3985 printf (_("\n%s: file format %s\n"),
3986 sanitize_string (bfd_get_filename (abfd
)),
3989 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3990 if (dump_file_header
)
3991 dump_bfd_header (abfd
);
3992 if (dump_private_headers
)
3993 dump_bfd_private_header (abfd
);
3994 if (dump_private_options
!= NULL
)
3995 dump_target_specific (abfd
);
3996 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4003 || dump_dwarf_section_info
)
4005 syms
= slurp_symtab (abfd
);
4007 /* If following links, load any symbol tables from the linked files as well. */
4008 if (do_follow_links
&& is_mainfile
)
4012 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4014 asymbol
** extra_syms
;
4015 long old_symcount
= symcount
;
4017 extra_syms
= slurp_symtab (i
->handle
);
4021 if (old_symcount
== 0)
4027 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4028 memcpy (syms
+ old_symcount
,
4030 symcount
* sizeof (asymbol
*));
4034 symcount
+= old_symcount
;
4039 if (dump_section_headers
)
4040 dump_headers (abfd
);
4042 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4043 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4044 dynsyms
= slurp_dynamic_symtab (abfd
);
4048 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4049 dynsymcount
, dynsyms
, &synthsyms
);
4055 dump_symbols (abfd
, FALSE
);
4056 if (dump_dynamic_symtab
)
4057 dump_symbols (abfd
, TRUE
);
4058 if (dump_dwarf_section_info
)
4061 if (dump_ctf_section_info
)
4062 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4064 if (dump_stab_section_info
)
4066 if (dump_reloc_info
&& ! disassemble
)
4068 if (dump_dynamic_reloc_info
&& ! disassemble
)
4069 dump_dynamic_relocs (abfd
);
4070 if (dump_section_contents
)
4073 disassemble_data (abfd
);
4079 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4080 if (dhandle
!= NULL
)
4082 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4084 dump_debugging_tags
? TRUE
: FALSE
))
4086 non_fatal (_("%s: printing debugging information failed"),
4087 bfd_get_filename (abfd
));
4093 /* PR 6483: If there was no STABS debug info in the file, try
4095 else if (! dump_dwarf_section_info
)
4097 dwarf_select_sections_all ();
4125 free_debug_memory ();
4129 display_object_bfd (bfd
*abfd
)
4133 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4135 dump_bfd (abfd
, TRUE
);
4139 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4141 nonfatal (bfd_get_filename (abfd
));
4142 list_matching_formats (matching
);
4147 if (bfd_get_error () != bfd_error_file_not_recognized
)
4149 nonfatal (bfd_get_filename (abfd
));
4153 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4155 dump_bfd (abfd
, TRUE
);
4159 nonfatal (bfd_get_filename (abfd
));
4161 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4163 list_matching_formats (matching
);
4169 display_any_bfd (bfd
*file
, int level
)
4171 /* Decompress sections unless dumping the section contents. */
4172 if (!dump_section_contents
)
4173 file
->flags
|= BFD_DECOMPRESS
;
4175 /* If the file is an archive, process all of its elements. */
4176 if (bfd_check_format (file
, bfd_archive
))
4179 bfd
*last_arfile
= NULL
;
4182 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4183 else if (level
> 100)
4185 /* Prevent corrupted files from spinning us into an
4186 infinite loop. 100 is an arbitrary heuristic. */
4187 fatal (_("Archive nesting is too deep"));
4191 printf (_("In nested archive %s:\n"),
4192 sanitize_string (bfd_get_filename (file
)));
4196 bfd_set_error (bfd_error_no_error
);
4198 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4201 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4202 nonfatal (bfd_get_filename (file
));
4206 display_any_bfd (arfile
, level
+ 1);
4208 if (last_arfile
!= NULL
)
4210 bfd_close (last_arfile
);
4211 /* PR 17512: file: ac585d01. */
4212 if (arfile
== last_arfile
)
4218 last_arfile
= arfile
;
4221 if (last_arfile
!= NULL
)
4222 bfd_close (last_arfile
);
4225 display_object_bfd (file
);
4229 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4233 if (get_file_size (filename
) < 1)
4239 file
= bfd_openr (filename
, target
);
4242 nonfatal (filename
);
4246 display_any_bfd (file
, 0);
4248 /* This is an optimization to improve the speed of objdump, especially when
4249 dumping a file with lots of associated debug informatiom. Calling
4250 bfd_close on such a file can take a non-trivial amount of time as there
4251 are lots of lists to walk and buffers to free. This is only really
4252 necessary however if we are about to load another file and we need the
4253 memory back. Otherwise, if we are about to exit, then we can save (a lot
4254 of) time by only doing a quick close, and allowing the OS to reclaim the
4259 bfd_close_all_done (file
);
4263 main (int argc
, char **argv
)
4266 char *target
= default_target
;
4267 bfd_boolean seenflag
= FALSE
;
4269 #if defined (HAVE_SETLOCALE)
4270 #if defined (HAVE_LC_MESSAGES)
4271 setlocale (LC_MESSAGES
, "");
4273 setlocale (LC_CTYPE
, "");
4276 bindtextdomain (PACKAGE
, LOCALEDIR
);
4277 textdomain (PACKAGE
);
4279 program_name
= *argv
;
4280 xmalloc_set_program_name (program_name
);
4281 bfd_set_error_program_name (program_name
);
4283 START_PROGRESS (program_name
, 0);
4285 expandargv (&argc
, &argv
);
4287 if (bfd_init () != BFD_INIT_MAGIC
)
4288 fatal (_("fatal error: libbfd ABI mismatch"));
4289 set_default_bfd_target ();
4291 while ((c
= getopt_long (argc
, argv
,
4292 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4293 long_options
, (int *) 0))
4299 break; /* We've been given a long option. */
4306 if (disassembler_options
)
4307 /* Ignore potential memory leak for now. */
4308 options
= concat (disassembler_options
, ",",
4309 optarg
, (const char *) NULL
);
4312 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4319 display_file_offsets
= TRUE
;
4322 with_line_numbers
= TRUE
;
4331 enum demangling_styles style
;
4333 style
= cplus_demangle_name_to_style (optarg
);
4334 if (style
== unknown_demangling
)
4335 fatal (_("unknown demangling style `%s'"),
4338 cplus_demangle_set_style (style
);
4341 case OPTION_RECURSE_LIMIT
:
4342 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4344 case OPTION_NO_RECURSE_LIMIT
:
4345 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4348 do_wide
= wide_output
= TRUE
;
4350 case OPTION_ADJUST_VMA
:
4351 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4353 case OPTION_START_ADDRESS
:
4354 start_address
= parse_vma (optarg
, "--start-address");
4355 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4356 fatal (_("error: the start address should be before the end address"));
4358 case OPTION_STOP_ADDRESS
:
4359 stop_address
= parse_vma (optarg
, "--stop-address");
4360 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4361 fatal (_("error: the stop address should be after the start address"));
4365 prefix_length
= strlen (prefix
);
4366 /* Remove an unnecessary trailing '/' */
4367 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4370 case OPTION_PREFIX_STRIP
:
4371 prefix_strip
= atoi (optarg
);
4372 if (prefix_strip
< 0)
4373 fatal (_("error: prefix strip must be non-negative"));
4375 case OPTION_INSN_WIDTH
:
4376 insn_width
= strtoul (optarg
, NULL
, 0);
4377 if (insn_width
<= 0)
4378 fatal (_("error: instruction width must be positive"));
4380 case OPTION_INLINES
:
4381 unwind_inlines
= TRUE
;
4384 if (strcmp (optarg
, "B") == 0)
4385 endian
= BFD_ENDIAN_BIG
;
4386 else if (strcmp (optarg
, "L") == 0)
4387 endian
= BFD_ENDIAN_LITTLE
;
4390 nonfatal (_("unrecognized -E option"));
4395 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4396 endian
= BFD_ENDIAN_BIG
;
4397 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4398 endian
= BFD_ENDIAN_LITTLE
;
4401 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4408 dump_file_header
= TRUE
;
4412 formats_info
= TRUE
;
4416 add_include_path (optarg
);
4419 dump_private_headers
= TRUE
;
4423 dump_private_options
= optarg
;
4427 dump_private_headers
= TRUE
;
4429 dump_reloc_info
= TRUE
;
4430 dump_file_header
= TRUE
;
4431 dump_ar_hdrs
= TRUE
;
4432 dump_section_headers
= TRUE
;
4440 dump_dynamic_symtab
= TRUE
;
4446 disasm_sym
= optarg
;
4449 disassemble_zeroes
= TRUE
;
4453 disassemble_all
= TRUE
;
4458 with_source_code
= TRUE
;
4467 dump_debugging_tags
= 1;
4472 dump_dwarf_section_info
= TRUE
;
4475 dwarf_select_sections_by_letters (optarg
);
4477 dwarf_select_sections_all ();
4480 dump_dwarf_section_info
= TRUE
;
4483 dwarf_select_sections_by_names (optarg
);
4485 dwarf_select_sections_all ();
4487 case OPTION_DWARF_DEPTH
:
4490 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4493 case OPTION_DWARF_START
:
4496 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4497 suppress_bfd_header
= 1;
4500 case OPTION_DWARF_CHECK
:
4505 dump_ctf_section_info
= TRUE
;
4506 dump_ctf_section_name
= xstrdup (optarg
);
4509 case OPTION_CTF_PARENT
:
4510 dump_ctf_parent_name
= xstrdup (optarg
);
4514 dump_stab_section_info
= TRUE
;
4518 dump_section_contents
= TRUE
;
4522 dump_reloc_info
= TRUE
;
4526 dump_dynamic_reloc_info
= TRUE
;
4530 dump_ar_hdrs
= TRUE
;
4534 dump_section_headers
= TRUE
;
4539 show_version
= TRUE
;
4545 /* No need to set seenflag or to break - usage() does not return. */
4552 print_version ("objdump");
4558 exit_status
= display_info ();
4562 display_file ("a.out", target
, TRUE
);
4564 for (; optind
< argc
;)
4566 display_file (argv
[optind
], target
, optind
== argc
- 1);
4573 free (dump_ctf_section_name
);
4574 free (dump_ctf_parent_name
);
4576 END_PROGRESS (program_name
);