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