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
;
2215 /* Sections that do not contain machine
2216 code are not normally disassembled. */
2217 if (! disassemble_all
2218 && only_list
== NULL
2219 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2220 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2223 if (! process_section_p (section
))
2226 datasize
= bfd_get_section_size (section
);
2230 if (start_address
== (bfd_vma
) -1
2231 || start_address
< section
->vma
)
2234 addr_offset
= start_address
- section
->vma
;
2236 if (stop_address
== (bfd_vma
) -1)
2237 stop_offset
= datasize
/ opb
;
2240 if (stop_address
< section
->vma
)
2243 stop_offset
= stop_address
- section
->vma
;
2244 if (stop_offset
> datasize
/ opb
)
2245 stop_offset
= datasize
/ opb
;
2248 if (addr_offset
>= stop_offset
)
2251 /* Decide which set of relocs to use. Load them if necessary. */
2252 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2253 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2255 rel_pp
= paux
->dynrelbuf
;
2256 rel_count
= paux
->dynrelcount
;
2257 /* Dynamic reloc addresses are absolute, non-dynamic are section
2258 relative. REL_OFFSET specifies the reloc address corresponding
2259 to the start of this section. */
2260 rel_offset
= section
->vma
;
2268 if ((section
->flags
& SEC_RELOC
) != 0
2269 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2273 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2275 bfd_fatal (bfd_get_filename (abfd
));
2279 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2280 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2282 bfd_fatal (bfd_get_filename (abfd
));
2284 /* Sort the relocs by address. */
2285 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2289 rel_ppend
= rel_pp
+ rel_count
;
2291 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2293 non_fatal (_("Reading section %s failed because: %s"),
2294 section
->name
, bfd_errmsg (bfd_get_error ()));
2298 paux
->sec
= section
;
2299 pinfo
->buffer
= data
;
2300 pinfo
->buffer_vma
= section
->vma
;
2301 pinfo
->buffer_length
= datasize
;
2302 pinfo
->section
= section
;
2304 /* Skip over the relocs belonging to addresses below the
2306 while (rel_pp
< rel_ppend
2307 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2310 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2312 /* Find the nearest symbol forwards from our current position. */
2313 paux
->require_sec
= TRUE
;
2314 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2315 (struct disassemble_info
*) inf
,
2317 paux
->require_sec
= FALSE
;
2319 /* PR 9774: If the target used signed addresses then we must make
2320 sure that we sign extend the value that we calculate for 'addr'
2321 in the loop below. */
2322 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2323 && (bed
= get_elf_backend_data (abfd
)) != NULL
2324 && bed
->sign_extend_vma
)
2325 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2327 /* Disassemble a block of instructions up to the address associated with
2328 the symbol we have just found. Then print the symbol and find the
2329 next symbol on. Repeat until we have disassembled the entire section
2330 or we have reached the end of the address range we are interested in. */
2331 while (addr_offset
< stop_offset
)
2335 bfd_vma nextstop_offset
;
2337 bfd_boolean do_print
= TRUE
;
2339 addr
= section
->vma
+ addr_offset
;
2340 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2342 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2347 (x
< sorted_symcount
2348 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2352 pinfo
->symbols
= sorted_syms
+ place
;
2353 pinfo
->num_symbols
= x
- place
;
2354 pinfo
->symtab_pos
= place
;
2358 pinfo
->symbols
= NULL
;
2359 pinfo
->num_symbols
= 0;
2360 pinfo
->symtab_pos
= -1;
2363 if (sym
&& paux
->symbol
)
2365 const char *name
= bfd_asymbol_name (sym
);
2368 if (do_demangle
&& name
[0] != '\0')
2370 /* Demangle the name. */
2371 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2375 do_print
= streq (name
, paux
->symbol
);
2379 if (! prefix_addresses
&& do_print
)
2381 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2382 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2384 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2387 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2389 else if (sym
== NULL
)
2393 #define is_valid_next_sym(SYM) \
2394 ((SYM)->section == section \
2395 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2396 && pinfo->symbol_is_valid (SYM, pinfo))
2398 /* Search forward for the next appropriate symbol in
2399 SECTION. Note that all the symbols are sorted
2400 together into one big array, and that some sections
2401 may have overlapping addresses. */
2402 while (place
< sorted_symcount
2403 && ! is_valid_next_sym (sorted_syms
[place
]))
2406 if (place
>= sorted_symcount
)
2409 nextsym
= sorted_syms
[place
];
2412 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2413 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2414 else if (nextsym
== NULL
)
2415 nextstop_offset
= stop_offset
;
2417 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2419 if (nextstop_offset
> stop_offset
2420 || nextstop_offset
<= addr_offset
)
2421 nextstop_offset
= stop_offset
;
2423 /* If a symbol is explicitly marked as being an object
2424 rather than a function, just dump the bytes without
2425 disassembling them. */
2428 || sym
->section
!= section
2429 || bfd_asymbol_value (sym
) > addr
2430 || ((sym
->flags
& BSF_OBJECT
) == 0
2431 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2433 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2435 || (sym
->flags
& BSF_FUNCTION
) != 0)
2442 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2443 addr_offset
, nextstop_offset
,
2444 rel_offset
, &rel_pp
, rel_ppend
);
2449 addr_offset
= nextstop_offset
;
2455 if (rel_ppstart
!= NULL
)
2459 /* Disassemble the contents of an object file. */
2462 disassemble_data (bfd
*abfd
)
2464 struct disassemble_info disasm_info
;
2465 struct objdump_disasm_info aux
;
2469 prev_functionname
= NULL
;
2471 prev_discriminator
= 0;
2473 /* We make a copy of syms to sort. We don't want to sort syms
2474 because that will screw up the relocs. */
2475 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2476 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2477 * sizeof (asymbol
*));
2478 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2479 sorted_symcount
* sizeof (asymbol
*));
2481 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2483 for (i
= 0; i
< synthcount
; ++i
)
2485 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2489 /* Sort the symbols into section and symbol order. */
2490 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2492 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2494 disasm_info
.application_data
= (void *) &aux
;
2496 aux
.require_sec
= FALSE
;
2497 aux
.dynrelbuf
= NULL
;
2498 aux
.dynrelcount
= 0;
2500 aux
.symbol
= disasm_sym
;
2502 disasm_info
.print_address_func
= objdump_print_address
;
2503 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2505 if (machine
!= NULL
)
2507 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2510 fatal (_("can't use supplied machine %s"), machine
);
2512 abfd
->arch_info
= inf
;
2515 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2517 struct bfd_target
*xvec
;
2519 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2520 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2521 xvec
->byteorder
= endian
;
2525 /* Use libopcodes to locate a suitable disassembler. */
2526 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2527 bfd_big_endian (abfd
),
2528 bfd_get_mach (abfd
), abfd
);
2529 if (!aux
.disassemble_fn
)
2531 non_fatal (_("can't disassemble for architecture %s\n"),
2532 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2537 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2538 disasm_info
.arch
= bfd_get_arch (abfd
);
2539 disasm_info
.mach
= bfd_get_mach (abfd
);
2540 disasm_info
.disassembler_options
= disassembler_options
;
2541 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2542 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2543 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2544 disasm_info
.disassembler_needs_relocs
= FALSE
;
2546 if (bfd_big_endian (abfd
))
2547 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2548 else if (bfd_little_endian (abfd
))
2549 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2551 /* ??? Aborting here seems too drastic. We could default to big or little
2553 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2555 /* Allow the target to customize the info structure. */
2556 disassemble_init_for_target (& disasm_info
);
2558 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2560 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2562 if (relsize
< 0 && dump_dynamic_reloc_info
)
2563 bfd_fatal (bfd_get_filename (abfd
));
2567 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2568 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2571 if (aux
.dynrelcount
< 0)
2572 bfd_fatal (bfd_get_filename (abfd
));
2574 /* Sort the relocs by address. */
2575 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2579 disasm_info
.symtab
= sorted_syms
;
2580 disasm_info
.symtab_size
= sorted_symcount
;
2582 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2584 if (aux
.dynrelbuf
!= NULL
)
2585 free (aux
.dynrelbuf
);
2590 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2591 asection
*sec
, void *file
)
2593 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2594 bfd
*abfd
= (bfd
*) file
;
2598 if (section
->start
!= NULL
)
2600 /* If it is already loaded, do nothing. */
2601 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2603 free (section
->start
);
2606 section
->filename
= bfd_get_filename (abfd
);
2607 section
->reloc_info
= NULL
;
2608 section
->num_relocs
= 0;
2609 section
->address
= bfd_get_section_vma (abfd
, sec
);
2610 section
->user_data
= sec
;
2611 section
->size
= bfd_get_section_size (sec
);
2612 amt
= section
->size
+ 1;
2613 if (amt
== 0 || amt
> bfd_get_file_size (abfd
))
2615 section
->start
= NULL
;
2616 free_debug_section (debug
);
2617 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2618 sanitize_string (section
->name
),
2619 (unsigned long long) section
->size
);
2622 section
->start
= contents
= malloc (amt
);
2623 if (section
->start
== NULL
2624 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2626 free_debug_section (debug
);
2627 printf (_("\nCan't get contents for section '%s'.\n"),
2628 sanitize_string (section
->name
));
2631 /* Ensure any string section has a terminating NUL. */
2632 section
->start
[section
->size
] = 0;
2634 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2639 bfd_cache_section_contents (sec
, section
->start
);
2641 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2648 free_debug_section (debug
);
2649 printf (_("\nCan't get contents for section '%s'.\n"),
2650 sanitize_string (section
->name
));
2654 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2657 unsigned long reloc_count
;
2660 relocs
= (arelent
**) xmalloc (reloc_size
);
2662 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2663 if (reloc_count
== 0)
2667 section
->reloc_info
= relocs
;
2668 section
->num_relocs
= reloc_count
;
2677 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2682 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2685 relocs
= (arelent
**) dsec
->reloc_info
;
2687 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2688 if (rp
->address
== offset
)
2695 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2697 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2698 bfd
*abfd
= (bfd
*) file
;
2701 /* If it is already loaded, do nothing. */
2702 if (section
->start
!= NULL
)
2704 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2708 /* Locate the debug section. */
2709 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2711 section
->name
= section
->uncompressed_name
;
2714 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2716 section
->name
= section
->compressed_name
;
2721 return load_specific_debug_section (debug
, sec
, file
);
2725 free_debug_section (enum dwarf_section_display_enum debug
)
2727 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2729 if (section
->start
== NULL
)
2732 /* PR 17512: file: 0f67f69d. */
2733 if (section
->user_data
!= NULL
)
2735 asection
* sec
= (asection
*) section
->user_data
;
2737 /* If we are freeing contents that are also pointed to by the BFD
2738 library's section structure then make sure to update those pointers
2739 too. Otherwise, the next time we try to load data for this section
2740 we can end up using a stale pointer. */
2741 if (section
->start
== sec
->contents
)
2743 sec
->contents
= NULL
;
2744 sec
->flags
&= ~ SEC_IN_MEMORY
;
2745 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2749 free ((char *) section
->start
);
2750 section
->start
= NULL
;
2751 section
->address
= 0;
2756 close_debug_file (void * file
)
2758 bfd
* abfd
= (bfd
*) file
;
2764 open_debug_file (const char * pathname
)
2768 data
= bfd_openr (pathname
, NULL
);
2772 if (! bfd_check_format (data
, bfd_object
))
2779 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2780 void *arg ATTRIBUTE_UNUSED
)
2782 const char *name
= bfd_get_section_name (abfd
, section
);
2786 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2787 match
= ".debug_info";
2791 for (i
= 0; i
< max
; i
++)
2792 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2793 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2794 && debug_displays
[i
].enabled
!= NULL
2795 && *debug_displays
[i
].enabled
)
2797 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2799 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2800 sec
->name
= sec
->uncompressed_name
;
2802 sec
->name
= sec
->compressed_name
;
2803 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2806 debug_displays
[i
].display (sec
, abfd
);
2808 if (i
!= info
&& i
!= abbrev
)
2809 free_debug_section ((enum dwarf_section_display_enum
) i
);
2815 /* Dump the dwarf debugging information. */
2818 dump_dwarf (bfd
*abfd
)
2822 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2824 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2826 if (bfd_big_endian (abfd
))
2827 byte_get
= byte_get_big_endian
;
2828 else if (bfd_little_endian (abfd
))
2829 byte_get
= byte_get_little_endian
;
2831 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2833 warn (_("File %s does not contain any dwarf debug information\n"),
2834 bfd_get_filename (abfd
));
2838 switch (bfd_get_arch (abfd
))
2841 switch (bfd_get_mach (abfd
))
2843 case bfd_mach_x86_64
:
2844 case bfd_mach_x86_64_intel_syntax
:
2845 case bfd_mach_x86_64_nacl
:
2846 case bfd_mach_x64_32
:
2847 case bfd_mach_x64_32_intel_syntax
:
2848 case bfd_mach_x64_32_nacl
:
2849 init_dwarf_regnames_x86_64 ();
2853 init_dwarf_regnames_i386 ();
2858 case bfd_arch_iamcu
:
2859 init_dwarf_regnames_iamcu ();
2862 case bfd_arch_aarch64
:
2863 init_dwarf_regnames_aarch64();
2867 init_dwarf_regnames_s390 ();
2870 case bfd_arch_riscv
:
2871 init_dwarf_regnames_riscv ();
2875 /* S12Z has a 24 bit address space. But the only known
2876 producer of dwarf_info encodes addresses into 32 bits. */
2884 separates
= load_separate_debug_file (abfd
, bfd_get_filename (abfd
));
2886 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2889 bfd_map_over_sections (separates
, dump_dwarf_section
, NULL
);
2891 free_debug_memory ();
2894 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2895 it. Return NULL on failure. */
2898 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2903 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2904 if (stabsect
== NULL
)
2906 printf (_("No %s section present\n\n"),
2907 sanitize_string (sect_name
));
2911 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2913 non_fatal (_("reading %s section of %s failed: %s"),
2914 sect_name
, bfd_get_filename (abfd
),
2915 bfd_errmsg (bfd_get_error ()));
2921 *size_ptr
= bfd_section_size (abfd
, stabsect
);
2926 /* Stabs entries use a 12 byte format:
2927 4 byte string table index
2929 1 byte stab other field
2930 2 byte stab desc field
2932 FIXME: This will have to change for a 64 bit object format. */
2934 #define STRDXOFF (0)
2936 #define OTHEROFF (5)
2939 #define STABSIZE (12)
2941 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2942 using string table section STRSECT_NAME (in `strtab'). */
2945 print_section_stabs (bfd
*abfd
,
2946 const char *stabsect_name
,
2947 unsigned *string_offset_ptr
)
2950 unsigned file_string_table_offset
= 0;
2951 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2952 bfd_byte
*stabp
, *stabs_end
;
2955 stabs_end
= stabp
+ stab_size
;
2957 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
2958 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2960 /* Loop through all symbols and print them.
2962 We start the index at -1 because there is a dummy symbol on
2963 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2964 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2968 unsigned char type
, other
;
2969 unsigned short desc
;
2972 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2973 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2974 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2975 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2976 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2978 printf ("\n%-6d ", i
);
2979 /* Either print the stab name, or, if unnamed, print its number
2980 again (makes consistent formatting for tools like awk). */
2981 name
= bfd_get_stab_name (type
);
2983 printf ("%-6s", sanitize_string (name
));
2984 else if (type
== N_UNDF
)
2987 printf ("%-6d", type
);
2988 printf (" %-6d %-6d ", other
, desc
);
2989 bfd_printf_vma (abfd
, value
);
2990 printf (" %-6lu", strx
);
2992 /* Symbols with type == 0 (N_UNDF) specify the length of the
2993 string table associated with this file. We use that info
2994 to know how to relocate the *next* file's string table indices. */
2997 file_string_table_offset
= next_file_string_table_offset
;
2998 next_file_string_table_offset
+= value
;
3002 bfd_size_type amt
= strx
+ file_string_table_offset
;
3004 /* Using the (possibly updated) string table offset, print the
3005 string (if any) associated with this symbol. */
3006 if (amt
< stabstr_size
)
3007 /* PR 17512: file: 079-79389-0.001:0.1.
3008 FIXME: May need to sanitize this string before displaying. */
3009 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3015 *string_offset_ptr
= next_file_string_table_offset
;
3020 const char * section_name
;
3021 const char * string_section_name
;
3022 unsigned string_offset
;
3027 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3030 stab_section_names
* sought
= (stab_section_names
*) names
;
3032 /* Check for section names for which stabsect_name is a prefix, to
3033 handle .stab.N, etc. */
3034 len
= strlen (sought
->section_name
);
3036 /* If the prefix matches, and the files section name ends with a
3037 nul or a digit, then we match. I.e., we want either an exact
3038 match or a section followed by a number. */
3039 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3040 && (section
->name
[len
] == 0
3041 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3044 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3049 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
3051 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3057 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3059 stab_section_names s
;
3061 s
.section_name
= stabsect_name
;
3062 s
.string_section_name
= strsect_name
;
3063 s
.string_offset
= 0;
3065 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3071 /* Dump the any sections containing stabs debugging information. */
3074 dump_stabs (bfd
*abfd
)
3076 dump_stabs_section (abfd
, ".stab", ".stabstr");
3077 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3078 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3081 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3083 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3087 dump_bfd_header (bfd
*abfd
)
3091 printf (_("architecture: %s, "),
3092 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3093 bfd_get_mach (abfd
)));
3094 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3096 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3097 PF (HAS_RELOC
, "HAS_RELOC");
3098 PF (EXEC_P
, "EXEC_P");
3099 PF (HAS_LINENO
, "HAS_LINENO");
3100 PF (HAS_DEBUG
, "HAS_DEBUG");
3101 PF (HAS_SYMS
, "HAS_SYMS");
3102 PF (HAS_LOCALS
, "HAS_LOCALS");
3103 PF (DYNAMIC
, "DYNAMIC");
3104 PF (WP_TEXT
, "WP_TEXT");
3105 PF (D_PAGED
, "D_PAGED");
3106 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3107 printf (_("\nstart address 0x"));
3108 bfd_printf_vma (abfd
, abfd
->start_address
);
3114 dump_bfd_private_header (bfd
*abfd
)
3116 bfd_print_private_bfd_data (abfd
, stdout
);
3120 dump_target_specific (bfd
*abfd
)
3122 const struct objdump_private_desc
* const *desc
;
3123 struct objdump_private_option
*opt
;
3126 /* Find the desc. */
3127 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3128 if ((*desc
)->filter (abfd
))
3133 non_fatal (_("option -P/--private not supported by this file"));
3137 /* Clear all options. */
3138 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3139 opt
->selected
= FALSE
;
3141 /* Decode options. */
3142 b
= dump_private_options
;
3145 e
= strchr (b
, ',');
3150 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3151 if (strcmp (opt
->name
, b
) == 0)
3153 opt
->selected
= TRUE
;
3156 if (opt
->name
== NULL
)
3157 non_fatal (_("target specific dump '%s' not supported"), b
);
3168 (*desc
)->dump (abfd
);
3171 /* Display a section in hexadecimal format with associated characters.
3172 Each line prefixed by the zero padded address. */
3175 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3177 bfd_byte
*data
= NULL
;
3178 bfd_size_type datasize
;
3179 bfd_vma addr_offset
;
3180 bfd_vma start_offset
;
3181 bfd_vma stop_offset
;
3182 unsigned int opb
= bfd_octets_per_byte (abfd
);
3183 /* Bytes per line. */
3184 const int onaline
= 16;
3189 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3192 if (! process_section_p (section
))
3195 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3198 /* Compute the address range to display. */
3199 if (start_address
== (bfd_vma
) -1
3200 || start_address
< section
->vma
)
3203 start_offset
= start_address
- section
->vma
;
3205 if (stop_address
== (bfd_vma
) -1)
3206 stop_offset
= datasize
/ opb
;
3209 if (stop_address
< section
->vma
)
3212 stop_offset
= stop_address
- section
->vma
;
3214 if (stop_offset
> datasize
/ opb
)
3215 stop_offset
= datasize
/ opb
;
3218 if (start_offset
>= stop_offset
)
3221 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3222 if (display_file_offsets
)
3223 printf (_(" (Starting at file offset: 0x%lx)"),
3224 (unsigned long) (section
->filepos
+ start_offset
));
3227 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3229 non_fatal (_("Reading section %s failed because: %s"),
3230 section
->name
, bfd_errmsg (bfd_get_error ()));
3236 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3237 if (strlen (buf
) >= sizeof (buf
))
3241 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3243 count
= strlen (buf
) - count
;
3247 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3248 if (strlen (buf
) >= sizeof (buf
))
3252 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3254 count
= strlen (buf
) - count
;
3258 for (addr_offset
= start_offset
;
3259 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3263 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3264 count
= strlen (buf
);
3265 if ((size_t) count
>= sizeof (buf
))
3269 while (count
< width
)
3274 fputs (buf
+ count
- width
, stdout
);
3277 for (j
= addr_offset
* opb
;
3278 j
< addr_offset
* opb
+ onaline
; j
++)
3280 if (j
< stop_offset
* opb
)
3281 printf ("%02x", (unsigned) (data
[j
]));
3289 for (j
= addr_offset
* opb
;
3290 j
< addr_offset
* opb
+ onaline
; j
++)
3292 if (j
>= stop_offset
* opb
)
3295 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3302 /* Actually display the various requested regions. */
3305 dump_data (bfd
*abfd
)
3307 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3310 /* Should perhaps share code and display with nm? */
3313 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3322 max_count
= dynsymcount
;
3323 printf ("DYNAMIC SYMBOL TABLE:\n");
3328 max_count
= symcount
;
3329 printf ("SYMBOL TABLE:\n");
3333 printf (_("no symbols\n"));
3335 for (count
= 0; count
< max_count
; count
++)
3339 if (*current
== NULL
)
3340 printf (_("no information for symbol number %ld\n"), count
);
3342 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3343 printf (_("could not determine the type of symbol number %ld\n"),
3346 else if (process_section_p ((* current
)->section
)
3347 && (dump_special_syms
3348 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3350 const char *name
= (*current
)->name
;
3352 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3356 /* If we want to demangle the name, we demangle it
3357 here, and temporarily clobber it while calling
3358 bfd_print_symbol. FIXME: This is a gross hack. */
3359 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3361 (*current
)->name
= alloc
;
3362 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3363 bfd_print_symbol_all
);
3366 (*current
)->name
= name
;
3371 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3372 bfd_print_symbol_all
);
3382 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3385 char *last_filename
, *last_functionname
;
3386 unsigned int last_line
;
3387 unsigned int last_discriminator
;
3389 /* Get column headers lined up reasonably. */
3397 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3398 width
= strlen (buf
) - 7;
3400 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3403 last_filename
= NULL
;
3404 last_functionname
= NULL
;
3406 last_discriminator
= 0;
3408 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3411 const char *filename
, *functionname
;
3412 unsigned int linenumber
;
3413 unsigned int discriminator
;
3414 const char *sym_name
;
3415 const char *section_name
;
3416 bfd_vma addend2
= 0;
3418 if (start_address
!= (bfd_vma
) -1
3419 && q
->address
< start_address
)
3421 if (stop_address
!= (bfd_vma
) -1
3422 && q
->address
> stop_address
)
3425 if (with_line_numbers
3427 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3428 &filename
, &functionname
,
3429 &linenumber
, &discriminator
))
3431 if (functionname
!= NULL
3432 && (last_functionname
== NULL
3433 || strcmp (functionname
, last_functionname
) != 0))
3435 printf ("%s():\n", sanitize_string (functionname
));
3436 if (last_functionname
!= NULL
)
3437 free (last_functionname
);
3438 last_functionname
= xstrdup (functionname
);
3442 && (linenumber
!= last_line
3443 || (filename
!= NULL
3444 && last_filename
!= NULL
3445 && filename_cmp (filename
, last_filename
) != 0)
3446 || (discriminator
!= last_discriminator
)))
3448 if (discriminator
> 0)
3449 printf ("%s:%u\n", filename
== NULL
? "???" :
3450 sanitize_string (filename
), linenumber
);
3452 printf ("%s:%u (discriminator %u)\n",
3453 filename
== NULL
? "???" : sanitize_string (filename
),
3454 linenumber
, discriminator
);
3455 last_line
= linenumber
;
3456 last_discriminator
= discriminator
;
3457 if (last_filename
!= NULL
)
3458 free (last_filename
);
3459 if (filename
== NULL
)
3460 last_filename
= NULL
;
3462 last_filename
= xstrdup (filename
);
3466 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3468 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3469 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3474 section_name
= NULL
;
3477 bfd_printf_vma (abfd
, q
->address
);
3478 if (q
->howto
== NULL
)
3479 printf (" *unknown* ");
3480 else if (q
->howto
->name
)
3482 const char *name
= q
->howto
->name
;
3484 /* R_SPARC_OLO10 relocations contain two addends.
3485 But because 'arelent' lacks enough storage to
3486 store them both, the 64-bit ELF Sparc backend
3487 records this as two relocations. One R_SPARC_LO10
3488 and one R_SPARC_13, both pointing to the same
3489 address. This is merely so that we have some
3490 place to store both addend fields.
3492 Undo this transformation, otherwise the output
3493 will be confusing. */
3494 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3495 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3497 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3499 arelent
*q2
= *(p
+ 1);
3502 && q
->address
== q2
->address
3503 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3505 name
= "R_SPARC_OLO10";
3506 addend2
= q2
->addend
;
3510 printf (" %-16s ", name
);
3513 printf (" %-16d ", q
->howto
->type
);
3517 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3521 if (section_name
== NULL
)
3522 section_name
= "*unknown*";
3523 printf ("[%s]", sanitize_string (section_name
));
3528 bfd_signed_vma addend
= q
->addend
;
3536 bfd_printf_vma (abfd
, addend
);
3541 bfd_printf_vma (abfd
, addend2
);
3547 if (last_filename
!= NULL
)
3548 free (last_filename
);
3549 if (last_functionname
!= NULL
)
3550 free (last_functionname
);
3554 dump_relocs_in_section (bfd
*abfd
,
3556 void *dummy ATTRIBUTE_UNUSED
)
3562 if ( bfd_is_abs_section (section
)
3563 || bfd_is_und_section (section
)
3564 || bfd_is_com_section (section
)
3565 || (! process_section_p (section
))
3566 || ((section
->flags
& SEC_RELOC
) == 0))
3569 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3571 bfd_fatal (bfd_get_filename (abfd
));
3573 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3577 printf (" (none)\n\n");
3581 if ((bfd_get_file_flags (abfd
) & (BFD_IN_MEMORY
| BFD_LINKER_CREATED
)) == 0
3582 && (/* Check that the size of the relocs is reasonable. Note that some
3583 file formats, eg aout, can have relocs whose internal size is
3584 larger than their external size, thus we check the size divided
3585 by four against the file size. See PR 23931 for an example of
3587 ((ufile_ptr
) (relsize
/ 4) > bfd_get_file_size (abfd
))
3588 /* Also check the section's reloc count since if this is negative
3589 (or very large) the computation in bfd_get_reloc_upper_bound
3590 may have resulted in returning a small, positive integer.
3591 See PR 22508 for a reproducer.
3593 Note - we check against file size rather than section size as
3594 it is possible for there to be more relocs that apply to a
3595 section than there are bytes in that section. */
3596 || (section
->reloc_count
> bfd_get_file_size (abfd
))))
3598 printf (" (too many: %#x relocs)\n", section
->reloc_count
);
3599 bfd_set_error (bfd_error_file_truncated
);
3600 bfd_fatal (bfd_get_filename (abfd
));
3603 relpp
= (arelent
**) xmalloc (relsize
);
3604 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3609 non_fatal (_("failed to read relocs in: %s"), sanitize_string (bfd_get_filename (abfd
)));
3610 bfd_fatal (_("error message was"));
3612 else if (relcount
== 0)
3613 printf (" (none)\n\n");
3617 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3624 dump_relocs (bfd
*abfd
)
3626 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3630 dump_dynamic_relocs (bfd
*abfd
)
3636 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3638 bfd_fatal (bfd_get_filename (abfd
));
3640 printf ("DYNAMIC RELOCATION RECORDS");
3643 printf (" (none)\n\n");
3646 relpp
= (arelent
**) xmalloc (relsize
);
3647 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3650 bfd_fatal (bfd_get_filename (abfd
));
3651 else if (relcount
== 0)
3652 printf (" (none)\n\n");
3656 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3663 /* Creates a table of paths, to search for source files. */
3666 add_include_path (const char *path
)
3670 include_path_count
++;
3671 include_paths
= (const char **)
3672 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3673 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3674 if (path
[1] == ':' && path
[2] == 0)
3675 path
= concat (path
, ".", (const char *) 0);
3677 include_paths
[include_path_count
- 1] = path
;
3681 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3685 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3687 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3688 section
->vma
+= adjust_section_vma
;
3690 section
->lma
+= adjust_section_vma
;
3694 /* Dump selected contents of ABFD. */
3697 dump_bfd (bfd
*abfd
)
3699 /* If we are adjusting section VMA's, change them all now. Changing
3700 the BFD information is a hack. However, we must do it, or
3701 bfd_find_nearest_line will not do the right thing. */
3702 if (adjust_section_vma
!= 0)
3704 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3705 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3708 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3709 printf (_("\n%s: file format %s\n"),
3710 sanitize_string (bfd_get_filename (abfd
)),
3713 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3714 if (dump_file_header
)
3715 dump_bfd_header (abfd
);
3716 if (dump_private_headers
)
3717 dump_bfd_private_header (abfd
);
3718 if (dump_private_options
!= NULL
)
3719 dump_target_specific (abfd
);
3720 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3727 || dump_dwarf_section_info
)
3728 syms
= slurp_symtab (abfd
);
3730 if (dump_section_headers
)
3731 dump_headers (abfd
);
3733 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3734 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3735 dynsyms
= slurp_dynamic_symtab (abfd
);
3738 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3739 dynsymcount
, dynsyms
, &synthsyms
);
3745 dump_symbols (abfd
, FALSE
);
3746 if (dump_dynamic_symtab
)
3747 dump_symbols (abfd
, TRUE
);
3748 if (dump_dwarf_section_info
)
3750 if (dump_stab_section_info
)
3752 if (dump_reloc_info
&& ! disassemble
)
3754 if (dump_dynamic_reloc_info
&& ! disassemble
)
3755 dump_dynamic_relocs (abfd
);
3756 if (dump_section_contents
)
3759 disassemble_data (abfd
);
3765 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3766 if (dhandle
!= NULL
)
3768 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3770 dump_debugging_tags
? TRUE
: FALSE
))
3772 non_fatal (_("%s: printing debugging information failed"),
3773 bfd_get_filename (abfd
));
3779 /* PR 6483: If there was no STABS debug info in the file, try
3781 else if (! dump_dwarf_section_info
)
3783 dwarf_select_sections_all ();
3812 display_object_bfd (bfd
*abfd
)
3816 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3822 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3824 nonfatal (bfd_get_filename (abfd
));
3825 list_matching_formats (matching
);
3830 if (bfd_get_error () != bfd_error_file_not_recognized
)
3832 nonfatal (bfd_get_filename (abfd
));
3836 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3842 nonfatal (bfd_get_filename (abfd
));
3844 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3846 list_matching_formats (matching
);
3852 display_any_bfd (bfd
*file
, int level
)
3854 /* Decompress sections unless dumping the section contents. */
3855 if (!dump_section_contents
)
3856 file
->flags
|= BFD_DECOMPRESS
;
3858 /* If the file is an archive, process all of its elements. */
3859 if (bfd_check_format (file
, bfd_archive
))
3862 bfd
*last_arfile
= NULL
;
3865 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
3866 else if (level
> 100)
3868 /* Prevent corrupted files from spinning us into an
3869 infinite loop. 100 is an arbitrary heuristic. */
3870 fatal (_("Archive nesting is too deep"));
3874 printf (_("In nested archive %s:\n"),
3875 sanitize_string (bfd_get_filename (file
)));
3879 bfd_set_error (bfd_error_no_error
);
3881 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3884 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3885 nonfatal (bfd_get_filename (file
));
3889 display_any_bfd (arfile
, level
+ 1);
3891 if (last_arfile
!= NULL
)
3893 bfd_close (last_arfile
);
3894 /* PR 17512: file: ac585d01. */
3895 if (arfile
== last_arfile
)
3901 last_arfile
= arfile
;
3904 if (last_arfile
!= NULL
)
3905 bfd_close (last_arfile
);
3908 display_object_bfd (file
);
3912 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3916 if (get_file_size (filename
) < 1)
3922 file
= bfd_openr (filename
, target
);
3925 nonfatal (filename
);
3929 display_any_bfd (file
, 0);
3931 /* This is an optimization to improve the speed of objdump, especially when
3932 dumping a file with lots of associated debug informatiom. Calling
3933 bfd_close on such a file can take a non-trivial amount of time as there
3934 are lots of lists to walk and buffers to free. This is only really
3935 necessary however if we are about to load another file and we need the
3936 memory back. Otherwise, if we are about to exit, then we can save (a lot
3937 of) time by only doing a quick close, and allowing the OS to reclaim the
3942 bfd_close_all_done (file
);
3946 main (int argc
, char **argv
)
3949 char *target
= default_target
;
3950 bfd_boolean seenflag
= FALSE
;
3952 #if defined (HAVE_SETLOCALE)
3953 #if defined (HAVE_LC_MESSAGES)
3954 setlocale (LC_MESSAGES
, "");
3956 setlocale (LC_CTYPE
, "");
3959 bindtextdomain (PACKAGE
, LOCALEDIR
);
3960 textdomain (PACKAGE
);
3962 program_name
= *argv
;
3963 xmalloc_set_program_name (program_name
);
3964 bfd_set_error_program_name (program_name
);
3966 START_PROGRESS (program_name
, 0);
3968 expandargv (&argc
, &argv
);
3970 if (bfd_init () != BFD_INIT_MAGIC
)
3971 fatal (_("fatal error: libbfd ABI mismatch"));
3972 set_default_bfd_target ();
3974 while ((c
= getopt_long (argc
, argv
,
3975 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3976 long_options
, (int *) 0))
3982 break; /* We've been given a long option. */
3989 if (disassembler_options
)
3990 /* Ignore potential memory leak for now. */
3991 options
= concat (disassembler_options
, ",",
3992 optarg
, (const char *) NULL
);
3995 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4002 display_file_offsets
= TRUE
;
4005 with_line_numbers
= TRUE
;
4014 enum demangling_styles style
;
4016 style
= cplus_demangle_name_to_style (optarg
);
4017 if (style
== unknown_demangling
)
4018 fatal (_("unknown demangling style `%s'"),
4021 cplus_demangle_set_style (style
);
4024 case OPTION_RECURSE_LIMIT
:
4025 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4027 case OPTION_NO_RECURSE_LIMIT
:
4028 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4031 do_wide
= wide_output
= TRUE
;
4033 case OPTION_ADJUST_VMA
:
4034 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4036 case OPTION_START_ADDRESS
:
4037 start_address
= parse_vma (optarg
, "--start-address");
4038 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4039 fatal (_("error: the start address should be before the end address"));
4041 case OPTION_STOP_ADDRESS
:
4042 stop_address
= parse_vma (optarg
, "--stop-address");
4043 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4044 fatal (_("error: the stop address should be after the start address"));
4048 prefix_length
= strlen (prefix
);
4049 /* Remove an unnecessary trailing '/' */
4050 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4053 case OPTION_PREFIX_STRIP
:
4054 prefix_strip
= atoi (optarg
);
4055 if (prefix_strip
< 0)
4056 fatal (_("error: prefix strip must be non-negative"));
4058 case OPTION_INSN_WIDTH
:
4059 insn_width
= strtoul (optarg
, NULL
, 0);
4060 if (insn_width
<= 0)
4061 fatal (_("error: instruction width must be positive"));
4063 case OPTION_INLINES
:
4064 unwind_inlines
= TRUE
;
4067 if (strcmp (optarg
, "B") == 0)
4068 endian
= BFD_ENDIAN_BIG
;
4069 else if (strcmp (optarg
, "L") == 0)
4070 endian
= BFD_ENDIAN_LITTLE
;
4073 nonfatal (_("unrecognized -E option"));
4078 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4079 endian
= BFD_ENDIAN_BIG
;
4080 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4081 endian
= BFD_ENDIAN_LITTLE
;
4084 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4091 dump_file_header
= TRUE
;
4095 formats_info
= TRUE
;
4099 add_include_path (optarg
);
4102 dump_private_headers
= TRUE
;
4106 dump_private_options
= optarg
;
4110 dump_private_headers
= TRUE
;
4112 dump_reloc_info
= TRUE
;
4113 dump_file_header
= TRUE
;
4114 dump_ar_hdrs
= TRUE
;
4115 dump_section_headers
= TRUE
;
4123 dump_dynamic_symtab
= TRUE
;
4129 disasm_sym
= optarg
;
4132 disassemble_zeroes
= TRUE
;
4136 disassemble_all
= TRUE
;
4141 with_source_code
= TRUE
;
4150 dump_debugging_tags
= 1;
4155 dump_dwarf_section_info
= TRUE
;
4158 dwarf_select_sections_by_letters (optarg
);
4160 dwarf_select_sections_all ();
4163 dump_dwarf_section_info
= TRUE
;
4166 dwarf_select_sections_by_names (optarg
);
4168 dwarf_select_sections_all ();
4170 case OPTION_DWARF_DEPTH
:
4173 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4176 case OPTION_DWARF_START
:
4179 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4180 suppress_bfd_header
= 1;
4183 case OPTION_DWARF_CHECK
:
4187 dump_stab_section_info
= TRUE
;
4191 dump_section_contents
= TRUE
;
4195 dump_reloc_info
= TRUE
;
4199 dump_dynamic_reloc_info
= TRUE
;
4203 dump_ar_hdrs
= TRUE
;
4207 dump_section_headers
= TRUE
;
4212 show_version
= TRUE
;
4218 /* No need to set seenflag or to break - usage() does not return. */
4225 print_version ("objdump");
4231 exit_status
= display_info ();
4235 display_file ("a.out", target
, TRUE
);
4237 for (; optind
< argc
;)
4239 display_file (argv
[optind
], target
, optind
== argc
- 1);
4246 END_PROGRESS (program_name
);