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. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status
= 0;
80 static char *default_target
= NULL
; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version
= 0; /* Show the version number. */
85 static int dump_section_contents
; /* -s */
86 static int dump_section_headers
; /* -h */
87 static bfd_boolean dump_file_header
; /* -f */
88 static int dump_symtab
; /* -t */
89 static int dump_dynamic_symtab
; /* -T */
90 static int dump_reloc_info
; /* -r */
91 static int dump_dynamic_reloc_info
; /* -R */
92 static int dump_ar_hdrs
; /* -a */
93 static int dump_private_headers
; /* -p */
94 static char *dump_private_options
; /* -P */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int suppress_bfd_header
;
113 static int dump_special_syms
= 0; /* --special-syms */
114 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
115 static int file_start_context
= 0; /* --file-start-context */
116 static bfd_boolean display_file_offsets
;/* -F */
117 static const char *prefix
; /* --prefix */
118 static int prefix_strip
; /* --prefix-strip */
119 static size_t prefix_length
;
120 static bfd_boolean unwind_inlines
; /* --inlines. */
121 static const char * disasm_sym
; /* Disassembly start symbol. */
123 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
125 /* A structure to record the sections mentioned in -j switches. */
128 const char * name
; /* The name of the section. */
129 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
130 struct only
* next
; /* Pointer to the next structure in the list. */
132 /* Pointer to an array of 'only' structures.
133 This pointer is NULL if the -j switch has not been used. */
134 static struct only
* only_list
= NULL
;
136 /* Variables for handling include file path table. */
137 static const char **include_paths
;
138 static int include_path_count
;
140 /* Extra info to pass to the section disassembler and address printing
142 struct objdump_disasm_info
146 bfd_boolean require_sec
;
147 arelent
** dynrelbuf
;
149 disassembler_ftype disassemble_fn
;
154 /* Architecture to disassemble for, or default if NULL. */
155 static char *machine
= NULL
;
157 /* Target specific options to the disassembler. */
158 static char *disassembler_options
= NULL
;
160 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
161 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
163 /* The symbol table. */
164 static asymbol
**syms
;
166 /* Number of symbols in `syms'. */
167 static long symcount
= 0;
169 /* The sorted symbol table. */
170 static asymbol
**sorted_syms
;
172 /* Number of symbols in `sorted_syms'. */
173 static long sorted_symcount
= 0;
175 /* The dynamic symbol table. */
176 static asymbol
**dynsyms
;
178 /* The synthetic symbol table. */
179 static asymbol
*synthsyms
;
180 static long synthcount
= 0;
182 /* Number of symbols in `dynsyms'. */
183 static long dynsymcount
= 0;
185 static bfd_byte
*stabs
;
186 static bfd_size_type stab_size
;
188 static bfd_byte
*strtab
;
189 static bfd_size_type stabstr_size
;
191 static bfd_boolean is_relocatable
= FALSE
;
193 /* Handlers for -P/--private. */
194 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
196 OBJDUMP_PRIVATE_VECTORS
200 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
202 usage (FILE *stream
, int status
)
204 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
205 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
206 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
207 fprintf (stream
, _("\
208 -a, --archive-headers Display archive header information\n\
209 -f, --file-headers Display the contents of the overall file header\n\
210 -p, --private-headers Display object format specific file header contents\n\
211 -P, --private=OPT,OPT... Display object format specific contents\n\
212 -h, --[section-]headers Display the contents of the section headers\n\
213 -x, --all-headers Display the contents of all headers\n\
214 -d, --disassemble Display assembler contents of executable sections\n\
215 -D, --disassemble-all Display assembler contents of all sections\n\
216 --disassemble=<sym> Display assembler contents from <sym>\n\
217 -S, --source Intermix source code with disassembly\n\
218 -s, --full-contents Display the full contents of all sections requested\n\
219 -g, --debugging Display debug information in object file\n\
220 -e, --debugging-tags Display debug information using ctags style\n\
221 -G, --stabs Display (in raw form) any STABS info in the file\n\
222 -W[lLiaprmfFsoRtUuTgAckK] or\n\
223 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
224 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
225 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
226 =addr,=cu_index,=links,=follow-links]\n\
227 Display DWARF info in the file\n\
228 -t, --syms Display the contents of the symbol table(s)\n\
229 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
230 -r, --reloc Display the relocation entries in the file\n\
231 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
232 @<file> Read options from <file>\n\
233 -v, --version Display this program's version number\n\
234 -i, --info List object formats and architectures supported\n\
235 -H, --help Display this information\n\
239 const struct objdump_private_desc
* const *desc
;
241 fprintf (stream
, _("\n The following switches are optional:\n"));
242 fprintf (stream
, _("\
243 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
244 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
245 -j, --section=NAME Only display information for section NAME\n\
246 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
247 -EB --endian=big Assume big endian format when disassembling\n\
248 -EL --endian=little Assume little endian format when disassembling\n\
249 --file-start-context Include context from start of file (with -S)\n\
250 -I, --include=DIR Add DIR to search list for source files\n\
251 -l, --line-numbers Include line numbers and filenames in output\n\
252 -F, --file-offsets Include file offsets when displaying information\n\
253 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
254 The STYLE, if specified, can be `auto', `gnu',\n\
255 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
257 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
258 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
259 -w, --wide Format output for more than 80 columns\n\
260 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
261 --start-address=ADDR Only process data whose address is >= ADDR\n\
262 --stop-address=ADDR Only process data whose address is <= ADDR\n\
263 --prefix-addresses Print complete address alongside disassembly\n\
264 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
265 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
266 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
267 --special-syms Include special symbols in symbol dumps\n\
268 --inlines Print all inlines for source line (with -l)\n\
269 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
270 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
271 fprintf (stream
, _("\
272 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
273 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
275 --dwarf-check Make additional dwarf internal consistency checks.\
277 list_supported_targets (program_name
, stream
);
278 list_supported_architectures (program_name
, stream
);
280 disassembler_usage (stream
);
282 if (objdump_private_vectors
[0] != NULL
)
285 _("\nOptions supported for -P/--private switch:\n"));
286 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
287 (*desc
)->help (stream
);
290 if (REPORT_BUGS_TO
[0] && status
== 0)
291 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
295 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
299 OPTION_START_ADDRESS
,
309 OPTION_RECURSE_LIMIT
,
310 OPTION_NO_RECURSE_LIMIT
,
314 static struct option long_options
[]=
316 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
317 {"all-headers", no_argument
, NULL
, 'x'},
318 {"private-headers", no_argument
, NULL
, 'p'},
319 {"private", required_argument
, NULL
, 'P'},
320 {"architecture", required_argument
, NULL
, 'm'},
321 {"archive-headers", no_argument
, NULL
, 'a'},
322 {"debugging", no_argument
, NULL
, 'g'},
323 {"debugging-tags", no_argument
, NULL
, 'e'},
324 {"demangle", optional_argument
, NULL
, 'C'},
325 {"disassemble", optional_argument
, NULL
, 'd'},
326 {"disassemble-all", no_argument
, NULL
, 'D'},
327 {"disassembler-options", required_argument
, NULL
, 'M'},
328 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
329 {"dynamic-reloc", no_argument
, NULL
, 'R'},
330 {"dynamic-syms", no_argument
, NULL
, 'T'},
331 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
332 {"file-headers", no_argument
, NULL
, 'f'},
333 {"file-offsets", no_argument
, NULL
, 'F'},
334 {"file-start-context", no_argument
, &file_start_context
, 1},
335 {"full-contents", no_argument
, NULL
, 's'},
336 {"headers", no_argument
, NULL
, 'h'},
337 {"help", no_argument
, NULL
, 'H'},
338 {"info", no_argument
, NULL
, 'i'},
339 {"line-numbers", no_argument
, NULL
, 'l'},
340 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
341 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
342 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
343 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
344 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
345 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
346 {"reloc", no_argument
, NULL
, 'r'},
347 {"section", required_argument
, NULL
, 'j'},
348 {"section-headers", no_argument
, NULL
, 'h'},
349 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
350 {"source", no_argument
, NULL
, 'S'},
351 {"special-syms", no_argument
, &dump_special_syms
, 1},
352 {"include", required_argument
, NULL
, 'I'},
353 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
354 {"stabs", no_argument
, NULL
, 'G'},
355 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
356 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
357 {"syms", no_argument
, NULL
, 't'},
358 {"target", required_argument
, NULL
, 'b'},
359 {"version", no_argument
, NULL
, 'V'},
360 {"wide", no_argument
, NULL
, 'w'},
361 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
362 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
363 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
364 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
365 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
366 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
367 {"inlines", no_argument
, 0, OPTION_INLINES
},
368 {0, no_argument
, 0, 0}
372 nonfatal (const char *msg
)
378 /* Returns a version of IN with any control characters
379 replaced by escape sequences. Uses a static buffer
383 sanitize_string (const char * in
)
385 static char * buffer
= NULL
;
386 static unsigned int buffer_len
= 0;
387 const char * original
= in
;
394 /* See if any conversion is necessary. In the majority
395 of cases it will not be needed. */
408 /* Copy the input, translating as needed. */
410 if (buffer_len
< (strlen (in
) * 2))
412 free ((void *) buffer
);
413 buffer_len
= strlen (in
) * 2;
414 buffer
= xmalloc (buffer_len
+ 1);
440 /* Returns TRUE if the specified section should be dumped. */
443 process_section_p (asection
* section
)
447 if (only_list
== NULL
)
450 for (only
= only_list
; only
; only
= only
->next
)
451 if (strcmp (only
->name
, section
->name
) == 0)
460 /* Add an entry to the 'only' list. */
463 add_only (char * name
)
467 /* First check to make sure that we do not
468 already have an entry for this name. */
469 for (only
= only_list
; only
; only
= only
->next
)
470 if (strcmp (only
->name
, name
) == 0)
473 only
= xmalloc (sizeof * only
);
476 only
->next
= only_list
;
480 /* Release the memory used by the 'only' list.
481 PR 11225: Issue a warning message for unseen sections.
482 Only do this if none of the sections were seen. This is mainly to support
483 tools like the GAS testsuite where an object file is dumped with a list of
484 generic section names known to be present in a range of different file
488 free_only_list (void)
490 bfd_boolean at_least_one_seen
= FALSE
;
494 if (only_list
== NULL
)
497 for (only
= only_list
; only
; only
= only
->next
)
500 at_least_one_seen
= TRUE
;
504 for (only
= only_list
; only
; only
= next
)
506 if (! at_least_one_seen
)
508 non_fatal (_("section '%s' mentioned in a -j option, "
509 "but not found in any input file"),
520 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
523 unsigned int opb
= bfd_octets_per_byte (abfd
);
524 int longest_section_name
= *((int *) data
);
526 /* Ignore linker created section. See elfNN_ia64_object_p in
528 if (section
->flags
& SEC_LINKER_CREATED
)
531 /* PR 10413: Skip sections that we are ignoring. */
532 if (! process_section_p (section
))
535 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
536 sanitize_string (bfd_get_section_name (abfd
, section
)),
537 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
538 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
540 bfd_printf_vma (abfd
, section
->lma
);
541 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
542 bfd_get_section_alignment (abfd
, section
));
548 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
550 PF (SEC_HAS_CONTENTS
, "CONTENTS");
551 PF (SEC_ALLOC
, "ALLOC");
552 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
553 PF (SEC_LOAD
, "LOAD");
554 PF (SEC_RELOC
, "RELOC");
555 PF (SEC_READONLY
, "READONLY");
556 PF (SEC_CODE
, "CODE");
557 PF (SEC_DATA
, "DATA");
559 PF (SEC_DEBUGGING
, "DEBUGGING");
560 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
561 PF (SEC_EXCLUDE
, "EXCLUDE");
562 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
563 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
565 PF (SEC_TIC54X_BLOCK
, "BLOCK");
566 PF (SEC_TIC54X_CLINK
, "CLINK");
568 PF (SEC_SMALL_DATA
, "SMALL_DATA");
569 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
571 PF (SEC_COFF_SHARED
, "SHARED");
572 PF (SEC_COFF_NOREAD
, "NOREAD");
574 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
575 PF (SEC_ELF_PURECODE
, "PURECODE");
576 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
577 PF (SEC_GROUP
, "GROUP");
578 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
580 PF (SEC_MEP_VLIW
, "VLIW");
583 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
586 struct coff_comdat_info
*comdat
;
588 switch (section
->flags
& SEC_LINK_DUPLICATES
)
592 case SEC_LINK_DUPLICATES_DISCARD
:
593 ls
= "LINK_ONCE_DISCARD";
595 case SEC_LINK_DUPLICATES_ONE_ONLY
:
596 ls
= "LINK_ONCE_ONE_ONLY";
598 case SEC_LINK_DUPLICATES_SAME_SIZE
:
599 ls
= "LINK_ONCE_SAME_SIZE";
601 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
602 ls
= "LINK_ONCE_SAME_CONTENTS";
605 printf ("%s%s", comma
, ls
);
607 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
609 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
618 /* Called on each SECTION in ABFD, update the int variable pointed to by
619 DATA which contains the string length of the longest section name. */
622 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
624 int *longest_so_far
= (int *) data
;
628 /* Ignore linker created section. */
629 if (section
->flags
& SEC_LINKER_CREATED
)
632 /* Skip sections that we are ignoring. */
633 if (! process_section_p (section
))
636 name
= bfd_get_section_name (abfd
, section
);
637 len
= (int) strlen (name
);
638 if (len
> *longest_so_far
)
639 *longest_so_far
= len
;
643 dump_headers (bfd
*abfd
)
645 /* The default width of 13 is just an arbitrary choice. */
646 int max_section_name_length
= 13;
652 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
653 if (bfd_get_arch_size (abfd
) == 32)
659 printf (_("Sections:\n"));
662 bfd_map_over_sections (abfd
, find_longest_section_name
,
663 &max_section_name_length
);
665 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
666 max_section_name_length
, "Name",
667 bfd_vma_width
, "VMA",
668 bfd_vma_width
, "LMA");
671 printf (_(" Flags"));
674 bfd_map_over_sections (abfd
, dump_section_header
,
675 &max_section_name_length
);
679 slurp_symtab (bfd
*abfd
)
684 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
690 storage
= bfd_get_symtab_upper_bound (abfd
);
693 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
694 bfd_fatal (_("error message was"));
697 sy
= (asymbol
**) xmalloc (storage
);
699 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
701 bfd_fatal (bfd_get_filename (abfd
));
705 /* Read in the dynamic symbols. */
708 slurp_dynamic_symtab (bfd
*abfd
)
713 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
716 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
718 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
724 bfd_fatal (bfd_get_filename (abfd
));
727 sy
= (asymbol
**) xmalloc (storage
);
729 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
731 bfd_fatal (bfd_get_filename (abfd
));
735 /* Some symbol names are significant and should be kept in the
736 table of sorted symbol names, even if they are marked as
737 debugging/section symbols. */
740 is_significant_symbol_name (const char * name
)
742 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
745 /* Filter out (in place) symbols that are useless for disassembly.
746 COUNT is the number of elements in SYMBOLS.
747 Return the number of useful symbols. */
750 remove_useless_symbols (asymbol
**symbols
, long count
)
752 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
756 asymbol
*sym
= *in_ptr
++;
758 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
760 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
761 && ! is_significant_symbol_name (sym
->name
))
763 if (bfd_is_und_section (sym
->section
)
764 || bfd_is_com_section (sym
->section
))
769 return out_ptr
- symbols
;
772 /* Sort symbols into value order. */
775 compare_symbols (const void *ap
, const void *bp
)
777 const asymbol
*a
= * (const asymbol
**) ap
;
778 const asymbol
*b
= * (const asymbol
**) bp
;
788 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
790 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
793 if (a
->section
> b
->section
)
795 else if (a
->section
< b
->section
)
798 an
= bfd_asymbol_name (a
);
799 bn
= bfd_asymbol_name (b
);
803 /* The symbols gnu_compiled and gcc2_compiled convey no real
804 information, so put them after other symbols with the same value. */
805 af
= (strstr (an
, "gnu_compiled") != NULL
806 || strstr (an
, "gcc2_compiled") != NULL
);
807 bf
= (strstr (bn
, "gnu_compiled") != NULL
808 || strstr (bn
, "gcc2_compiled") != NULL
);
815 /* We use a heuristic for the file name, to try to sort it after
816 more useful symbols. It may not work on non Unix systems, but it
817 doesn't really matter; the only difference is precisely which
818 symbol names get printed. */
820 #define file_symbol(s, sn, snl) \
821 (((s)->flags & BSF_FILE) != 0 \
822 || ((sn)[(snl) - 2] == '.' \
823 && ((sn)[(snl) - 1] == 'o' \
824 || (sn)[(snl) - 1] == 'a')))
826 af
= file_symbol (a
, an
, anl
);
827 bf
= file_symbol (b
, bn
, bnl
);
834 /* Try to sort global symbols before local symbols before function
835 symbols before debugging symbols. */
840 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
842 if ((aflags
& BSF_DEBUGGING
) != 0)
847 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
849 if ((aflags
& BSF_FUNCTION
) != 0)
854 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
856 if ((aflags
& BSF_LOCAL
) != 0)
861 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
863 if ((aflags
& BSF_GLOBAL
) != 0)
869 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
870 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
875 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
876 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
878 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
879 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
881 return asz
> bsz
? -1 : 1;
884 /* Symbols that start with '.' might be section names, so sort them
885 after symbols that don't start with '.'. */
886 if (an
[0] == '.' && bn
[0] != '.')
888 if (an
[0] != '.' && bn
[0] == '.')
891 /* Finally, if we can't distinguish them in any other way, try to
892 get consistent results by sorting the symbols by name. */
893 return strcmp (an
, bn
);
896 /* Sort relocs into address order. */
899 compare_relocs (const void *ap
, const void *bp
)
901 const arelent
*a
= * (const arelent
**) ap
;
902 const arelent
*b
= * (const arelent
**) bp
;
904 if (a
->address
> b
->address
)
906 else if (a
->address
< b
->address
)
909 /* So that associated relocations tied to the same address show up
910 in the correct order, we don't do any further sorting. */
919 /* Print an address (VMA) to the output stream in INFO.
920 If SKIP_ZEROES is TRUE, omit leading zeroes. */
923 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
924 bfd_boolean skip_zeroes
)
928 struct objdump_disasm_info
*aux
;
930 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
931 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
936 for (p
= buf
; *p
== '0'; ++p
)
941 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
944 /* Print the name of a symbol. */
947 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
951 const char *name
, *version_string
= NULL
;
952 bfd_boolean hidden
= FALSE
;
955 name
= bfd_asymbol_name (sym
);
956 if (do_demangle
&& name
[0] != '\0')
958 /* Demangle the name. */
959 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
964 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
965 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
967 if (bfd_is_und_section (bfd_get_section (sym
)))
970 name
= sanitize_string (name
);
974 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
975 if (version_string
&& *version_string
!= '\0')
976 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
982 if (version_string
&& *version_string
!= '\0')
983 printf (hidden
? "@%s" : "@@%s", version_string
);
990 /* Locate a symbol given a bfd and a section (from INFO->application_data),
991 and a VMA. If INFO->application_data->require_sec is TRUE, then always
992 require the symbol to be in the section. Returns NULL if there is no
993 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
994 of the symbol in sorted_syms. */
997 find_symbol_for_address (bfd_vma vma
,
998 struct disassemble_info
*inf
,
1001 /* @@ Would it speed things up to cache the last two symbols returned,
1002 and maybe their address ranges? For many processors, only one memory
1003 operand can be present at a time, so the 2-entry cache wouldn't be
1004 constantly churned by code doing heavy memory accesses. */
1006 /* Indices in `sorted_syms'. */
1008 long max_count
= sorted_symcount
;
1010 struct objdump_disasm_info
*aux
;
1014 bfd_boolean want_section
;
1017 if (sorted_symcount
< 1)
1020 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1023 opb
= inf
->octets_per_byte
;
1025 /* Perform a binary search looking for the closest symbol to the
1026 required value. We are searching the range (min, max_count]. */
1027 while (min
+ 1 < max_count
)
1031 thisplace
= (max_count
+ min
) / 2;
1032 sym
= sorted_syms
[thisplace
];
1034 if (bfd_asymbol_value (sym
) > vma
)
1035 max_count
= thisplace
;
1036 else if (bfd_asymbol_value (sym
) < vma
)
1045 /* The symbol we want is now in min, the low end of the range we
1046 were searching. If there are several symbols with the same
1047 value, we want the first (non-section/non-debugging) one. */
1049 while (thisplace
> 0
1050 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1051 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1052 && ((sorted_syms
[thisplace
- 1]->flags
1053 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1057 /* Prefer a symbol in the current section if we have multple symbols
1058 with the same value, as can occur with overlays or zero size
1061 while (min
< max_count
1062 && (bfd_asymbol_value (sorted_syms
[min
])
1063 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1065 if (sorted_syms
[min
]->section
== sec
1066 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
1073 return sorted_syms
[thisplace
];
1078 /* If the file is relocatable, and the symbol could be from this
1079 section, prefer a symbol from this section over symbols from
1080 others, even if the other symbol's value might be closer.
1082 Note that this may be wrong for some symbol references if the
1083 sections have overlapping memory ranges, but in that case there's
1084 no way to tell what's desired without looking at the relocation
1087 Also give the target a chance to reject symbols. */
1088 want_section
= (aux
->require_sec
1089 || ((abfd
->flags
& HAS_RELOC
) != 0
1090 && vma
>= bfd_get_section_vma (abfd
, sec
)
1091 && vma
< (bfd_get_section_vma (abfd
, sec
)
1092 + bfd_section_size (abfd
, sec
) / opb
)));
1093 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1094 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1097 long newplace
= sorted_symcount
;
1099 for (i
= min
- 1; i
>= 0; i
--)
1101 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1102 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1104 if (newplace
== sorted_symcount
)
1107 if (bfd_asymbol_value (sorted_syms
[i
])
1108 != bfd_asymbol_value (sorted_syms
[newplace
]))
1111 /* Remember this symbol and keep searching until we reach
1112 an earlier address. */
1117 if (newplace
!= sorted_symcount
)
1118 thisplace
= newplace
;
1121 /* We didn't find a good symbol with a smaller value.
1122 Look for one with a larger value. */
1123 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1125 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1126 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1134 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1135 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1136 /* There is no suitable symbol. */
1140 /* If we have not found an exact match for the specified address
1141 and we have dynamic relocations available, then we can produce
1142 a better result by matching a relocation to the address and
1143 using the symbol associated with that relocation. */
1144 rel_count
= aux
->dynrelcount
;
1146 && sorted_syms
[thisplace
]->value
!= vma
1148 && aux
->dynrelbuf
!= NULL
1149 && aux
->dynrelbuf
[0]->address
<= vma
1150 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1151 /* If we have matched a synthetic symbol, then stick with that. */
1152 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1155 arelent
** rel_high
;
1157 rel_low
= aux
->dynrelbuf
;
1158 rel_high
= rel_low
+ rel_count
- 1;
1159 while (rel_low
<= rel_high
)
1161 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1162 arelent
* rel
= *rel_mid
;
1164 if (rel
->address
== vma
)
1166 /* Absolute relocations do not provide a more helpful
1167 symbolic address. Find a non-absolute relocation
1168 with the same address. */
1169 arelent
**rel_vma
= rel_mid
;
1171 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1175 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1179 if (rel
->sym_ptr_ptr
!= NULL
1180 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1183 * place
= thisplace
;
1184 return * rel
->sym_ptr_ptr
;
1190 if (vma
< rel
->address
)
1192 else if (vma
>= rel_mid
[1]->address
)
1193 rel_low
= rel_mid
+ 1;
1202 return sorted_syms
[thisplace
];
1205 /* Print an address and the offset to the nearest symbol. */
1208 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1209 bfd_vma vma
, struct disassemble_info
*inf
,
1210 bfd_boolean skip_zeroes
)
1212 objdump_print_value (vma
, inf
, skip_zeroes
);
1218 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1219 sanitize_string (bfd_get_section_name (abfd
, sec
)));
1220 secaddr
= bfd_get_section_vma (abfd
, sec
);
1223 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1224 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1226 else if (vma
> secaddr
)
1228 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1229 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1231 (*inf
->fprintf_func
) (inf
->stream
, ">");
1235 (*inf
->fprintf_func
) (inf
->stream
, " <");
1237 objdump_print_symname (abfd
, inf
, sym
);
1239 if (bfd_asymbol_value (sym
) == vma
)
1241 /* Undefined symbols in an executables and dynamic objects do not have
1242 a value associated with them, so it does not make sense to display
1243 an offset relative to them. Normally we would not be provided with
1244 this kind of symbol, but the target backend might choose to do so,
1245 and the code in find_symbol_for_address might return an as yet
1246 unresolved symbol associated with a dynamic reloc. */
1247 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1248 && bfd_is_und_section (sym
->section
))
1250 else if (bfd_asymbol_value (sym
) > vma
)
1252 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1253 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1255 else if (vma
> bfd_asymbol_value (sym
))
1257 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1258 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1261 (*inf
->fprintf_func
) (inf
->stream
, ">");
1264 if (display_file_offsets
)
1265 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1266 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1269 /* Print an address (VMA), symbolically if possible.
1270 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1273 objdump_print_addr (bfd_vma vma
,
1274 struct disassemble_info
*inf
,
1275 bfd_boolean skip_zeroes
)
1277 struct objdump_disasm_info
*aux
;
1278 asymbol
*sym
= NULL
;
1279 bfd_boolean skip_find
= FALSE
;
1281 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1283 if (sorted_symcount
< 1)
1285 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1286 objdump_print_value (vma
, inf
, skip_zeroes
);
1288 if (display_file_offsets
)
1289 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1290 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1294 if (aux
->reloc
!= NULL
1295 && aux
->reloc
->sym_ptr_ptr
!= NULL
1296 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1298 sym
= * aux
->reloc
->sym_ptr_ptr
;
1300 /* Adjust the vma to the reloc. */
1301 vma
+= bfd_asymbol_value (sym
);
1303 if (bfd_is_und_section (bfd_get_section (sym
)))
1308 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1310 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1314 /* Print VMA to INFO. This function is passed to the disassembler
1318 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1320 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1323 /* Determine if the given address has a symbol associated with it. */
1326 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1330 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1332 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1335 /* Hold the last function name and the last line number we displayed
1336 in a disassembly. */
1338 static char *prev_functionname
;
1339 static unsigned int prev_line
;
1340 static unsigned int prev_discriminator
;
1342 /* We keep a list of all files that we have seen when doing a
1343 disassembly with source, so that we know how much of the file to
1344 display. This can be important for inlined functions. */
1346 struct print_file_list
1348 struct print_file_list
*next
;
1349 const char *filename
;
1350 const char *modname
;
1353 const char **linemap
;
1356 unsigned max_printed
;
1360 static struct print_file_list
*print_files
;
1362 /* The number of preceding context lines to show when we start
1363 displaying a file for the first time. */
1365 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1367 /* Read a complete file into memory. */
1370 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1373 int ps
= getpagesize ();
1377 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1381 if (fstat (fd
, fst
) < 0)
1386 *size
= fst
->st_size
;
1388 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1389 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1390 if (map
!= (char *) -1L)
1396 map
= (const char *) malloc (*size
);
1397 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1399 free ((void *) map
);
1406 #define line_map_decrease 5
1408 /* Precompute array of lines for a mapped file. */
1410 static const char **
1411 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1413 const char *p
, *lstart
, *end
;
1414 int chars_per_line
= 45; /* First iteration will use 40. */
1415 unsigned int lineno
;
1416 const char **linemap
= NULL
;
1417 unsigned long line_map_size
= 0;
1423 for (p
= map
; p
< end
; p
++)
1427 if (p
+ 1 < end
&& p
[1] == '\r')
1430 else if (*p
== '\r')
1432 if (p
+ 1 < end
&& p
[1] == '\n')
1438 /* End of line found. */
1440 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1442 unsigned long newsize
;
1444 chars_per_line
-= line_map_decrease
;
1445 if (chars_per_line
<= 1)
1447 line_map_size
= size
/ chars_per_line
+ 1;
1448 if (line_map_size
< lineno
+ 1)
1449 line_map_size
= lineno
+ 1;
1450 newsize
= line_map_size
* sizeof (char *);
1451 linemap
= (const char **) xrealloc (linemap
, newsize
);
1454 linemap
[lineno
++] = lstart
;
1462 /* Tries to open MODNAME, and if successful adds a node to print_files
1463 linked list and returns that node. Returns NULL on failure. */
1465 static struct print_file_list
*
1466 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1468 struct print_file_list
*p
;
1470 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1472 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1479 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1482 p
->filename
= origname
;
1483 p
->modname
= modname
;
1484 p
->next
= print_files
;
1490 /* If the source file, as described in the symtab, is not found
1491 try to locate it in one of the paths specified with -I
1492 If found, add location to print_files linked list. */
1494 static struct print_file_list
*
1495 update_source_path (const char *filename
, bfd
*abfd
)
1497 struct print_file_list
*p
;
1502 p
= try_print_file_open (filename
, filename
, &fst
);
1505 if (include_path_count
== 0)
1508 /* Get the name of the file. */
1509 fname
= lbasename (filename
);
1511 /* If file exists under a new path, we need to add it to the list
1512 so that show_line knows about it. */
1513 for (i
= 0; i
< include_path_count
; i
++)
1515 char *modname
= concat (include_paths
[i
], "/", fname
,
1518 p
= try_print_file_open (filename
, modname
, &fst
);
1528 long mtime
= bfd_get_mtime (abfd
);
1530 if (fst
.st_mtime
> mtime
)
1531 warn (_("source file %s is more recent than object file\n"),
1538 /* Print a source file line. */
1541 print_line (struct print_file_list
*p
, unsigned int linenum
)
1547 if (linenum
>= p
->maxline
)
1549 l
= p
->linemap
[linenum
];
1550 /* Test fwrite return value to quiet glibc warning. */
1551 len
= strcspn (l
, "\n\r");
1552 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1556 /* Print a range of source code lines. */
1559 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1563 while (start
<= end
)
1565 print_line (p
, start
);
1570 /* Show the line number, or the source line, in a disassembly
1574 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1576 const char *filename
;
1577 const char *functionname
;
1578 unsigned int linenumber
;
1579 unsigned int discriminator
;
1583 if (! with_line_numbers
&& ! with_source_code
)
1586 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1587 &filename
, &functionname
,
1588 &linenumber
, &discriminator
))
1591 if (filename
!= NULL
&& *filename
== '\0')
1593 if (functionname
!= NULL
&& *functionname
== '\0')
1594 functionname
= NULL
;
1597 && IS_ABSOLUTE_PATH (filename
)
1601 const char *fname
= filename
;
1603 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1606 memcpy (path
, prefix
, prefix_length
);
1607 path_up
= path
+ prefix_length
;
1609 /* Build relocated filename, stripping off leading directories
1610 from the initial filename if requested. */
1611 if (prefix_strip
> 0)
1616 /* Skip selected directory levels. */
1617 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1618 if (IS_DIR_SEPARATOR(*s
))
1625 /* Update complete filename. */
1626 strncpy (path_up
, fname
, PATH_MAX
);
1627 path_up
[PATH_MAX
] = '\0';
1635 if (with_line_numbers
)
1637 if (functionname
!= NULL
1638 && (prev_functionname
== NULL
1639 || strcmp (functionname
, prev_functionname
) != 0))
1641 printf ("%s():\n", sanitize_string (functionname
));
1645 && (linenumber
!= prev_line
1646 || discriminator
!= prev_discriminator
))
1648 if (discriminator
> 0)
1649 printf ("%s:%u (discriminator %u)\n",
1650 filename
== NULL
? "???" : sanitize_string (filename
),
1651 linenumber
, discriminator
);
1653 printf ("%s:%u\n", filename
== NULL
1654 ? "???" : sanitize_string (filename
),
1659 const char *filename2
;
1660 const char *functionname2
;
1663 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1666 printf ("inlined by %s:%u",
1667 sanitize_string (filename2
), line2
);
1668 printf (" (%s)\n", sanitize_string (functionname2
));
1673 if (with_source_code
1677 struct print_file_list
**pp
, *p
;
1680 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1681 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1688 filename
= xstrdup (filename
);
1689 p
= update_source_path (filename
, abfd
);
1692 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1694 if (file_start_context
&& p
->first
)
1698 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1699 if (l
>= linenumber
)
1701 if (p
->max_printed
>= l
)
1703 if (p
->max_printed
< linenumber
)
1704 l
= p
->max_printed
+ 1;
1709 dump_lines (p
, l
, linenumber
);
1710 if (p
->max_printed
< linenumber
)
1711 p
->max_printed
= linenumber
;
1712 p
->last_line
= linenumber
;
1717 if (functionname
!= NULL
1718 && (prev_functionname
== NULL
1719 || strcmp (functionname
, prev_functionname
) != 0))
1721 if (prev_functionname
!= NULL
)
1722 free (prev_functionname
);
1723 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1724 strcpy (prev_functionname
, functionname
);
1727 if (linenumber
> 0 && linenumber
!= prev_line
)
1728 prev_line
= linenumber
;
1730 if (discriminator
!= prev_discriminator
)
1731 prev_discriminator
= discriminator
;
1737 /* Pseudo FILE object for strings. */
1745 /* sprintf to a "stream". */
1747 static int ATTRIBUTE_PRINTF_2
1748 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1755 size_t space
= f
->alloc
- f
->pos
;
1757 va_start (args
, format
);
1758 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1764 f
->alloc
= (f
->alloc
+ n
) * 2;
1765 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1772 /* The number of zeroes we want to see before we start skipping them.
1773 The number is arbitrarily chosen. */
1775 #define DEFAULT_SKIP_ZEROES 8
1777 /* The number of zeroes to skip at the end of a section. If the
1778 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1779 SKIP_ZEROES, they will be disassembled. If there are fewer than
1780 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1781 attempt to avoid disassembling zeroes inserted by section
1784 #define DEFAULT_SKIP_ZEROES_AT_END 3
1786 /* Disassemble some data in memory between given values. */
1789 disassemble_bytes (struct disassemble_info
* inf
,
1790 disassembler_ftype disassemble_fn
,
1793 bfd_vma start_offset
,
1794 bfd_vma stop_offset
,
1797 arelent
** relppend
)
1799 struct objdump_disasm_info
*aux
;
1801 int octets_per_line
;
1802 int skip_addr_chars
;
1803 bfd_vma addr_offset
;
1804 unsigned int opb
= inf
->octets_per_byte
;
1805 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1806 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1810 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1814 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1818 octets_per_line
= insn_width
;
1820 octets_per_line
= 4;
1822 octets_per_line
= 16;
1824 /* Figure out how many characters to skip at the start of an
1825 address, to make the disassembly look nicer. We discard leading
1826 zeroes in chunks of 4, ensuring that there is always a leading
1828 skip_addr_chars
= 0;
1829 if (! prefix_addresses
)
1833 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1835 while (buf
[skip_addr_chars
] == '0')
1838 /* Don't discard zeros on overflow. */
1839 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1840 skip_addr_chars
= 0;
1842 if (skip_addr_chars
!= 0)
1843 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1846 inf
->insn_info_valid
= 0;
1848 addr_offset
= start_offset
;
1849 while (addr_offset
< stop_offset
)
1852 bfd_boolean need_nl
= FALSE
;
1853 int previous_octets
;
1855 /* Remember the length of the previous instruction. */
1856 previous_octets
= octets
;
1859 /* Make sure we don't use relocs from previous instructions. */
1862 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1864 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1867 if (! disassemble_zeroes
1868 && (inf
->insn_info_valid
== 0
1869 || inf
->branch_delay_insns
== 0)
1870 && (z
- addr_offset
* opb
>= skip_zeroes
1871 || (z
== stop_offset
* opb
&&
1872 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1874 /* If there are more nonzero octets to follow, we only skip
1875 zeroes in multiples of 4, to try to avoid running over
1876 the start of an instruction which happens to start with
1878 if (z
!= stop_offset
* opb
)
1879 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1881 octets
= z
- addr_offset
* opb
;
1883 /* If we are going to display more data, and we are displaying
1884 file offsets, then tell the user how many zeroes we skip
1885 and the file offset from where we resume dumping. */
1886 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1887 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1889 (unsigned long) (section
->filepos
1890 + (addr_offset
+ (octets
/ opb
))));
1900 if (with_line_numbers
|| with_source_code
)
1901 show_line (aux
->abfd
, section
, addr_offset
);
1903 if (! prefix_addresses
)
1907 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1908 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1912 printf ("%s:\t", buf
+ skip_addr_chars
);
1916 aux
->require_sec
= TRUE
;
1917 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1918 aux
->require_sec
= FALSE
;
1925 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1926 inf
->stream
= &sfile
;
1927 inf
->bytes_per_line
= 0;
1928 inf
->bytes_per_chunk
= 0;
1929 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1931 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1933 if (inf
->disassembler_needs_relocs
1934 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1935 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1936 && *relppp
< relppend
)
1938 bfd_signed_vma distance_to_rel
;
1940 distance_to_rel
= (**relppp
)->address
1941 - (rel_offset
+ addr_offset
);
1943 /* Check to see if the current reloc is associated with
1944 the instruction that we are about to disassemble. */
1945 if (distance_to_rel
== 0
1946 /* FIXME: This is wrong. We are trying to catch
1947 relocs that are addressed part way through the
1948 current instruction, as might happen with a packed
1949 VLIW instruction. Unfortunately we do not know the
1950 length of the current instruction since we have not
1951 disassembled it yet. Instead we take a guess based
1952 upon the length of the previous instruction. The
1953 proper solution is to have a new target-specific
1954 disassembler function which just returns the length
1955 of an instruction at a given address without trying
1956 to display its disassembly. */
1957 || (distance_to_rel
> 0
1958 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1960 inf
->flags
|= INSN_HAS_RELOC
;
1961 aux
->reloc
= **relppp
;
1965 if (! disassemble_all
1966 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1967 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1968 /* Set a stop_vma so that the disassembler will not read
1969 beyond the next symbol. We assume that symbols appear on
1970 the boundaries between instructions. We only do this when
1971 disassembling code of course, and when -D is in effect. */
1972 inf
->stop_vma
= section
->vma
+ stop_offset
;
1974 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1977 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1978 inf
->stream
= stdout
;
1979 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1980 octets_per_line
= inf
->bytes_per_line
;
1981 if (octets
< (int) opb
)
1984 printf ("%s\n", sfile
.buffer
);
1987 non_fatal (_("disassemble_fn returned length %d"),
1998 octets
= octets_per_line
;
1999 if (addr_offset
+ octets
/ opb
> stop_offset
)
2000 octets
= (stop_offset
- addr_offset
) * opb
;
2002 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2004 if (ISPRINT (data
[j
]))
2005 buf
[j
- addr_offset
* opb
] = data
[j
];
2007 buf
[j
- addr_offset
* opb
] = '.';
2009 buf
[j
- addr_offset
* opb
] = '\0';
2012 if (prefix_addresses
2014 : show_raw_insn
>= 0)
2018 /* If ! prefix_addresses and ! wide_output, we print
2019 octets_per_line octets per line. */
2021 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2022 pb
= octets_per_line
;
2024 if (inf
->bytes_per_chunk
)
2025 bpc
= inf
->bytes_per_chunk
;
2029 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2031 /* PR 21580: Check for a buffer ending early. */
2032 if (j
+ bpc
<= stop_offset
* opb
)
2036 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2038 for (k
= bpc
- 1; k
>= 0; k
--)
2039 printf ("%02x", (unsigned) data
[j
+ k
]);
2043 for (k
= 0; k
< bpc
; k
++)
2044 printf ("%02x", (unsigned) data
[j
+ k
]);
2050 for (; pb
< octets_per_line
; pb
+= bpc
)
2054 for (k
= 0; k
< bpc
; k
++)
2059 /* Separate raw data from instruction by extra space. */
2069 printf ("%s", sfile
.buffer
);
2071 if (prefix_addresses
2073 : show_raw_insn
>= 0)
2081 j
= addr_offset
* opb
+ pb
;
2083 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2084 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2088 printf ("%s:\t", buf
+ skip_addr_chars
);
2090 pb
+= octets_per_line
;
2093 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2095 /* PR 21619: Check for a buffer ending early. */
2096 if (j
+ bpc
<= stop_offset
* opb
)
2100 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2102 for (k
= bpc
- 1; k
>= 0; k
--)
2103 printf ("%02x", (unsigned) data
[j
+ k
]);
2107 for (k
= 0; k
< bpc
; k
++)
2108 printf ("%02x", (unsigned) data
[j
+ k
]);
2122 while ((*relppp
) < relppend
2123 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2125 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2136 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2139 if (q
->howto
== NULL
)
2140 printf (": *unknown*\t");
2141 else if (q
->howto
->name
)
2142 printf (": %s\t", q
->howto
->name
);
2144 printf (": %d\t", q
->howto
->type
);
2146 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2147 printf ("*unknown*");
2150 const char *sym_name
;
2152 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2153 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2154 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2159 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2160 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2161 if (sym_name
== NULL
|| *sym_name
== '\0')
2162 sym_name
= "*unknown*";
2163 printf ("%s", sanitize_string (sym_name
));
2169 bfd_signed_vma addend
= q
->addend
;
2177 objdump_print_value (addend
, inf
, TRUE
);
2189 addr_offset
+= octets
/ opb
;
2192 free (sfile
.buffer
);
2196 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2198 const struct elf_backend_data
* bed
;
2199 bfd_vma sign_adjust
= 0;
2200 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2201 struct objdump_disasm_info
* paux
;
2202 unsigned int opb
= pinfo
->octets_per_byte
;
2203 bfd_byte
* data
= NULL
;
2204 bfd_size_type datasize
= 0;
2205 arelent
** rel_pp
= NULL
;
2206 arelent
** rel_ppstart
= NULL
;
2207 arelent
** rel_ppend
;
2208 bfd_vma stop_offset
;
2209 asymbol
* sym
= NULL
;
2213 unsigned long addr_offset
;
2214 bfd_boolean do_print
;
2217 stop_offset_reached
,
2222 /* Sections that do not contain machine
2223 code are not normally disassembled. */
2224 if (! disassemble_all
2225 && only_list
== NULL
2226 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2227 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2230 if (! process_section_p (section
))
2233 datasize
= bfd_get_section_size (section
);
2237 if (start_address
== (bfd_vma
) -1
2238 || start_address
< section
->vma
)
2241 addr_offset
= start_address
- section
->vma
;
2243 if (stop_address
== (bfd_vma
) -1)
2244 stop_offset
= datasize
/ opb
;
2247 if (stop_address
< section
->vma
)
2250 stop_offset
= stop_address
- section
->vma
;
2251 if (stop_offset
> datasize
/ opb
)
2252 stop_offset
= datasize
/ opb
;
2255 if (addr_offset
>= stop_offset
)
2258 /* Decide which set of relocs to use. Load them if necessary. */
2259 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2260 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2262 rel_pp
= paux
->dynrelbuf
;
2263 rel_count
= paux
->dynrelcount
;
2264 /* Dynamic reloc addresses are absolute, non-dynamic are section
2265 relative. REL_OFFSET specifies the reloc address corresponding
2266 to the start of this section. */
2267 rel_offset
= section
->vma
;
2275 if ((section
->flags
& SEC_RELOC
) != 0
2276 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2280 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2282 bfd_fatal (bfd_get_filename (abfd
));
2286 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2287 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2289 bfd_fatal (bfd_get_filename (abfd
));
2291 /* Sort the relocs by address. */
2292 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2296 rel_ppend
= rel_pp
+ rel_count
;
2298 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2300 non_fatal (_("Reading section %s failed because: %s"),
2301 section
->name
, bfd_errmsg (bfd_get_error ()));
2305 paux
->sec
= section
;
2306 pinfo
->buffer
= data
;
2307 pinfo
->buffer_vma
= section
->vma
;
2308 pinfo
->buffer_length
= datasize
;
2309 pinfo
->section
= section
;
2311 /* Skip over the relocs belonging to addresses below the
2313 while (rel_pp
< rel_ppend
2314 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2317 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2319 /* Find the nearest symbol forwards from our current position. */
2320 paux
->require_sec
= TRUE
;
2321 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2322 (struct disassemble_info
*) inf
,
2324 paux
->require_sec
= FALSE
;
2326 /* PR 9774: If the target used signed addresses then we must make
2327 sure that we sign extend the value that we calculate for 'addr'
2328 in the loop below. */
2329 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2330 && (bed
= get_elf_backend_data (abfd
)) != NULL
2331 && bed
->sign_extend_vma
)
2332 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2334 /* Disassemble a block of instructions up to the address associated with
2335 the symbol we have just found. Then print the symbol and find the
2336 next symbol on. Repeat until we have disassembled the entire section
2337 or we have reached the end of the address range we are interested in. */
2338 do_print
= paux
->symbol
== NULL
;
2339 loop_until
= stop_offset_reached
;
2341 while (addr_offset
< stop_offset
)
2345 bfd_vma nextstop_offset
;
2348 addr
= section
->vma
+ addr_offset
;
2349 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2351 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2356 (x
< sorted_symcount
2357 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2361 pinfo
->symbols
= sorted_syms
+ place
;
2362 pinfo
->num_symbols
= x
- place
;
2363 pinfo
->symtab_pos
= place
;
2367 pinfo
->symbols
= NULL
;
2368 pinfo
->num_symbols
= 0;
2369 pinfo
->symtab_pos
= -1;
2372 /* If we are only disassembling from a specific symbol,
2373 check to see if we should start or stop displaying. */
2374 if (sym
&& paux
->symbol
)
2378 /* See if we should stop printing. */
2382 if (sym
->flags
& BSF_FUNCTION
)
2386 case stop_offset_reached
:
2387 /* Handled by the while loop. */
2391 /* FIXME: There is an implicit assumption here
2392 that the name of sym is different from
2394 if (! bfd_is_local_label (abfd
, sym
))
2401 const char * name
= bfd_asymbol_name (sym
);
2402 char * alloc
= NULL
;
2404 if (do_demangle
&& name
[0] != '\0')
2406 /* Demangle the name. */
2407 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2412 /* We are not currently printing. Check to see
2413 if the current symbol matches the requested symbol. */
2414 if (streq (name
, paux
->symbol
))
2418 if (sym
->flags
& BSF_FUNCTION
)
2420 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2421 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2423 /* Sym is a function symbol with a size associated
2424 with it. Turn on automatic disassembly for the
2425 next VALUE bytes. */
2426 stop_offset
= addr_offset
2427 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2428 loop_until
= stop_offset_reached
;
2432 /* Otherwise we need to tell the loop heuristic to
2433 loop until the next function symbol is encountered. */
2434 loop_until
= function_sym
;
2439 /* Otherwise loop until the next symbol is encountered. */
2440 loop_until
= next_sym
;
2448 if (! prefix_addresses
&& do_print
)
2450 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2451 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2453 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2456 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2458 else if (sym
== NULL
)
2462 #define is_valid_next_sym(SYM) \
2463 ((SYM)->section == section \
2464 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2465 && pinfo->symbol_is_valid (SYM, pinfo))
2467 /* Search forward for the next appropriate symbol in
2468 SECTION. Note that all the symbols are sorted
2469 together into one big array, and that some sections
2470 may have overlapping addresses. */
2471 while (place
< sorted_symcount
2472 && ! is_valid_next_sym (sorted_syms
[place
]))
2475 if (place
>= sorted_symcount
)
2478 nextsym
= sorted_syms
[place
];
2481 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2482 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2483 else if (nextsym
== NULL
)
2484 nextstop_offset
= stop_offset
;
2486 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2488 if (nextstop_offset
> stop_offset
2489 || nextstop_offset
<= addr_offset
)
2490 nextstop_offset
= stop_offset
;
2492 /* If a symbol is explicitly marked as being an object
2493 rather than a function, just dump the bytes without
2494 disassembling them. */
2497 || sym
->section
!= section
2498 || bfd_asymbol_value (sym
) > addr
2499 || ((sym
->flags
& BSF_OBJECT
) == 0
2500 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2502 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2504 || (sym
->flags
& BSF_FUNCTION
) != 0)
2510 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2511 addr_offset
, nextstop_offset
,
2512 rel_offset
, &rel_pp
, rel_ppend
);
2514 addr_offset
= nextstop_offset
;
2520 if (rel_ppstart
!= NULL
)
2524 /* Disassemble the contents of an object file. */
2527 disassemble_data (bfd
*abfd
)
2529 struct disassemble_info disasm_info
;
2530 struct objdump_disasm_info aux
;
2534 prev_functionname
= NULL
;
2536 prev_discriminator
= 0;
2538 /* We make a copy of syms to sort. We don't want to sort syms
2539 because that will screw up the relocs. */
2540 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2541 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2542 * sizeof (asymbol
*));
2543 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2544 sorted_symcount
* sizeof (asymbol
*));
2546 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2548 for (i
= 0; i
< synthcount
; ++i
)
2550 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2554 /* Sort the symbols into section and symbol order. */
2555 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2557 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2559 disasm_info
.application_data
= (void *) &aux
;
2561 aux
.require_sec
= FALSE
;
2562 aux
.dynrelbuf
= NULL
;
2563 aux
.dynrelcount
= 0;
2565 aux
.symbol
= disasm_sym
;
2567 disasm_info
.print_address_func
= objdump_print_address
;
2568 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2570 if (machine
!= NULL
)
2572 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2575 fatal (_("can't use supplied machine %s"), machine
);
2577 abfd
->arch_info
= inf
;
2580 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2582 struct bfd_target
*xvec
;
2584 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2585 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2586 xvec
->byteorder
= endian
;
2590 /* Use libopcodes to locate a suitable disassembler. */
2591 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2592 bfd_big_endian (abfd
),
2593 bfd_get_mach (abfd
), abfd
);
2594 if (!aux
.disassemble_fn
)
2596 non_fatal (_("can't disassemble for architecture %s\n"),
2597 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2602 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2603 disasm_info
.arch
= bfd_get_arch (abfd
);
2604 disasm_info
.mach
= bfd_get_mach (abfd
);
2605 disasm_info
.disassembler_options
= disassembler_options
;
2606 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2607 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2608 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2609 disasm_info
.disassembler_needs_relocs
= FALSE
;
2611 if (bfd_big_endian (abfd
))
2612 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2613 else if (bfd_little_endian (abfd
))
2614 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2616 /* ??? Aborting here seems too drastic. We could default to big or little
2618 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2620 /* Allow the target to customize the info structure. */
2621 disassemble_init_for_target (& disasm_info
);
2623 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2625 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2627 if (relsize
< 0 && dump_dynamic_reloc_info
)
2628 bfd_fatal (bfd_get_filename (abfd
));
2632 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2633 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2636 if (aux
.dynrelcount
< 0)
2637 bfd_fatal (bfd_get_filename (abfd
));
2639 /* Sort the relocs by address. */
2640 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2644 disasm_info
.symtab
= sorted_syms
;
2645 disasm_info
.symtab_size
= sorted_symcount
;
2647 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2649 if (aux
.dynrelbuf
!= NULL
)
2650 free (aux
.dynrelbuf
);
2655 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2656 asection
*sec
, void *file
)
2658 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2659 bfd
*abfd
= (bfd
*) file
;
2663 if (section
->start
!= NULL
)
2665 /* If it is already loaded, do nothing. */
2666 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2668 free (section
->start
);
2671 section
->filename
= bfd_get_filename (abfd
);
2672 section
->reloc_info
= NULL
;
2673 section
->num_relocs
= 0;
2674 section
->address
= bfd_get_section_vma (abfd
, sec
);
2675 section
->user_data
= sec
;
2676 section
->size
= bfd_get_section_size (sec
);
2677 amt
= section
->size
+ 1;
2678 if (amt
== 0 || amt
> bfd_get_file_size (abfd
))
2680 section
->start
= NULL
;
2681 free_debug_section (debug
);
2682 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2683 sanitize_string (section
->name
),
2684 (unsigned long long) section
->size
);
2687 section
->start
= contents
= malloc (amt
);
2688 if (section
->start
== NULL
2689 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2691 free_debug_section (debug
);
2692 printf (_("\nCan't get contents for section '%s'.\n"),
2693 sanitize_string (section
->name
));
2696 /* Ensure any string section has a terminating NUL. */
2697 section
->start
[section
->size
] = 0;
2699 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2704 bfd_cache_section_contents (sec
, section
->start
);
2706 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2713 free_debug_section (debug
);
2714 printf (_("\nCan't get contents for section '%s'.\n"),
2715 sanitize_string (section
->name
));
2719 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2722 unsigned long reloc_count
;
2725 relocs
= (arelent
**) xmalloc (reloc_size
);
2727 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2728 if (reloc_count
== 0)
2732 section
->reloc_info
= relocs
;
2733 section
->num_relocs
= reloc_count
;
2742 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2747 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2750 relocs
= (arelent
**) dsec
->reloc_info
;
2752 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2753 if (rp
->address
== offset
)
2760 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2762 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2763 bfd
*abfd
= (bfd
*) file
;
2766 /* If it is already loaded, do nothing. */
2767 if (section
->start
!= NULL
)
2769 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2773 /* Locate the debug section. */
2774 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2776 section
->name
= section
->uncompressed_name
;
2779 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2781 section
->name
= section
->compressed_name
;
2786 return load_specific_debug_section (debug
, sec
, file
);
2790 free_debug_section (enum dwarf_section_display_enum debug
)
2792 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2794 if (section
->start
== NULL
)
2797 /* PR 17512: file: 0f67f69d. */
2798 if (section
->user_data
!= NULL
)
2800 asection
* sec
= (asection
*) section
->user_data
;
2802 /* If we are freeing contents that are also pointed to by the BFD
2803 library's section structure then make sure to update those pointers
2804 too. Otherwise, the next time we try to load data for this section
2805 we can end up using a stale pointer. */
2806 if (section
->start
== sec
->contents
)
2808 sec
->contents
= NULL
;
2809 sec
->flags
&= ~ SEC_IN_MEMORY
;
2810 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2814 free ((char *) section
->start
);
2815 section
->start
= NULL
;
2816 section
->address
= 0;
2821 close_debug_file (void * file
)
2823 bfd
* abfd
= (bfd
*) file
;
2829 open_debug_file (const char * pathname
)
2833 data
= bfd_openr (pathname
, NULL
);
2837 if (! bfd_check_format (data
, bfd_object
))
2844 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2845 void *arg ATTRIBUTE_UNUSED
)
2847 const char *name
= bfd_get_section_name (abfd
, section
);
2851 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2852 match
= ".debug_info";
2856 for (i
= 0; i
< max
; i
++)
2857 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2858 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2859 && debug_displays
[i
].enabled
!= NULL
2860 && *debug_displays
[i
].enabled
)
2862 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2864 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2865 sec
->name
= sec
->uncompressed_name
;
2867 sec
->name
= sec
->compressed_name
;
2868 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2871 debug_displays
[i
].display (sec
, abfd
);
2873 if (i
!= info
&& i
!= abbrev
)
2874 free_debug_section ((enum dwarf_section_display_enum
) i
);
2880 /* Dump the dwarf debugging information. */
2883 dump_dwarf (bfd
*abfd
)
2887 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2889 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2891 if (bfd_big_endian (abfd
))
2892 byte_get
= byte_get_big_endian
;
2893 else if (bfd_little_endian (abfd
))
2894 byte_get
= byte_get_little_endian
;
2896 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2898 warn (_("File %s does not contain any dwarf debug information\n"),
2899 bfd_get_filename (abfd
));
2903 switch (bfd_get_arch (abfd
))
2906 switch (bfd_get_mach (abfd
))
2908 case bfd_mach_x86_64
:
2909 case bfd_mach_x86_64_intel_syntax
:
2910 case bfd_mach_x86_64_nacl
:
2911 case bfd_mach_x64_32
:
2912 case bfd_mach_x64_32_intel_syntax
:
2913 case bfd_mach_x64_32_nacl
:
2914 init_dwarf_regnames_x86_64 ();
2918 init_dwarf_regnames_i386 ();
2923 case bfd_arch_iamcu
:
2924 init_dwarf_regnames_iamcu ();
2927 case bfd_arch_aarch64
:
2928 init_dwarf_regnames_aarch64();
2932 init_dwarf_regnames_s390 ();
2935 case bfd_arch_riscv
:
2936 init_dwarf_regnames_riscv ();
2940 /* S12Z has a 24 bit address space. But the only known
2941 producer of dwarf_info encodes addresses into 32 bits. */
2949 separates
= load_separate_debug_file (abfd
, bfd_get_filename (abfd
));
2951 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2954 bfd_map_over_sections (separates
, dump_dwarf_section
, NULL
);
2956 free_debug_memory ();
2959 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2960 it. Return NULL on failure. */
2963 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2968 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2969 if (stabsect
== NULL
)
2971 printf (_("No %s section present\n\n"),
2972 sanitize_string (sect_name
));
2976 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2978 non_fatal (_("reading %s section of %s failed: %s"),
2979 sect_name
, bfd_get_filename (abfd
),
2980 bfd_errmsg (bfd_get_error ()));
2986 *size_ptr
= bfd_section_size (abfd
, stabsect
);
2991 /* Stabs entries use a 12 byte format:
2992 4 byte string table index
2994 1 byte stab other field
2995 2 byte stab desc field
2997 FIXME: This will have to change for a 64 bit object format. */
2999 #define STRDXOFF (0)
3001 #define OTHEROFF (5)
3004 #define STABSIZE (12)
3006 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3007 using string table section STRSECT_NAME (in `strtab'). */
3010 print_section_stabs (bfd
*abfd
,
3011 const char *stabsect_name
,
3012 unsigned *string_offset_ptr
)
3015 unsigned file_string_table_offset
= 0;
3016 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3017 bfd_byte
*stabp
, *stabs_end
;
3020 stabs_end
= stabp
+ stab_size
;
3022 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3023 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3025 /* Loop through all symbols and print them.
3027 We start the index at -1 because there is a dummy symbol on
3028 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3029 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3033 unsigned char type
, other
;
3034 unsigned short desc
;
3037 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3038 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3039 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3040 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3041 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3043 printf ("\n%-6d ", i
);
3044 /* Either print the stab name, or, if unnamed, print its number
3045 again (makes consistent formatting for tools like awk). */
3046 name
= bfd_get_stab_name (type
);
3048 printf ("%-6s", sanitize_string (name
));
3049 else if (type
== N_UNDF
)
3052 printf ("%-6d", type
);
3053 printf (" %-6d %-6d ", other
, desc
);
3054 bfd_printf_vma (abfd
, value
);
3055 printf (" %-6lu", strx
);
3057 /* Symbols with type == 0 (N_UNDF) specify the length of the
3058 string table associated with this file. We use that info
3059 to know how to relocate the *next* file's string table indices. */
3062 file_string_table_offset
= next_file_string_table_offset
;
3063 next_file_string_table_offset
+= value
;
3067 bfd_size_type amt
= strx
+ file_string_table_offset
;
3069 /* Using the (possibly updated) string table offset, print the
3070 string (if any) associated with this symbol. */
3071 if (amt
< stabstr_size
)
3072 /* PR 17512: file: 079-79389-0.001:0.1.
3073 FIXME: May need to sanitize this string before displaying. */
3074 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3080 *string_offset_ptr
= next_file_string_table_offset
;
3085 const char * section_name
;
3086 const char * string_section_name
;
3087 unsigned string_offset
;
3092 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3095 stab_section_names
* sought
= (stab_section_names
*) names
;
3097 /* Check for section names for which stabsect_name is a prefix, to
3098 handle .stab.N, etc. */
3099 len
= strlen (sought
->section_name
);
3101 /* If the prefix matches, and the files section name ends with a
3102 nul or a digit, then we match. I.e., we want either an exact
3103 match or a section followed by a number. */
3104 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3105 && (section
->name
[len
] == 0
3106 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3109 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3114 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
3116 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3122 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3124 stab_section_names s
;
3126 s
.section_name
= stabsect_name
;
3127 s
.string_section_name
= strsect_name
;
3128 s
.string_offset
= 0;
3130 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3136 /* Dump the any sections containing stabs debugging information. */
3139 dump_stabs (bfd
*abfd
)
3141 dump_stabs_section (abfd
, ".stab", ".stabstr");
3142 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3143 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3146 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3148 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3152 dump_bfd_header (bfd
*abfd
)
3156 printf (_("architecture: %s, "),
3157 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3158 bfd_get_mach (abfd
)));
3159 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3161 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3162 PF (HAS_RELOC
, "HAS_RELOC");
3163 PF (EXEC_P
, "EXEC_P");
3164 PF (HAS_LINENO
, "HAS_LINENO");
3165 PF (HAS_DEBUG
, "HAS_DEBUG");
3166 PF (HAS_SYMS
, "HAS_SYMS");
3167 PF (HAS_LOCALS
, "HAS_LOCALS");
3168 PF (DYNAMIC
, "DYNAMIC");
3169 PF (WP_TEXT
, "WP_TEXT");
3170 PF (D_PAGED
, "D_PAGED");
3171 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3172 printf (_("\nstart address 0x"));
3173 bfd_printf_vma (abfd
, abfd
->start_address
);
3179 dump_bfd_private_header (bfd
*abfd
)
3181 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3182 non_fatal (_("warning: private headers incomplete: %s"),
3183 bfd_errmsg (bfd_get_error ()));
3187 dump_target_specific (bfd
*abfd
)
3189 const struct objdump_private_desc
* const *desc
;
3190 struct objdump_private_option
*opt
;
3193 /* Find the desc. */
3194 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3195 if ((*desc
)->filter (abfd
))
3200 non_fatal (_("option -P/--private not supported by this file"));
3204 /* Clear all options. */
3205 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3206 opt
->selected
= FALSE
;
3208 /* Decode options. */
3209 b
= dump_private_options
;
3212 e
= strchr (b
, ',');
3217 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3218 if (strcmp (opt
->name
, b
) == 0)
3220 opt
->selected
= TRUE
;
3223 if (opt
->name
== NULL
)
3224 non_fatal (_("target specific dump '%s' not supported"), b
);
3235 (*desc
)->dump (abfd
);
3238 /* Display a section in hexadecimal format with associated characters.
3239 Each line prefixed by the zero padded address. */
3242 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3244 bfd_byte
*data
= NULL
;
3245 bfd_size_type datasize
;
3246 bfd_vma addr_offset
;
3247 bfd_vma start_offset
;
3248 bfd_vma stop_offset
;
3249 unsigned int opb
= bfd_octets_per_byte (abfd
);
3250 /* Bytes per line. */
3251 const int onaline
= 16;
3256 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3259 if (! process_section_p (section
))
3262 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3265 /* Compute the address range to display. */
3266 if (start_address
== (bfd_vma
) -1
3267 || start_address
< section
->vma
)
3270 start_offset
= start_address
- section
->vma
;
3272 if (stop_address
== (bfd_vma
) -1)
3273 stop_offset
= datasize
/ opb
;
3276 if (stop_address
< section
->vma
)
3279 stop_offset
= stop_address
- section
->vma
;
3281 if (stop_offset
> datasize
/ opb
)
3282 stop_offset
= datasize
/ opb
;
3285 if (start_offset
>= stop_offset
)
3288 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3289 if (display_file_offsets
)
3290 printf (_(" (Starting at file offset: 0x%lx)"),
3291 (unsigned long) (section
->filepos
+ start_offset
));
3294 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3296 non_fatal (_("Reading section %s failed because: %s"),
3297 section
->name
, bfd_errmsg (bfd_get_error ()));
3303 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3304 if (strlen (buf
) >= sizeof (buf
))
3308 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3310 count
= strlen (buf
) - count
;
3314 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3315 if (strlen (buf
) >= sizeof (buf
))
3319 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3321 count
= strlen (buf
) - count
;
3325 for (addr_offset
= start_offset
;
3326 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3330 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3331 count
= strlen (buf
);
3332 if ((size_t) count
>= sizeof (buf
))
3336 while (count
< width
)
3341 fputs (buf
+ count
- width
, stdout
);
3344 for (j
= addr_offset
* opb
;
3345 j
< addr_offset
* opb
+ onaline
; j
++)
3347 if (j
< stop_offset
* opb
)
3348 printf ("%02x", (unsigned) (data
[j
]));
3356 for (j
= addr_offset
* opb
;
3357 j
< addr_offset
* opb
+ onaline
; j
++)
3359 if (j
>= stop_offset
* opb
)
3362 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3369 /* Actually display the various requested regions. */
3372 dump_data (bfd
*abfd
)
3374 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3377 /* Should perhaps share code and display with nm? */
3380 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3389 max_count
= dynsymcount
;
3390 printf ("DYNAMIC SYMBOL TABLE:\n");
3395 max_count
= symcount
;
3396 printf ("SYMBOL TABLE:\n");
3400 printf (_("no symbols\n"));
3402 for (count
= 0; count
< max_count
; count
++)
3406 if (*current
== NULL
)
3407 printf (_("no information for symbol number %ld\n"), count
);
3409 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3410 printf (_("could not determine the type of symbol number %ld\n"),
3413 else if (process_section_p ((* current
)->section
)
3414 && (dump_special_syms
3415 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3417 const char *name
= (*current
)->name
;
3419 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3423 /* If we want to demangle the name, we demangle it
3424 here, and temporarily clobber it while calling
3425 bfd_print_symbol. FIXME: This is a gross hack. */
3426 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3428 (*current
)->name
= alloc
;
3429 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3430 bfd_print_symbol_all
);
3433 (*current
)->name
= name
;
3438 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3439 bfd_print_symbol_all
);
3449 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3452 char *last_filename
, *last_functionname
;
3453 unsigned int last_line
;
3454 unsigned int last_discriminator
;
3456 /* Get column headers lined up reasonably. */
3464 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3465 width
= strlen (buf
) - 7;
3467 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3470 last_filename
= NULL
;
3471 last_functionname
= NULL
;
3473 last_discriminator
= 0;
3475 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3478 const char *filename
, *functionname
;
3479 unsigned int linenumber
;
3480 unsigned int discriminator
;
3481 const char *sym_name
;
3482 const char *section_name
;
3483 bfd_vma addend2
= 0;
3485 if (start_address
!= (bfd_vma
) -1
3486 && q
->address
< start_address
)
3488 if (stop_address
!= (bfd_vma
) -1
3489 && q
->address
> stop_address
)
3492 if (with_line_numbers
3494 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3495 &filename
, &functionname
,
3496 &linenumber
, &discriminator
))
3498 if (functionname
!= NULL
3499 && (last_functionname
== NULL
3500 || strcmp (functionname
, last_functionname
) != 0))
3502 printf ("%s():\n", sanitize_string (functionname
));
3503 if (last_functionname
!= NULL
)
3504 free (last_functionname
);
3505 last_functionname
= xstrdup (functionname
);
3509 && (linenumber
!= last_line
3510 || (filename
!= NULL
3511 && last_filename
!= NULL
3512 && filename_cmp (filename
, last_filename
) != 0)
3513 || (discriminator
!= last_discriminator
)))
3515 if (discriminator
> 0)
3516 printf ("%s:%u\n", filename
== NULL
? "???" :
3517 sanitize_string (filename
), linenumber
);
3519 printf ("%s:%u (discriminator %u)\n",
3520 filename
== NULL
? "???" : sanitize_string (filename
),
3521 linenumber
, discriminator
);
3522 last_line
= linenumber
;
3523 last_discriminator
= discriminator
;
3524 if (last_filename
!= NULL
)
3525 free (last_filename
);
3526 if (filename
== NULL
)
3527 last_filename
= NULL
;
3529 last_filename
= xstrdup (filename
);
3533 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3535 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3536 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3541 section_name
= NULL
;
3544 bfd_printf_vma (abfd
, q
->address
);
3545 if (q
->howto
== NULL
)
3546 printf (" *unknown* ");
3547 else if (q
->howto
->name
)
3549 const char *name
= q
->howto
->name
;
3551 /* R_SPARC_OLO10 relocations contain two addends.
3552 But because 'arelent' lacks enough storage to
3553 store them both, the 64-bit ELF Sparc backend
3554 records this as two relocations. One R_SPARC_LO10
3555 and one R_SPARC_13, both pointing to the same
3556 address. This is merely so that we have some
3557 place to store both addend fields.
3559 Undo this transformation, otherwise the output
3560 will be confusing. */
3561 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3562 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3564 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3566 arelent
*q2
= *(p
+ 1);
3569 && q
->address
== q2
->address
3570 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3572 name
= "R_SPARC_OLO10";
3573 addend2
= q2
->addend
;
3577 printf (" %-16s ", name
);
3580 printf (" %-16d ", q
->howto
->type
);
3584 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3588 if (section_name
== NULL
)
3589 section_name
= "*unknown*";
3590 printf ("[%s]", sanitize_string (section_name
));
3595 bfd_signed_vma addend
= q
->addend
;
3603 bfd_printf_vma (abfd
, addend
);
3608 bfd_printf_vma (abfd
, addend2
);
3614 if (last_filename
!= NULL
)
3615 free (last_filename
);
3616 if (last_functionname
!= NULL
)
3617 free (last_functionname
);
3621 dump_relocs_in_section (bfd
*abfd
,
3623 void *dummy ATTRIBUTE_UNUSED
)
3629 if ( bfd_is_abs_section (section
)
3630 || bfd_is_und_section (section
)
3631 || bfd_is_com_section (section
)
3632 || (! process_section_p (section
))
3633 || ((section
->flags
& SEC_RELOC
) == 0))
3636 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3638 bfd_fatal (bfd_get_filename (abfd
));
3640 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3644 printf (" (none)\n\n");
3648 if ((bfd_get_file_flags (abfd
) & (BFD_IN_MEMORY
| BFD_LINKER_CREATED
)) == 0
3649 && (/* Check that the size of the relocs is reasonable. Note that some
3650 file formats, eg aout, can have relocs whose internal size is
3651 larger than their external size, thus we check the size divided
3652 by four against the file size. See PR 23931 for an example of
3654 ((ufile_ptr
) (relsize
/ 4) > bfd_get_file_size (abfd
))
3655 /* Also check the section's reloc count since if this is negative
3656 (or very large) the computation in bfd_get_reloc_upper_bound
3657 may have resulted in returning a small, positive integer.
3658 See PR 22508 for a reproducer.
3660 Note - we check against file size rather than section size as
3661 it is possible for there to be more relocs that apply to a
3662 section than there are bytes in that section. */
3663 || (section
->reloc_count
> bfd_get_file_size (abfd
))))
3665 printf (" (too many: %#x relocs)\n", section
->reloc_count
);
3666 bfd_set_error (bfd_error_file_truncated
);
3667 bfd_fatal (bfd_get_filename (abfd
));
3670 relpp
= (arelent
**) xmalloc (relsize
);
3671 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3676 non_fatal (_("failed to read relocs in: %s"), sanitize_string (bfd_get_filename (abfd
)));
3677 bfd_fatal (_("error message was"));
3679 else if (relcount
== 0)
3680 printf (" (none)\n\n");
3684 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3691 dump_relocs (bfd
*abfd
)
3693 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3697 dump_dynamic_relocs (bfd
*abfd
)
3703 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3705 bfd_fatal (bfd_get_filename (abfd
));
3707 printf ("DYNAMIC RELOCATION RECORDS");
3710 printf (" (none)\n\n");
3713 relpp
= (arelent
**) xmalloc (relsize
);
3714 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3717 bfd_fatal (bfd_get_filename (abfd
));
3718 else if (relcount
== 0)
3719 printf (" (none)\n\n");
3723 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3730 /* Creates a table of paths, to search for source files. */
3733 add_include_path (const char *path
)
3737 include_path_count
++;
3738 include_paths
= (const char **)
3739 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3740 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3741 if (path
[1] == ':' && path
[2] == 0)
3742 path
= concat (path
, ".", (const char *) 0);
3744 include_paths
[include_path_count
- 1] = path
;
3748 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3752 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3754 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3755 section
->vma
+= adjust_section_vma
;
3757 section
->lma
+= adjust_section_vma
;
3761 /* Dump selected contents of ABFD. */
3764 dump_bfd (bfd
*abfd
)
3766 /* If we are adjusting section VMA's, change them all now. Changing
3767 the BFD information is a hack. However, we must do it, or
3768 bfd_find_nearest_line will not do the right thing. */
3769 if (adjust_section_vma
!= 0)
3771 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3772 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3775 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3776 printf (_("\n%s: file format %s\n"),
3777 sanitize_string (bfd_get_filename (abfd
)),
3780 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3781 if (dump_file_header
)
3782 dump_bfd_header (abfd
);
3783 if (dump_private_headers
)
3784 dump_bfd_private_header (abfd
);
3785 if (dump_private_options
!= NULL
)
3786 dump_target_specific (abfd
);
3787 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3794 || dump_dwarf_section_info
)
3795 syms
= slurp_symtab (abfd
);
3797 if (dump_section_headers
)
3798 dump_headers (abfd
);
3800 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3801 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3802 dynsyms
= slurp_dynamic_symtab (abfd
);
3805 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3806 dynsymcount
, dynsyms
, &synthsyms
);
3812 dump_symbols (abfd
, FALSE
);
3813 if (dump_dynamic_symtab
)
3814 dump_symbols (abfd
, TRUE
);
3815 if (dump_dwarf_section_info
)
3817 if (dump_stab_section_info
)
3819 if (dump_reloc_info
&& ! disassemble
)
3821 if (dump_dynamic_reloc_info
&& ! disassemble
)
3822 dump_dynamic_relocs (abfd
);
3823 if (dump_section_contents
)
3826 disassemble_data (abfd
);
3832 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3833 if (dhandle
!= NULL
)
3835 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3837 dump_debugging_tags
? TRUE
: FALSE
))
3839 non_fatal (_("%s: printing debugging information failed"),
3840 bfd_get_filename (abfd
));
3846 /* PR 6483: If there was no STABS debug info in the file, try
3848 else if (! dump_dwarf_section_info
)
3850 dwarf_select_sections_all ();
3879 display_object_bfd (bfd
*abfd
)
3883 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3889 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3891 nonfatal (bfd_get_filename (abfd
));
3892 list_matching_formats (matching
);
3897 if (bfd_get_error () != bfd_error_file_not_recognized
)
3899 nonfatal (bfd_get_filename (abfd
));
3903 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3909 nonfatal (bfd_get_filename (abfd
));
3911 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3913 list_matching_formats (matching
);
3919 display_any_bfd (bfd
*file
, int level
)
3921 /* Decompress sections unless dumping the section contents. */
3922 if (!dump_section_contents
)
3923 file
->flags
|= BFD_DECOMPRESS
;
3925 /* If the file is an archive, process all of its elements. */
3926 if (bfd_check_format (file
, bfd_archive
))
3929 bfd
*last_arfile
= NULL
;
3932 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
3933 else if (level
> 100)
3935 /* Prevent corrupted files from spinning us into an
3936 infinite loop. 100 is an arbitrary heuristic. */
3937 fatal (_("Archive nesting is too deep"));
3941 printf (_("In nested archive %s:\n"),
3942 sanitize_string (bfd_get_filename (file
)));
3946 bfd_set_error (bfd_error_no_error
);
3948 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3951 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3952 nonfatal (bfd_get_filename (file
));
3956 display_any_bfd (arfile
, level
+ 1);
3958 if (last_arfile
!= NULL
)
3960 bfd_close (last_arfile
);
3961 /* PR 17512: file: ac585d01. */
3962 if (arfile
== last_arfile
)
3968 last_arfile
= arfile
;
3971 if (last_arfile
!= NULL
)
3972 bfd_close (last_arfile
);
3975 display_object_bfd (file
);
3979 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3983 if (get_file_size (filename
) < 1)
3989 file
= bfd_openr (filename
, target
);
3992 nonfatal (filename
);
3996 display_any_bfd (file
, 0);
3998 /* This is an optimization to improve the speed of objdump, especially when
3999 dumping a file with lots of associated debug informatiom. Calling
4000 bfd_close on such a file can take a non-trivial amount of time as there
4001 are lots of lists to walk and buffers to free. This is only really
4002 necessary however if we are about to load another file and we need the
4003 memory back. Otherwise, if we are about to exit, then we can save (a lot
4004 of) time by only doing a quick close, and allowing the OS to reclaim the
4009 bfd_close_all_done (file
);
4013 main (int argc
, char **argv
)
4016 char *target
= default_target
;
4017 bfd_boolean seenflag
= FALSE
;
4019 #if defined (HAVE_SETLOCALE)
4020 #if defined (HAVE_LC_MESSAGES)
4021 setlocale (LC_MESSAGES
, "");
4023 setlocale (LC_CTYPE
, "");
4026 bindtextdomain (PACKAGE
, LOCALEDIR
);
4027 textdomain (PACKAGE
);
4029 program_name
= *argv
;
4030 xmalloc_set_program_name (program_name
);
4031 bfd_set_error_program_name (program_name
);
4033 START_PROGRESS (program_name
, 0);
4035 expandargv (&argc
, &argv
);
4037 if (bfd_init () != BFD_INIT_MAGIC
)
4038 fatal (_("fatal error: libbfd ABI mismatch"));
4039 set_default_bfd_target ();
4041 while ((c
= getopt_long (argc
, argv
,
4042 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4043 long_options
, (int *) 0))
4049 break; /* We've been given a long option. */
4056 if (disassembler_options
)
4057 /* Ignore potential memory leak for now. */
4058 options
= concat (disassembler_options
, ",",
4059 optarg
, (const char *) NULL
);
4062 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4069 display_file_offsets
= TRUE
;
4072 with_line_numbers
= TRUE
;
4081 enum demangling_styles style
;
4083 style
= cplus_demangle_name_to_style (optarg
);
4084 if (style
== unknown_demangling
)
4085 fatal (_("unknown demangling style `%s'"),
4088 cplus_demangle_set_style (style
);
4091 case OPTION_RECURSE_LIMIT
:
4092 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4094 case OPTION_NO_RECURSE_LIMIT
:
4095 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4098 do_wide
= wide_output
= TRUE
;
4100 case OPTION_ADJUST_VMA
:
4101 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4103 case OPTION_START_ADDRESS
:
4104 start_address
= parse_vma (optarg
, "--start-address");
4105 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4106 fatal (_("error: the start address should be before the end address"));
4108 case OPTION_STOP_ADDRESS
:
4109 stop_address
= parse_vma (optarg
, "--stop-address");
4110 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4111 fatal (_("error: the stop address should be after the start address"));
4115 prefix_length
= strlen (prefix
);
4116 /* Remove an unnecessary trailing '/' */
4117 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4120 case OPTION_PREFIX_STRIP
:
4121 prefix_strip
= atoi (optarg
);
4122 if (prefix_strip
< 0)
4123 fatal (_("error: prefix strip must be non-negative"));
4125 case OPTION_INSN_WIDTH
:
4126 insn_width
= strtoul (optarg
, NULL
, 0);
4127 if (insn_width
<= 0)
4128 fatal (_("error: instruction width must be positive"));
4130 case OPTION_INLINES
:
4131 unwind_inlines
= TRUE
;
4134 if (strcmp (optarg
, "B") == 0)
4135 endian
= BFD_ENDIAN_BIG
;
4136 else if (strcmp (optarg
, "L") == 0)
4137 endian
= BFD_ENDIAN_LITTLE
;
4140 nonfatal (_("unrecognized -E option"));
4145 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4146 endian
= BFD_ENDIAN_BIG
;
4147 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4148 endian
= BFD_ENDIAN_LITTLE
;
4151 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4158 dump_file_header
= TRUE
;
4162 formats_info
= TRUE
;
4166 add_include_path (optarg
);
4169 dump_private_headers
= TRUE
;
4173 dump_private_options
= optarg
;
4177 dump_private_headers
= TRUE
;
4179 dump_reloc_info
= TRUE
;
4180 dump_file_header
= TRUE
;
4181 dump_ar_hdrs
= TRUE
;
4182 dump_section_headers
= TRUE
;
4190 dump_dynamic_symtab
= TRUE
;
4196 disasm_sym
= optarg
;
4199 disassemble_zeroes
= TRUE
;
4203 disassemble_all
= TRUE
;
4208 with_source_code
= TRUE
;
4217 dump_debugging_tags
= 1;
4222 dump_dwarf_section_info
= TRUE
;
4225 dwarf_select_sections_by_letters (optarg
);
4227 dwarf_select_sections_all ();
4230 dump_dwarf_section_info
= TRUE
;
4233 dwarf_select_sections_by_names (optarg
);
4235 dwarf_select_sections_all ();
4237 case OPTION_DWARF_DEPTH
:
4240 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4243 case OPTION_DWARF_START
:
4246 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4247 suppress_bfd_header
= 1;
4250 case OPTION_DWARF_CHECK
:
4254 dump_stab_section_info
= TRUE
;
4258 dump_section_contents
= TRUE
;
4262 dump_reloc_info
= TRUE
;
4266 dump_dynamic_reloc_info
= TRUE
;
4270 dump_ar_hdrs
= TRUE
;
4274 dump_section_headers
= TRUE
;
4279 show_version
= TRUE
;
4285 /* No need to set seenflag or to break - usage() does not return. */
4292 print_version ("objdump");
4298 exit_status
= display_info ();
4302 display_file ("a.out", target
, TRUE
);
4304 for (; optind
< argc
;)
4306 display_file (argv
[optind
], target
, optind
== argc
- 1);
4313 END_PROGRESS (program_name
);