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. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status = 0;
81 static char *default_target = NULL; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version = 0; /* Show the version number. */
86 static int dump_section_contents; /* -s */
87 static int dump_section_headers; /* -h */
88 static bfd_boolean dump_file_header; /* -f */
89 static int dump_symtab; /* -t */
90 static int dump_dynamic_symtab; /* -T */
91 static int dump_reloc_info; /* -r */
92 static int dump_dynamic_reloc_info; /* -R */
93 static int dump_ar_hdrs; /* -a */
94 static int dump_private_headers; /* -p */
95 static char *dump_private_options; /* -P */
96 static int prefix_addresses; /* --prefix-addresses */
97 static int with_line_numbers; /* -l */
98 static bfd_boolean with_source_code; /* -S */
99 static int show_raw_insn; /* --show-raw-insn */
100 static int dump_dwarf_section_info; /* --dwarf */
101 static int dump_stab_section_info; /* --stabs */
102 static int dump_ctf_section_info; /* --ctf */
103 static char *dump_ctf_section_name;
104 static char *dump_ctf_parent_name; /* --ctf-parent */
105 static int do_demangle; /* -C, --demangle */
106 static bfd_boolean disassemble; /* -d */
107 static bfd_boolean disassemble_all; /* -D */
108 static int disassemble_zeroes; /* --disassemble-zeroes */
109 static bfd_boolean formats_info; /* -i */
110 static int wide_output; /* -w */
111 static int insn_width; /* --insn-width */
112 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
113 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
114 static int dump_debugging; /* --debugging */
115 static int dump_debugging_tags; /* --debugging-tags */
116 static int suppress_bfd_header;
117 static int dump_special_syms = 0; /* --special-syms */
118 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
119 static int file_start_context = 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets;/* -F */
121 static const char *prefix; /* --prefix */
122 static int prefix_strip; /* --prefix-strip */
123 static size_t prefix_length;
124 static bfd_boolean unwind_inlines; /* --inlines. */
125 static const char * disasm_sym; /* Disassembly start symbol. */
126 static const char * source_comment; /* --source_comment. */
128 static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
130 /* A structure to record the sections mentioned in -j switches. */
133 const char * name; /* The name of the section. */
134 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
135 struct only * next; /* Pointer to the next structure in the list. */
137 /* Pointer to an array of 'only' structures.
138 This pointer is NULL if the -j switch has not been used. */
139 static struct only * only_list = NULL;
141 /* Variables for handling include file path table. */
142 static const char **include_paths;
143 static int include_path_count;
145 /* Extra info to pass to the section disassembler and address printing
147 struct objdump_disasm_info
151 bfd_boolean require_sec;
152 arelent ** dynrelbuf;
154 disassembler_ftype disassemble_fn;
159 /* Architecture to disassemble for, or default if NULL. */
160 static char *machine = NULL;
162 /* Target specific options to the disassembler. */
163 static char *disassembler_options = NULL;
165 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
166 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
168 /* The symbol table. */
169 static asymbol **syms;
171 /* Number of symbols in `syms'. */
172 static long symcount = 0;
174 /* The sorted symbol table. */
175 static asymbol **sorted_syms;
177 /* Number of symbols in `sorted_syms'. */
178 static long sorted_symcount = 0;
180 /* The dynamic symbol table. */
181 static asymbol **dynsyms;
183 /* The synthetic symbol table. */
184 static asymbol *synthsyms;
185 static long synthcount = 0;
187 /* Number of symbols in `dynsyms'. */
188 static long dynsymcount = 0;
190 static bfd_byte *stabs;
191 static bfd_size_type stab_size;
193 static bfd_byte *strtab;
194 static bfd_size_type stabstr_size;
196 /* Handlers for -P/--private. */
197 static const struct objdump_private_desc * const objdump_private_vectors[] =
199 OBJDUMP_PRIVATE_VECTORS
203 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
205 usage (FILE *stream, int status)
207 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
208 fprintf (stream, _(" Display information from object <file(s)>.\n"));
209 fprintf (stream, _(" At least one of the following switches must be given:\n"));
210 fprintf (stream, _("\
211 -a, --archive-headers Display archive header information\n\
212 -f, --file-headers Display the contents of the overall file header\n\
213 -p, --private-headers Display object format specific file header contents\n\
214 -P, --private=OPT,OPT... Display object format specific contents\n\
215 -h, --[section-]headers Display the contents of the section headers\n\
216 -x, --all-headers Display the contents of all headers\n\
217 -d, --disassemble Display assembler contents of executable sections\n\
218 -D, --disassemble-all Display assembler contents of all sections\n\
219 --disassemble=<sym> Display assembler contents from <sym>\n\
220 -S, --source Intermix source code with disassembly\n\
221 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
222 -s, --full-contents Display the full contents of all sections requested\n\
223 -g, --debugging Display debug information in object file\n\
224 -e, --debugging-tags Display debug information using ctags style\n\
225 -G, --stabs Display (in raw form) any STABS info in the file\n\
226 -W[lLiaprmfFsoRtUuTgAckK] or\n\
227 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
228 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
229 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
230 =addr,=cu_index,=links,=follow-links]\n\
231 Display DWARF info in the file\n\
232 --ctf=SECTION Display CTF info from SECTION\n\
233 -t, --syms Display the contents of the symbol table(s)\n\
234 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
235 -r, --reloc Display the relocation entries in the file\n\
236 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
237 @<file> Read options from <file>\n\
238 -v, --version Display this program's version number\n\
239 -i, --info List object formats and architectures supported\n\
240 -H, --help Display this information\n\
244 const struct objdump_private_desc * const *desc;
246 fprintf (stream, _("\n The following switches are optional:\n"));
247 fprintf (stream, _("\
248 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
249 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
250 -j, --section=NAME Only display information for section NAME\n\
251 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
252 -EB --endian=big Assume big endian format when disassembling\n\
253 -EL --endian=little Assume little endian format when disassembling\n\
254 --file-start-context Include context from start of file (with -S)\n\
255 -I, --include=DIR Add DIR to search list for source files\n\
256 -l, --line-numbers Include line numbers and filenames in output\n\
257 -F, --file-offsets Include file offsets when displaying information\n\
258 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
259 The STYLE, if specified, can be `auto', `gnu',\n\
260 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
262 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
263 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
264 -w, --wide Format output for more than 80 columns\n\
265 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
266 --start-address=ADDR Only process data whose address is >= ADDR\n\
267 --stop-address=ADDR Only process data whose address is <= ADDR\n\
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
270 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
271 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
272 --special-syms Include special symbols in symbol dumps\n\
273 --inlines Print all inlines for source line (with -l)\n\
274 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
275 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
276 fprintf (stream, _("\
277 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
278 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
280 --dwarf-check Make additional dwarf internal consistency checks.\
282 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
283 list_supported_targets (program_name, stream);
284 list_supported_architectures (program_name, stream);
286 disassembler_usage (stream);
288 if (objdump_private_vectors[0] != NULL)
291 _("\nOptions supported for -P/--private switch:\n"));
292 for (desc = objdump_private_vectors; *desc != NULL; desc++)
293 (*desc)->help (stream);
296 if (REPORT_BUGS_TO[0] && status == 0)
297 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
301 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
305 OPTION_START_ADDRESS,
315 OPTION_RECURSE_LIMIT,
316 OPTION_NO_RECURSE_LIMIT,
318 OPTION_SOURCE_COMMENT,
323 static struct option long_options[]=
325 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
326 {"all-headers", no_argument, NULL, 'x'},
327 {"private-headers", no_argument, NULL, 'p'},
328 {"private", required_argument, NULL, 'P'},
329 {"architecture", required_argument, NULL, 'm'},
330 {"archive-headers", no_argument, NULL, 'a'},
331 {"debugging", no_argument, NULL, 'g'},
332 {"debugging-tags", no_argument, NULL, 'e'},
333 {"demangle", optional_argument, NULL, 'C'},
334 {"disassemble", optional_argument, NULL, 'd'},
335 {"disassemble-all", no_argument, NULL, 'D'},
336 {"disassembler-options", required_argument, NULL, 'M'},
337 {"disassemble-zeroes", no_argument, NULL, 'z'},
338 {"dynamic-reloc", no_argument, NULL, 'R'},
339 {"dynamic-syms", no_argument, NULL, 'T'},
340 {"endian", required_argument, NULL, OPTION_ENDIAN},
341 {"file-headers", no_argument, NULL, 'f'},
342 {"file-offsets", no_argument, NULL, 'F'},
343 {"file-start-context", no_argument, &file_start_context, 1},
344 {"full-contents", no_argument, NULL, 's'},
345 {"headers", no_argument, NULL, 'h'},
346 {"help", no_argument, NULL, 'H'},
347 {"info", no_argument, NULL, 'i'},
348 {"line-numbers", no_argument, NULL, 'l'},
349 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
350 {"prefix-addresses", no_argument, &prefix_addresses, 1},
351 {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
352 {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
353 {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
354 {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
355 {"reloc", no_argument, NULL, 'r'},
356 {"section", required_argument, NULL, 'j'},
357 {"section-headers", no_argument, NULL, 'h'},
358 {"show-raw-insn", no_argument, &show_raw_insn, 1},
359 {"source", no_argument, NULL, 'S'},
360 {"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
361 {"special-syms", no_argument, &dump_special_syms, 1},
362 {"include", required_argument, NULL, 'I'},
363 {"dwarf", optional_argument, NULL, OPTION_DWARF},
364 {"ctf", required_argument, NULL, OPTION_CTF},
365 {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
366 {"stabs", no_argument, NULL, 'G'},
367 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
368 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
369 {"syms", no_argument, NULL, 't'},
370 {"target", required_argument, NULL, 'b'},
371 {"version", no_argument, NULL, 'V'},
372 {"wide", no_argument, NULL, 'w'},
373 {"prefix", required_argument, NULL, OPTION_PREFIX},
374 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
375 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
376 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
377 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
378 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
379 {"inlines", no_argument, 0, OPTION_INLINES},
380 {0, no_argument, 0, 0}
384 nonfatal (const char *msg)
390 /* Returns a version of IN with any control characters
391 replaced by escape sequences. Uses a static buffer
395 sanitize_string (const char * in)
397 static char * buffer = NULL;
398 static size_t buffer_len = 0;
399 const char * original = in;
406 /* See if any conversion is necessary. In the majority
407 of cases it will not be needed. */
420 /* Copy the input, translating as needed. */
422 if (buffer_len < (strlen (in) * 2))
424 free ((void *) buffer);
425 buffer_len = strlen (in) * 2;
426 buffer = xmalloc (buffer_len + 1);
452 /* Returns TRUE if the specified section should be dumped. */
455 process_section_p (asection * section)
459 if (only_list == NULL)
462 for (only = only_list; only; only = only->next)
463 if (strcmp (only->name, section->name) == 0)
472 /* Add an entry to the 'only' list. */
475 add_only (char * name)
479 /* First check to make sure that we do not
480 already have an entry for this name. */
481 for (only = only_list; only; only = only->next)
482 if (strcmp (only->name, name) == 0)
485 only = xmalloc (sizeof * only);
488 only->next = only_list;
492 /* Release the memory used by the 'only' list.
493 PR 11225: Issue a warning message for unseen sections.
494 Only do this if none of the sections were seen. This is mainly to support
495 tools like the GAS testsuite where an object file is dumped with a list of
496 generic section names known to be present in a range of different file
500 free_only_list (void)
502 bfd_boolean at_least_one_seen = FALSE;
506 if (only_list == NULL)
509 for (only = only_list; only; only = only->next)
512 at_least_one_seen = TRUE;
516 for (only = only_list; only; only = next)
518 if (! at_least_one_seen)
520 non_fatal (_("section '%s' mentioned in a -j option, "
521 "but not found in any input file"),
532 dump_section_header (bfd *abfd, asection *section, void *data)
535 unsigned int opb = bfd_octets_per_byte (abfd);
536 int longest_section_name = *((int *) data);
538 /* Ignore linker created section. See elfNN_ia64_object_p in
540 if (section->flags & SEC_LINKER_CREATED)
543 /* PR 10413: Skip sections that we are ignoring. */
544 if (! process_section_p (section))
547 printf ("%3d %-*s %08lx ", section->index, longest_section_name,
548 sanitize_string (bfd_get_section_name (abfd, section)),
549 (unsigned long) bfd_section_size (abfd, section) / opb);
550 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
552 bfd_printf_vma (abfd, section->lma);
553 printf (" %08lx 2**%u", (unsigned long) section->filepos,
554 bfd_get_section_alignment (abfd, section));
560 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
562 PF (SEC_HAS_CONTENTS, "CONTENTS");
563 PF (SEC_ALLOC, "ALLOC");
564 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
565 PF (SEC_LOAD, "LOAD");
566 PF (SEC_RELOC, "RELOC");
567 PF (SEC_READONLY, "READONLY");
568 PF (SEC_CODE, "CODE");
569 PF (SEC_DATA, "DATA");
571 PF (SEC_DEBUGGING, "DEBUGGING");
572 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
573 PF (SEC_EXCLUDE, "EXCLUDE");
574 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
575 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
577 PF (SEC_TIC54X_BLOCK, "BLOCK");
578 PF (SEC_TIC54X_CLINK, "CLINK");
580 PF (SEC_SMALL_DATA, "SMALL_DATA");
581 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
583 PF (SEC_COFF_SHARED, "SHARED");
584 PF (SEC_COFF_NOREAD, "NOREAD");
586 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
587 PF (SEC_ELF_PURECODE, "PURECODE");
588 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
589 PF (SEC_GROUP, "GROUP");
590 if (bfd_get_arch (abfd) == bfd_arch_mep)
592 PF (SEC_MEP_VLIW, "VLIW");
595 if ((section->flags & SEC_LINK_ONCE) != 0)
598 struct coff_comdat_info *comdat;
600 switch (section->flags & SEC_LINK_DUPLICATES)
604 case SEC_LINK_DUPLICATES_DISCARD:
605 ls = "LINK_ONCE_DISCARD";
607 case SEC_LINK_DUPLICATES_ONE_ONLY:
608 ls = "LINK_ONCE_ONE_ONLY";
610 case SEC_LINK_DUPLICATES_SAME_SIZE:
611 ls = "LINK_ONCE_SAME_SIZE";
613 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
614 ls = "LINK_ONCE_SAME_CONTENTS";
617 printf ("%s%s", comma, ls);
619 comdat = bfd_coff_get_comdat_section (abfd, section);
621 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
630 /* Called on each SECTION in ABFD, update the int variable pointed to by
631 DATA which contains the string length of the longest section name. */
634 find_longest_section_name (bfd *abfd, asection *section, void *data)
636 int *longest_so_far = (int *) data;
640 /* Ignore linker created section. */
641 if (section->flags & SEC_LINKER_CREATED)
644 /* Skip sections that we are ignoring. */
645 if (! process_section_p (section))
648 name = bfd_get_section_name (abfd, section);
649 len = (int) strlen (name);
650 if (len > *longest_so_far)
651 *longest_so_far = len;
655 dump_headers (bfd *abfd)
657 /* The default width of 13 is just an arbitrary choice. */
658 int max_section_name_length = 13;
664 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
665 if (bfd_get_arch_size (abfd) == 32)
671 printf (_("Sections:\n"));
674 bfd_map_over_sections (abfd, find_longest_section_name,
675 &max_section_name_length);
677 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
678 max_section_name_length, "Name",
679 bfd_vma_width, "VMA",
680 bfd_vma_width, "LMA");
683 printf (_(" Flags"));
686 bfd_map_over_sections (abfd, dump_section_header,
687 &max_section_name_length);
691 slurp_symtab (bfd *abfd)
696 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
702 storage = bfd_get_symtab_upper_bound (abfd);
705 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
706 bfd_fatal (_("error message was"));
710 off_t filesize = bfd_get_file_size (abfd);
714 && filesize < storage
715 /* The MMO file format supports its own special compression
716 technique, so its sections can be larger than the file size. */
717 && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
719 bfd_nonfatal_message (bfd_get_filename (abfd), abfd, NULL,
720 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
721 storage, (long) filesize);
727 sy = (asymbol **) xmalloc (storage);
730 symcount = bfd_canonicalize_symtab (abfd, sy);
732 bfd_fatal (bfd_get_filename (abfd));
736 /* Read in the dynamic symbols. */
739 slurp_dynamic_symtab (bfd *abfd)
744 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
747 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
749 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
755 bfd_fatal (bfd_get_filename (abfd));
758 sy = (asymbol **) xmalloc (storage);
760 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
762 bfd_fatal (bfd_get_filename (abfd));
766 /* Some symbol names are significant and should be kept in the
767 table of sorted symbol names, even if they are marked as
768 debugging/section symbols. */
771 is_significant_symbol_name (const char * name)
773 return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
776 /* Filter out (in place) symbols that are useless for disassembly.
777 COUNT is the number of elements in SYMBOLS.
778 Return the number of useful symbols. */
781 remove_useless_symbols (asymbol **symbols, long count)
783 asymbol **in_ptr = symbols, **out_ptr = symbols;
787 asymbol *sym = *in_ptr++;
789 if (sym->name == NULL || sym->name[0] == '\0')
791 if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
792 && ! is_significant_symbol_name (sym->name))
794 if (bfd_is_und_section (sym->section)
795 || bfd_is_com_section (sym->section))
800 return out_ptr - symbols;
803 /* Sort symbols into value order. */
806 compare_symbols (const void *ap, const void *bp)
808 const asymbol *a = * (const asymbol **) ap;
809 const asymbol *b = * (const asymbol **) bp;
819 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
821 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
824 if (a->section > b->section)
826 else if (a->section < b->section)
829 an = bfd_asymbol_name (a);
830 bn = bfd_asymbol_name (b);
834 /* The symbols gnu_compiled and gcc2_compiled convey no real
835 information, so put them after other symbols with the same value. */
836 af = (strstr (an, "gnu_compiled") != NULL
837 || strstr (an, "gcc2_compiled") != NULL);
838 bf = (strstr (bn, "gnu_compiled") != NULL
839 || strstr (bn, "gcc2_compiled") != NULL);
846 /* We use a heuristic for the file name, to try to sort it after
847 more useful symbols. It may not work on non Unix systems, but it
848 doesn't really matter; the only difference is precisely which
849 symbol names get printed. */
851 #define file_symbol(s, sn, snl) \
852 (((s)->flags & BSF_FILE) != 0 \
853 || ((sn)[(snl) - 2] == '.' \
854 && ((sn)[(snl) - 1] == 'o' \
855 || (sn)[(snl) - 1] == 'a')))
857 af = file_symbol (a, an, anl);
858 bf = file_symbol (b, bn, bnl);
865 /* Try to sort global symbols before local symbols before function
866 symbols before debugging symbols. */
871 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
873 if ((aflags & BSF_DEBUGGING) != 0)
878 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
880 if ((aflags & BSF_FUNCTION) != 0)
885 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
887 if ((aflags & BSF_LOCAL) != 0)
892 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
894 if ((aflags & BSF_GLOBAL) != 0)
900 if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
901 && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
906 if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
907 asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
909 if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
910 bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
912 return asz > bsz ? -1 : 1;
915 /* Symbols that start with '.' might be section names, so sort them
916 after symbols that don't start with '.'. */
917 if (an[0] == '.' && bn[0] != '.')
919 if (an[0] != '.' && bn[0] == '.')
922 /* Finally, if we can't distinguish them in any other way, try to
923 get consistent results by sorting the symbols by name. */
924 return strcmp (an, bn);
927 /* Sort relocs into address order. */
930 compare_relocs (const void *ap, const void *bp)
932 const arelent *a = * (const arelent **) ap;
933 const arelent *b = * (const arelent **) bp;
935 if (a->address > b->address)
937 else if (a->address < b->address)
940 /* So that associated relocations tied to the same address show up
941 in the correct order, we don't do any further sorting. */
950 /* Print an address (VMA) to the output stream in INFO.
951 If SKIP_ZEROES is TRUE, omit leading zeroes. */
954 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
955 bfd_boolean skip_zeroes)
959 struct objdump_disasm_info *aux;
961 aux = (struct objdump_disasm_info *) inf->application_data;
962 bfd_sprintf_vma (aux->abfd, buf, vma);
967 for (p = buf; *p == '0'; ++p)
972 (*inf->fprintf_func) (inf->stream, "%s", p);
975 /* Print the name of a symbol. */
978 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
982 const char *name, *version_string = NULL;
983 bfd_boolean hidden = FALSE;
986 name = bfd_asymbol_name (sym);
987 if (do_demangle && name[0] != '\0')
989 /* Demangle the name. */
990 alloc = bfd_demangle (abfd, name, demangle_flags);
995 if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
996 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
998 if (bfd_is_und_section (bfd_get_section (sym)))
1001 name = sanitize_string (name);
1005 (*inf->fprintf_func) (inf->stream, "%s", name);
1006 if (version_string && *version_string != '\0')
1007 (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
1012 printf ("%s", name);
1013 if (version_string && *version_string != '\0')
1014 printf (hidden ? "@%s" : "@@%s", version_string);
1021 static inline bfd_boolean
1022 sym_ok (bfd_boolean want_section,
1023 bfd * abfd ATTRIBUTE_UNUSED,
1026 struct disassemble_info * inf)
1030 /* Note - we cannot just compare section pointers because they could
1031 be different, but the same... Ie the symbol that we are trying to
1032 find could have come from a separate debug info file. Under such
1033 circumstances the symbol will be associated with a section in the
1034 debug info file, whilst the section we want is in a normal file.
1035 So the section pointers will be different, but the section names
1036 will be the same. */
1037 if (strcmp (bfd_section_name (abfd, sorted_syms[place]->section),
1038 bfd_section_name (abfd, sec)) != 0)
1042 return inf->symbol_is_valid (sorted_syms[place], inf);
1045 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1046 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1047 require the symbol to be in the section. Returns NULL if there is no
1048 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1049 of the symbol in sorted_syms. */
1052 find_symbol_for_address (bfd_vma vma,
1053 struct disassemble_info *inf,
1056 /* @@ Would it speed things up to cache the last two symbols returned,
1057 and maybe their address ranges? For many processors, only one memory
1058 operand can be present at a time, so the 2-entry cache wouldn't be
1059 constantly churned by code doing heavy memory accesses. */
1061 /* Indices in `sorted_syms'. */
1063 long max_count = sorted_symcount;
1065 struct objdump_disasm_info *aux;
1069 bfd_boolean want_section;
1072 if (sorted_symcount < 1)
1075 aux = (struct objdump_disasm_info *) inf->application_data;
1078 opb = inf->octets_per_byte;
1080 /* Perform a binary search looking for the closest symbol to the
1081 required value. We are searching the range (min, max_count]. */
1082 while (min + 1 < max_count)
1086 thisplace = (max_count + min) / 2;
1087 sym = sorted_syms[thisplace];
1089 if (bfd_asymbol_value (sym) > vma)
1090 max_count = thisplace;
1091 else if (bfd_asymbol_value (sym) < vma)
1100 /* The symbol we want is now in min, the low end of the range we
1101 were searching. If there are several symbols with the same
1102 value, we want the first (non-section/non-debugging) one. */
1104 while (thisplace > 0
1105 && (bfd_asymbol_value (sorted_syms[thisplace])
1106 == bfd_asymbol_value (sorted_syms[thisplace - 1]))
1107 && ((sorted_syms[thisplace - 1]->flags
1108 & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
1112 /* Prefer a symbol in the current section if we have multple symbols
1113 with the same value, as can occur with overlays or zero size
1116 while (min < max_count
1117 && (bfd_asymbol_value (sorted_syms[min])
1118 == bfd_asymbol_value (sorted_syms[thisplace])))
1120 if (sym_ok (TRUE, abfd, min, sec, inf))
1127 return sorted_syms[thisplace];
1132 /* If the file is relocatable, and the symbol could be from this
1133 section, prefer a symbol from this section over symbols from
1134 others, even if the other symbol's value might be closer.
1136 Note that this may be wrong for some symbol references if the
1137 sections have overlapping memory ranges, but in that case there's
1138 no way to tell what's desired without looking at the relocation
1141 Also give the target a chance to reject symbols. */
1142 want_section = (aux->require_sec
1143 || ((abfd->flags & HAS_RELOC) != 0
1144 && vma >= bfd_get_section_vma (abfd, sec)
1145 && vma < (bfd_get_section_vma (abfd, sec)
1146 + bfd_section_size (abfd, sec) / opb)));
1148 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1151 long newplace = sorted_symcount;
1153 for (i = min - 1; i >= 0; i--)
1155 if (sym_ok (want_section, abfd, i, sec, inf))
1157 if (newplace == sorted_symcount)
1160 if (bfd_asymbol_value (sorted_syms[i])
1161 != bfd_asymbol_value (sorted_syms[newplace]))
1164 /* Remember this symbol and keep searching until we reach
1165 an earlier address. */
1170 if (newplace != sorted_symcount)
1171 thisplace = newplace;
1174 /* We didn't find a good symbol with a smaller value.
1175 Look for one with a larger value. */
1176 for (i = thisplace + 1; i < sorted_symcount; i++)
1178 if (sym_ok (want_section, abfd, i, sec, inf))
1186 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1187 /* There is no suitable symbol. */
1191 /* If we have not found an exact match for the specified address
1192 and we have dynamic relocations available, then we can produce
1193 a better result by matching a relocation to the address and
1194 using the symbol associated with that relocation. */
1195 rel_count = aux->dynrelcount;
1197 && sorted_syms[thisplace]->value != vma
1199 && aux->dynrelbuf != NULL
1200 && aux->dynrelbuf[0]->address <= vma
1201 && aux->dynrelbuf[rel_count - 1]->address >= vma
1202 /* If we have matched a synthetic symbol, then stick with that. */
1203 && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
1206 arelent ** rel_high;
1208 rel_low = aux->dynrelbuf;
1209 rel_high = rel_low + rel_count - 1;
1210 while (rel_low <= rel_high)
1212 arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
1213 arelent * rel = *rel_mid;
1215 if (rel->address == vma)
1217 /* Absolute relocations do not provide a more helpful
1218 symbolic address. Find a non-absolute relocation
1219 with the same address. */
1220 arelent **rel_vma = rel_mid;
1222 rel_mid >= rel_low && rel_mid[0]->address == vma;
1226 for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
1230 if (rel->sym_ptr_ptr != NULL
1231 && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
1234 * place = thisplace;
1235 return * rel->sym_ptr_ptr;
1241 if (vma < rel->address)
1243 else if (vma >= rel_mid[1]->address)
1244 rel_low = rel_mid + 1;
1253 return sorted_syms[thisplace];
1256 /* Print an address and the offset to the nearest symbol. */
1259 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
1260 bfd_vma vma, struct disassemble_info *inf,
1261 bfd_boolean skip_zeroes)
1263 objdump_print_value (vma, inf, skip_zeroes);
1269 (*inf->fprintf_func) (inf->stream, " <%s",
1270 sanitize_string (bfd_get_section_name (abfd, sec)));
1271 secaddr = bfd_get_section_vma (abfd, sec);
1274 (*inf->fprintf_func) (inf->stream, "-0x");
1275 objdump_print_value (secaddr - vma, inf, TRUE);
1277 else if (vma > secaddr)
1279 (*inf->fprintf_func) (inf->stream, "+0x");
1280 objdump_print_value (vma - secaddr, inf, TRUE);
1282 (*inf->fprintf_func) (inf->stream, ">");
1286 (*inf->fprintf_func) (inf->stream, " <");
1288 objdump_print_symname (abfd, inf, sym);
1290 if (bfd_asymbol_value (sym) == vma)
1292 /* Undefined symbols in an executables and dynamic objects do not have
1293 a value associated with them, so it does not make sense to display
1294 an offset relative to them. Normally we would not be provided with
1295 this kind of symbol, but the target backend might choose to do so,
1296 and the code in find_symbol_for_address might return an as yet
1297 unresolved symbol associated with a dynamic reloc. */
1298 else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
1299 && bfd_is_und_section (sym->section))
1301 else if (bfd_asymbol_value (sym) > vma)
1303 (*inf->fprintf_func) (inf->stream, "-0x");
1304 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1306 else if (vma > bfd_asymbol_value (sym))
1308 (*inf->fprintf_func) (inf->stream, "+0x");
1309 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1312 (*inf->fprintf_func) (inf->stream, ">");
1315 if (display_file_offsets)
1316 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1317 (long int)(sec->filepos + (vma - sec->vma)));
1320 /* Print an address (VMA), symbolically if possible.
1321 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1324 objdump_print_addr (bfd_vma vma,
1325 struct disassemble_info *inf,
1326 bfd_boolean skip_zeroes)
1328 struct objdump_disasm_info *aux;
1329 asymbol *sym = NULL;
1330 bfd_boolean skip_find = FALSE;
1332 aux = (struct objdump_disasm_info *) inf->application_data;
1334 if (sorted_symcount < 1)
1336 (*inf->fprintf_func) (inf->stream, "0x");
1337 objdump_print_value (vma, inf, skip_zeroes);
1339 if (display_file_offsets)
1340 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1341 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1345 if (aux->reloc != NULL
1346 && aux->reloc->sym_ptr_ptr != NULL
1347 && * aux->reloc->sym_ptr_ptr != NULL)
1349 sym = * aux->reloc->sym_ptr_ptr;
1351 /* Adjust the vma to the reloc. */
1352 vma += bfd_asymbol_value (sym);
1354 if (bfd_is_und_section (bfd_get_section (sym)))
1359 sym = find_symbol_for_address (vma, inf, NULL);
1361 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1365 /* Print VMA to INFO. This function is passed to the disassembler
1369 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1371 objdump_print_addr (vma, inf, ! prefix_addresses);
1374 /* Determine if the given address has a symbol associated with it. */
1377 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1381 sym = find_symbol_for_address (vma, inf, NULL);
1383 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1386 /* Hold the last function name and the last line number we displayed
1387 in a disassembly. */
1389 static char *prev_functionname;
1390 static unsigned int prev_line;
1391 static unsigned int prev_discriminator;
1393 /* We keep a list of all files that we have seen when doing a
1394 disassembly with source, so that we know how much of the file to
1395 display. This can be important for inlined functions. */
1397 struct print_file_list
1399 struct print_file_list *next;
1400 const char *filename;
1401 const char *modname;
1404 const char **linemap;
1407 unsigned max_printed;
1411 static struct print_file_list *print_files;
1413 /* The number of preceding context lines to show when we start
1414 displaying a file for the first time. */
1416 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1418 /* Read a complete file into memory. */
1421 slurp_file (const char *fn, size_t *size, struct stat *fst)
1424 int ps = getpagesize ();
1428 int fd = open (fn, O_RDONLY | O_BINARY);
1432 if (fstat (fd, fst) < 0)
1437 *size = fst->st_size;
1439 msize = (*size + ps - 1) & ~(ps - 1);
1440 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1441 if (map != (char *) -1L)
1447 map = (const char *) malloc (*size);
1448 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1450 free ((void *) map);
1457 #define line_map_decrease 5
1459 /* Precompute array of lines for a mapped file. */
1461 static const char **
1462 index_file (const char *map, size_t size, unsigned int *maxline)
1464 const char *p, *lstart, *end;
1465 int chars_per_line = 45; /* First iteration will use 40. */
1466 unsigned int lineno;
1467 const char **linemap = NULL;
1468 unsigned long line_map_size = 0;
1474 for (p = map; p < end; p++)
1478 if (p + 1 < end && p[1] == '\r')
1481 else if (*p == '\r')
1483 if (p + 1 < end && p[1] == '\n')
1489 /* End of line found. */
1491 if (linemap == NULL || line_map_size < lineno + 1)
1493 unsigned long newsize;
1495 chars_per_line -= line_map_decrease;
1496 if (chars_per_line <= 1)
1498 line_map_size = size / chars_per_line + 1;
1499 if (line_map_size < lineno + 1)
1500 line_map_size = lineno + 1;
1501 newsize = line_map_size * sizeof (char *);
1502 linemap = (const char **) xrealloc (linemap, newsize);
1505 linemap[lineno++] = lstart;
1513 /* Tries to open MODNAME, and if successful adds a node to print_files
1514 linked list and returns that node. Returns NULL on failure. */
1516 static struct print_file_list *
1517 try_print_file_open (const char *origname, const char *modname, struct stat *fst)
1519 struct print_file_list *p;
1521 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1523 p->map = slurp_file (modname, &p->mapsize, fst);
1530 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1533 p->filename = origname;
1534 p->modname = modname;
1535 p->next = print_files;
1541 /* If the source file, as described in the symtab, is not found
1542 try to locate it in one of the paths specified with -I
1543 If found, add location to print_files linked list. */
1545 static struct print_file_list *
1546 update_source_path (const char *filename, bfd *abfd)
1548 struct print_file_list *p;
1553 p = try_print_file_open (filename, filename, &fst);
1556 if (include_path_count == 0)
1559 /* Get the name of the file. */
1560 fname = lbasename (filename);
1562 /* If file exists under a new path, we need to add it to the list
1563 so that show_line knows about it. */
1564 for (i = 0; i < include_path_count; i++)
1566 char *modname = concat (include_paths[i], "/", fname,
1569 p = try_print_file_open (filename, modname, &fst);
1579 long mtime = bfd_get_mtime (abfd);
1581 if (fst.st_mtime > mtime)
1582 warn (_("source file %s is more recent than object file\n"),
1589 /* Print a source file line. */
1592 print_line (struct print_file_list *p, unsigned int linenum)
1598 if (linenum >= p->maxline)
1600 l = p->linemap [linenum];
1601 if (source_comment != NULL && strlen (l) > 0)
1602 printf ("%s", source_comment);
1603 len = strcspn (l, "\n\r");
1604 /* Test fwrite return value to quiet glibc warning. */
1605 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1609 /* Print a range of source code lines. */
1612 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1616 while (start <= end)
1618 print_line (p, start);
1623 /* Show the line number, or the source line, in a disassembly
1627 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1629 const char *filename;
1630 const char *functionname;
1631 unsigned int linenumber;
1632 unsigned int discriminator;
1636 if (! with_line_numbers && ! with_source_code)
1639 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1640 &filename, &functionname,
1641 &linenumber, &discriminator))
1644 if (filename != NULL && *filename == '\0')
1646 if (functionname != NULL && *functionname == '\0')
1647 functionname = NULL;
1650 && IS_ABSOLUTE_PATH (filename)
1654 const char *fname = filename;
1656 path = xmalloc (prefix_length + PATH_MAX + 1);
1659 memcpy (path, prefix, prefix_length);
1660 path_up = path + prefix_length;
1662 /* Build relocated filename, stripping off leading directories
1663 from the initial filename if requested. */
1664 if (prefix_strip > 0)
1669 /* Skip selected directory levels. */
1670 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1671 if (IS_DIR_SEPARATOR(*s))
1678 /* Update complete filename. */
1679 strncpy (path_up, fname, PATH_MAX);
1680 path_up[PATH_MAX] = '\0';
1688 if (with_line_numbers)
1690 if (functionname != NULL
1691 && (prev_functionname == NULL
1692 || strcmp (functionname, prev_functionname) != 0))
1694 printf ("%s():\n", sanitize_string (functionname));
1698 && (linenumber != prev_line
1699 || discriminator != prev_discriminator))
1701 if (discriminator > 0)
1702 printf ("%s:%u (discriminator %u)\n",
1703 filename == NULL ? "???" : sanitize_string (filename),
1704 linenumber, discriminator);
1706 printf ("%s:%u\n", filename == NULL
1707 ? "???" : sanitize_string (filename),
1712 const char *filename2;
1713 const char *functionname2;
1716 while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
1719 printf ("inlined by %s:%u",
1720 sanitize_string (filename2), line2);
1721 printf (" (%s)\n", sanitize_string (functionname2));
1726 if (with_source_code
1730 struct print_file_list **pp, *p;
1733 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1734 if (filename_cmp ((*pp)->filename, filename) == 0)
1741 filename = xstrdup (filename);
1742 p = update_source_path (filename, abfd);
1745 if (p != NULL && linenumber != p->last_line)
1747 if (file_start_context && p->first)
1751 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1752 if (l >= linenumber)
1754 if (p->max_printed >= l)
1756 if (p->max_printed < linenumber)
1757 l = p->max_printed + 1;
1762 dump_lines (p, l, linenumber);
1763 if (p->max_printed < linenumber)
1764 p->max_printed = linenumber;
1765 p->last_line = linenumber;
1770 if (functionname != NULL
1771 && (prev_functionname == NULL
1772 || strcmp (functionname, prev_functionname) != 0))
1774 if (prev_functionname != NULL)
1775 free (prev_functionname);
1776 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1777 strcpy (prev_functionname, functionname);
1780 if (linenumber > 0 && linenumber != prev_line)
1781 prev_line = linenumber;
1783 if (discriminator != prev_discriminator)
1784 prev_discriminator = discriminator;
1790 /* Pseudo FILE object for strings. */
1798 /* sprintf to a "stream". */
1800 static int ATTRIBUTE_PRINTF_2
1801 objdump_sprintf (SFILE *f, const char *format, ...)
1808 size_t space = f->alloc - f->pos;
1810 va_start (args, format);
1811 n = vsnprintf (f->buffer + f->pos, space, format, args);
1817 f->alloc = (f->alloc + n) * 2;
1818 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1825 /* The number of zeroes we want to see before we start skipping them.
1826 The number is arbitrarily chosen. */
1828 #define DEFAULT_SKIP_ZEROES 8
1830 /* The number of zeroes to skip at the end of a section. If the
1831 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1832 SKIP_ZEROES, they will be disassembled. If there are fewer than
1833 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1834 attempt to avoid disassembling zeroes inserted by section
1837 #define DEFAULT_SKIP_ZEROES_AT_END 3
1839 /* Disassemble some data in memory between given values. */
1842 disassemble_bytes (struct disassemble_info * inf,
1843 disassembler_ftype disassemble_fn,
1846 bfd_vma start_offset,
1847 bfd_vma stop_offset,
1850 arelent ** relppend)
1852 struct objdump_disasm_info *aux;
1854 int octets_per_line;
1855 int skip_addr_chars;
1856 bfd_vma addr_offset;
1857 unsigned int opb = inf->octets_per_byte;
1858 unsigned int skip_zeroes = inf->skip_zeroes;
1859 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1863 aux = (struct objdump_disasm_info *) inf->application_data;
1867 sfile.buffer = (char *) xmalloc (sfile.alloc);
1871 octets_per_line = insn_width;
1873 octets_per_line = 4;
1875 octets_per_line = 16;
1877 /* Figure out how many characters to skip at the start of an
1878 address, to make the disassembly look nicer. We discard leading
1879 zeroes in chunks of 4, ensuring that there is always a leading
1881 skip_addr_chars = 0;
1882 if (! prefix_addresses)
1886 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1888 while (buf[skip_addr_chars] == '0')
1891 /* Don't discard zeros on overflow. */
1892 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1893 skip_addr_chars = 0;
1895 if (skip_addr_chars != 0)
1896 skip_addr_chars = (skip_addr_chars - 1) & -4;
1899 inf->insn_info_valid = 0;
1901 addr_offset = start_offset;
1902 while (addr_offset < stop_offset)
1905 bfd_boolean need_nl = FALSE;
1906 int previous_octets;
1908 /* Remember the length of the previous instruction. */
1909 previous_octets = octets;
1912 /* Make sure we don't use relocs from previous instructions. */
1915 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1917 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1920 if (! disassemble_zeroes
1921 && (inf->insn_info_valid == 0
1922 || inf->branch_delay_insns == 0)
1923 && (z - addr_offset * opb >= skip_zeroes
1924 || (z == stop_offset * opb &&
1925 z - addr_offset * opb < skip_zeroes_at_end)))
1927 /* If there are more nonzero octets to follow, we only skip
1928 zeroes in multiples of 4, to try to avoid running over
1929 the start of an instruction which happens to start with
1931 if (z != stop_offset * opb)
1932 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1934 octets = z - addr_offset * opb;
1936 /* If we are going to display more data, and we are displaying
1937 file offsets, then tell the user how many zeroes we skip
1938 and the file offset from where we resume dumping. */
1939 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1940 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1942 (unsigned long) (section->filepos
1943 + (addr_offset + (octets / opb))));
1953 if (with_line_numbers || with_source_code)
1954 show_line (aux->abfd, section, addr_offset);
1956 if (! prefix_addresses)
1960 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1961 for (s = buf + skip_addr_chars; *s == '0'; s++)
1965 printf ("%s:\t", buf + skip_addr_chars);
1969 aux->require_sec = TRUE;
1970 objdump_print_address (section->vma + addr_offset, inf);
1971 aux->require_sec = FALSE;
1978 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1979 inf->stream = &sfile;
1980 inf->bytes_per_line = 0;
1981 inf->bytes_per_chunk = 0;
1982 inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
1983 | (wide_output ? WIDE_OUTPUT : 0));
1985 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1987 if (inf->disassembler_needs_relocs
1988 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1989 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1990 && *relppp < relppend)
1992 bfd_signed_vma distance_to_rel;
1994 distance_to_rel = (**relppp)->address
1995 - (rel_offset + addr_offset);
1997 /* Check to see if the current reloc is associated with
1998 the instruction that we are about to disassemble. */
1999 if (distance_to_rel == 0
2000 /* FIXME: This is wrong. We are trying to catch
2001 relocs that are addressed part way through the
2002 current instruction, as might happen with a packed
2003 VLIW instruction. Unfortunately we do not know the
2004 length of the current instruction since we have not
2005 disassembled it yet. Instead we take a guess based
2006 upon the length of the previous instruction. The
2007 proper solution is to have a new target-specific
2008 disassembler function which just returns the length
2009 of an instruction at a given address without trying
2010 to display its disassembly. */
2011 || (distance_to_rel > 0
2012 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
2014 inf->flags |= INSN_HAS_RELOC;
2015 aux->reloc = **relppp;
2019 if (! disassemble_all
2020 && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2021 == (SEC_CODE | SEC_HAS_CONTENTS))
2022 /* Set a stop_vma so that the disassembler will not read
2023 beyond the next symbol. We assume that symbols appear on
2024 the boundaries between instructions. We only do this when
2025 disassembling code of course, and when -D is in effect. */
2026 inf->stop_vma = section->vma + stop_offset;
2028 inf->stop_offset = stop_offset;
2029 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
2032 inf->fprintf_func = (fprintf_ftype) fprintf;
2033 inf->stream = stdout;
2034 if (insn_width == 0 && inf->bytes_per_line != 0)
2035 octets_per_line = inf->bytes_per_line;
2036 if (octets < (int) opb)
2039 printf ("%s\n", sfile.buffer);
2042 non_fatal (_("disassemble_fn returned length %d"),
2053 octets = octets_per_line;
2054 if (addr_offset + octets / opb > stop_offset)
2055 octets = (stop_offset - addr_offset) * opb;
2057 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
2059 if (ISPRINT (data[j]))
2060 buf[j - addr_offset * opb] = data[j];
2062 buf[j - addr_offset * opb] = '.';
2064 buf[j - addr_offset * opb] = '\0';
2067 if (prefix_addresses
2069 : show_raw_insn >= 0)
2073 /* If ! prefix_addresses and ! wide_output, we print
2074 octets_per_line octets per line. */
2076 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
2077 pb = octets_per_line;
2079 if (inf->bytes_per_chunk)
2080 bpc = inf->bytes_per_chunk;
2084 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
2086 /* PR 21580: Check for a buffer ending early. */
2087 if (j + bpc <= stop_offset * opb)
2091 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2093 for (k = bpc - 1; k >= 0; k--)
2094 printf ("%02x", (unsigned) data[j + k]);
2098 for (k = 0; k < bpc; k++)
2099 printf ("%02x", (unsigned) data[j + k]);
2105 for (; pb < octets_per_line; pb += bpc)
2109 for (k = 0; k < bpc; k++)
2114 /* Separate raw data from instruction by extra space. */
2124 printf ("%s", sfile.buffer);
2126 if (prefix_addresses
2128 : show_raw_insn >= 0)
2136 j = addr_offset * opb + pb;
2138 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
2139 for (s = buf + skip_addr_chars; *s == '0'; s++)
2143 printf ("%s:\t", buf + skip_addr_chars);
2145 pb += octets_per_line;
2148 for (; j < addr_offset * opb + pb; j += bpc)
2150 /* PR 21619: Check for a buffer ending early. */
2151 if (j + bpc <= stop_offset * opb)
2155 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2157 for (k = bpc - 1; k >= 0; k--)
2158 printf ("%02x", (unsigned) data[j + k]);
2162 for (k = 0; k < bpc; k++)
2163 printf ("%02x", (unsigned) data[j + k]);
2177 while ((*relppp) < relppend
2178 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
2180 if (dump_reloc_info || dump_dynamic_reloc_info)
2191 objdump_print_value (section->vma - rel_offset + q->address,
2194 if (q->howto == NULL)
2195 printf (": *unknown*\t");
2196 else if (q->howto->name)
2197 printf (": %s\t", q->howto->name);
2199 printf (": %d\t", q->howto->type);
2201 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
2202 printf ("*unknown*");
2205 const char *sym_name;
2207 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
2208 if (sym_name != NULL && *sym_name != '\0')
2209 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
2214 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
2215 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
2216 if (sym_name == NULL || *sym_name == '\0')
2217 sym_name = "*unknown*";
2218 printf ("%s", sanitize_string (sym_name));
2224 bfd_signed_vma addend = q->addend;
2232 objdump_print_value (addend, inf, TRUE);
2244 addr_offset += octets / opb;
2247 free (sfile.buffer);
2251 disassemble_section (bfd *abfd, asection *section, void *inf)
2253 const struct elf_backend_data * bed;
2254 bfd_vma sign_adjust = 0;
2255 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
2256 struct objdump_disasm_info * paux;
2257 unsigned int opb = pinfo->octets_per_byte;
2258 bfd_byte * data = NULL;
2259 bfd_size_type datasize = 0;
2260 arelent ** rel_pp = NULL;
2261 arelent ** rel_ppstart = NULL;
2262 arelent ** rel_ppend;
2263 bfd_vma stop_offset;
2264 asymbol * sym = NULL;
2268 unsigned long addr_offset;
2269 bfd_boolean do_print;
2272 stop_offset_reached,
2277 /* Sections that do not contain machine
2278 code are not normally disassembled. */
2279 if (! disassemble_all
2280 && only_list == NULL
2281 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2282 != (SEC_CODE | SEC_HAS_CONTENTS)))
2285 if (! process_section_p (section))
2288 datasize = bfd_get_section_size (section);
2292 if (start_address == (bfd_vma) -1
2293 || start_address < section->vma)
2296 addr_offset = start_address - section->vma;
2298 if (stop_address == (bfd_vma) -1)
2299 stop_offset = datasize / opb;
2302 if (stop_address < section->vma)
2305 stop_offset = stop_address - section->vma;
2306 if (stop_offset > datasize / opb)
2307 stop_offset = datasize / opb;
2310 if (addr_offset >= stop_offset)
2313 /* Decide which set of relocs to use. Load them if necessary. */
2314 paux = (struct objdump_disasm_info *) pinfo->application_data;
2315 if (paux->dynrelbuf && dump_dynamic_reloc_info)
2317 rel_pp = paux->dynrelbuf;
2318 rel_count = paux->dynrelcount;
2319 /* Dynamic reloc addresses are absolute, non-dynamic are section
2320 relative. REL_OFFSET specifies the reloc address corresponding
2321 to the start of this section. */
2322 rel_offset = section->vma;
2330 if ((section->flags & SEC_RELOC) != 0
2331 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2335 relsize = bfd_get_reloc_upper_bound (abfd, section);
2337 bfd_fatal (bfd_get_filename (abfd));
2341 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2342 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2344 bfd_fatal (bfd_get_filename (abfd));
2346 /* Sort the relocs by address. */
2347 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2351 rel_ppend = rel_pp + rel_count;
2353 if (!bfd_malloc_and_get_section (abfd, section, &data))
2355 non_fatal (_("Reading section %s failed because: %s"),
2356 section->name, bfd_errmsg (bfd_get_error ()));
2360 paux->sec = section;
2361 pinfo->buffer = data;
2362 pinfo->buffer_vma = section->vma;
2363 pinfo->buffer_length = datasize;
2364 pinfo->section = section;
2366 /* Skip over the relocs belonging to addresses below the
2368 while (rel_pp < rel_ppend
2369 && (*rel_pp)->address < rel_offset + addr_offset)
2372 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
2374 /* Find the nearest symbol forwards from our current position. */
2375 paux->require_sec = TRUE;
2376 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2377 (struct disassemble_info *) inf,
2379 paux->require_sec = FALSE;
2381 /* PR 9774: If the target used signed addresses then we must make
2382 sure that we sign extend the value that we calculate for 'addr'
2383 in the loop below. */
2384 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2385 && (bed = get_elf_backend_data (abfd)) != NULL
2386 && bed->sign_extend_vma)
2387 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2389 /* Disassemble a block of instructions up to the address associated with
2390 the symbol we have just found. Then print the symbol and find the
2391 next symbol on. Repeat until we have disassembled the entire section
2392 or we have reached the end of the address range we are interested in. */
2393 do_print = paux->symbol == NULL;
2394 loop_until = stop_offset_reached;
2396 while (addr_offset < stop_offset)
2400 bfd_vma nextstop_offset;
2403 addr = section->vma + addr_offset;
2404 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2406 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2411 (x < sorted_symcount
2412 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2416 pinfo->symbols = sorted_syms + place;
2417 pinfo->num_symbols = x - place;
2418 pinfo->symtab_pos = place;
2422 pinfo->symbols = NULL;
2423 pinfo->num_symbols = 0;
2424 pinfo->symtab_pos = -1;
2427 /* If we are only disassembling from a specific symbol,
2428 check to see if we should start or stop displaying. */
2429 if (sym && paux->symbol)
2433 /* See if we should stop printing. */
2437 if (sym->flags & BSF_FUNCTION)
2441 case stop_offset_reached:
2442 /* Handled by the while loop. */
2446 /* FIXME: There is an implicit assumption here
2447 that the name of sym is different from
2449 if (! bfd_is_local_label (abfd, sym))
2456 const char * name = bfd_asymbol_name (sym);
2457 char * alloc = NULL;
2459 if (do_demangle && name[0] != '\0')
2461 /* Demangle the name. */
2462 alloc = bfd_demangle (abfd, name, demangle_flags);
2467 /* We are not currently printing. Check to see
2468 if the current symbol matches the requested symbol. */
2469 if (streq (name, paux->symbol))
2473 if (sym->flags & BSF_FUNCTION)
2475 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2476 && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
2478 /* Sym is a function symbol with a size associated
2479 with it. Turn on automatic disassembly for the
2480 next VALUE bytes. */
2481 stop_offset = addr_offset
2482 + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
2483 loop_until = stop_offset_reached;
2487 /* Otherwise we need to tell the loop heuristic to
2488 loop until the next function symbol is encountered. */
2489 loop_until = function_sym;
2494 /* Otherwise loop until the next symbol is encountered. */
2495 loop_until = next_sym;
2503 if (! prefix_addresses && do_print)
2505 pinfo->fprintf_func (pinfo->stream, "\n");
2506 objdump_print_addr_with_sym (abfd, section, sym, addr,
2508 pinfo->fprintf_func (pinfo->stream, ":\n");
2511 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2513 else if (sym == NULL)
2517 #define is_valid_next_sym(SYM) \
2518 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2519 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2520 && pinfo->symbol_is_valid (SYM, pinfo))
2522 /* Search forward for the next appropriate symbol in
2523 SECTION. Note that all the symbols are sorted
2524 together into one big array, and that some sections
2525 may have overlapping addresses. */
2526 while (place < sorted_symcount
2527 && ! is_valid_next_sym (sorted_syms [place]))
2530 if (place >= sorted_symcount)
2533 nextsym = sorted_syms[place];
2536 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2537 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2538 else if (nextsym == NULL)
2539 nextstop_offset = stop_offset;
2541 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2543 if (nextstop_offset > stop_offset
2544 || nextstop_offset <= addr_offset)
2545 nextstop_offset = stop_offset;
2547 /* If a symbol is explicitly marked as being an object
2548 rather than a function, just dump the bytes without
2549 disassembling them. */
2552 || sym->section != section
2553 || bfd_asymbol_value (sym) > addr
2554 || ((sym->flags & BSF_OBJECT) == 0
2555 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2557 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2559 || (sym->flags & BSF_FUNCTION) != 0)
2565 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2566 addr_offset, nextstop_offset,
2567 rel_offset, &rel_pp, rel_ppend);
2569 addr_offset = nextstop_offset;
2575 if (rel_ppstart != NULL)
2579 /* Disassemble the contents of an object file. */
2582 disassemble_data (bfd *abfd)
2584 struct disassemble_info disasm_info;
2585 struct objdump_disasm_info aux;
2589 prev_functionname = NULL;
2591 prev_discriminator = 0;
2593 /* We make a copy of syms to sort. We don't want to sort syms
2594 because that will screw up the relocs. */
2595 sorted_symcount = symcount ? symcount : dynsymcount;
2596 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2597 * sizeof (asymbol *));
2598 memcpy (sorted_syms, symcount ? syms : dynsyms,
2599 sorted_symcount * sizeof (asymbol *));
2601 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2603 for (i = 0; i < synthcount; ++i)
2605 sorted_syms[sorted_symcount] = synthsyms + i;
2609 /* Sort the symbols into section and symbol order. */
2610 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2612 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2614 disasm_info.application_data = (void *) &aux;
2616 aux.require_sec = FALSE;
2617 aux.dynrelbuf = NULL;
2618 aux.dynrelcount = 0;
2620 aux.symbol = disasm_sym;
2622 disasm_info.print_address_func = objdump_print_address;
2623 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2625 if (machine != NULL)
2627 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2630 fatal (_("can't use supplied machine %s"), machine);
2632 abfd->arch_info = inf;
2635 if (endian != BFD_ENDIAN_UNKNOWN)
2637 struct bfd_target *xvec;
2639 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2640 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2641 xvec->byteorder = endian;
2645 /* Use libopcodes to locate a suitable disassembler. */
2646 aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
2647 bfd_big_endian (abfd),
2648 bfd_get_mach (abfd), abfd);
2649 if (!aux.disassemble_fn)
2651 non_fatal (_("can't disassemble for architecture %s\n"),
2652 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2657 disasm_info.flavour = bfd_get_flavour (abfd);
2658 disasm_info.arch = bfd_get_arch (abfd);
2659 disasm_info.mach = bfd_get_mach (abfd);
2660 disasm_info.disassembler_options = disassembler_options;
2661 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2662 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2663 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2664 disasm_info.disassembler_needs_relocs = FALSE;
2666 if (bfd_big_endian (abfd))
2667 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2668 else if (bfd_little_endian (abfd))
2669 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2671 /* ??? Aborting here seems too drastic. We could default to big or little
2673 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2675 /* Allow the target to customize the info structure. */
2676 disassemble_init_for_target (& disasm_info);
2678 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2680 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2682 if (relsize < 0 && dump_dynamic_reloc_info)
2683 bfd_fatal (bfd_get_filename (abfd));
2687 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2688 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2691 if (aux.dynrelcount < 0)
2692 bfd_fatal (bfd_get_filename (abfd));
2694 /* Sort the relocs by address. */
2695 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2699 disasm_info.symtab = sorted_syms;
2700 disasm_info.symtab_size = sorted_symcount;
2702 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2704 if (aux.dynrelbuf != NULL)
2705 free (aux.dynrelbuf);
2710 load_specific_debug_section (enum dwarf_section_display_enum debug,
2711 asection *sec, void *file)
2713 struct dwarf_section *section = &debug_displays [debug].section;
2714 bfd *abfd = (bfd *) file;
2719 if (section->start != NULL)
2721 /* If it is already loaded, do nothing. */
2722 if (streq (section->filename, bfd_get_filename (abfd)))
2724 free (section->start);
2727 section->filename = bfd_get_filename (abfd);
2728 section->reloc_info = NULL;
2729 section->num_relocs = 0;
2730 section->address = bfd_get_section_vma (abfd, sec);
2731 section->user_data = sec;
2732 section->size = bfd_get_section_size (sec);
2733 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2734 alloced = amt = section->size + 1;
2735 if (alloced != amt || alloced == 0)
2737 section->start = NULL;
2738 free_debug_section (debug);
2739 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2740 sanitize_string (section->name),
2741 (unsigned long long) section->size);
2744 section->start = contents = malloc (alloced);
2745 if (section->start == NULL
2746 || !bfd_get_full_section_contents (abfd, sec, &contents))
2748 free_debug_section (debug);
2749 printf (_("\nCan't get contents for section '%s'.\n"),
2750 sanitize_string (section->name));
2753 /* Ensure any string section has a terminating NUL. */
2754 section->start[section->size] = 0;
2756 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
2757 && debug_displays [debug].relocate)
2762 bfd_cache_section_contents (sec, section->start);
2764 ret = bfd_simple_get_relocated_section_contents (abfd,
2771 free_debug_section (debug);
2772 printf (_("\nCan't get contents for section '%s'.\n"),
2773 sanitize_string (section->name));
2777 reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2780 unsigned long reloc_count;
2783 relocs = (arelent **) xmalloc (reloc_size);
2785 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2786 if (reloc_count == 0)
2790 section->reloc_info = relocs;
2791 section->num_relocs = reloc_count;
2800 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2805 if (dsec == NULL || dsec->reloc_info == NULL)
2808 relocs = (arelent **) dsec->reloc_info;
2810 for (; (rp = * relocs) != NULL; ++ relocs)
2811 if (rp->address == offset)
2818 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2820 struct dwarf_section *section = &debug_displays [debug].section;
2821 bfd *abfd = (bfd *) file;
2824 /* If it is already loaded, do nothing. */
2825 if (section->start != NULL)
2827 if (streq (section->filename, bfd_get_filename (abfd)))
2831 /* Locate the debug section. */
2832 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2834 section->name = section->uncompressed_name;
2837 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2839 section->name = section->compressed_name;
2844 return load_specific_debug_section (debug, sec, file);
2848 free_debug_section (enum dwarf_section_display_enum debug)
2850 struct dwarf_section *section = &debug_displays [debug].section;
2852 if (section->start == NULL)
2855 /* PR 17512: file: 0f67f69d. */
2856 if (section->user_data != NULL)
2858 asection * sec = (asection *) section->user_data;
2860 /* If we are freeing contents that are also pointed to by the BFD
2861 library's section structure then make sure to update those pointers
2862 too. Otherwise, the next time we try to load data for this section
2863 we can end up using a stale pointer. */
2864 if (section->start == sec->contents)
2866 sec->contents = NULL;
2867 sec->flags &= ~ SEC_IN_MEMORY;
2868 sec->compress_status = COMPRESS_SECTION_NONE;
2872 free ((char *) section->start);
2873 section->start = NULL;
2874 section->address = 0;
2879 close_debug_file (void * file)
2881 bfd * abfd = (bfd *) file;
2887 open_debug_file (const char * pathname)
2891 data = bfd_openr (pathname, NULL);
2895 if (! bfd_check_format (data, bfd_object))
2902 dump_dwarf_section (bfd *abfd, asection *section,
2903 void *arg ATTRIBUTE_UNUSED)
2905 const char *name = bfd_get_section_name (abfd, section);
2909 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2910 match = ".debug_info";
2914 for (i = 0; i < max; i++)
2915 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2916 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2917 && debug_displays [i].enabled != NULL
2918 && *debug_displays [i].enabled)
2920 struct dwarf_section *sec = &debug_displays [i].section;
2922 if (strcmp (sec->uncompressed_name, match) == 0)
2923 sec->name = sec->uncompressed_name;
2925 sec->name = sec->compressed_name;
2926 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2929 debug_displays [i].display (sec, abfd);
2931 if (i != info && i != abbrev)
2932 free_debug_section ((enum dwarf_section_display_enum) i);
2938 /* Dump the dwarf debugging information. */
2941 dump_dwarf (bfd *abfd)
2943 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2944 if (byte_get == NULL)
2946 warn (_("File %s does not contain any dwarf debug information\n"),
2947 bfd_get_filename (abfd));
2951 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2953 switch (bfd_get_arch (abfd))
2956 switch (bfd_get_mach (abfd))
2958 case bfd_mach_x86_64:
2959 case bfd_mach_x86_64_intel_syntax:
2960 case bfd_mach_x86_64_nacl:
2961 case bfd_mach_x64_32:
2962 case bfd_mach_x64_32_intel_syntax:
2963 case bfd_mach_x64_32_nacl:
2964 init_dwarf_regnames_x86_64 ();
2968 init_dwarf_regnames_i386 ();
2973 case bfd_arch_iamcu:
2974 init_dwarf_regnames_iamcu ();
2977 case bfd_arch_aarch64:
2978 init_dwarf_regnames_aarch64();
2982 init_dwarf_regnames_s390 ();
2985 case bfd_arch_riscv:
2986 init_dwarf_regnames_riscv ();
2990 /* S12Z has a 24 bit address space. But the only known
2991 producer of dwarf_info encodes addresses into 32 bits. */
2999 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
3002 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3003 it. Return NULL on failure. */
3006 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr,
3007 bfd_size_type *entsize_ptr)
3012 stabsect = bfd_get_section_by_name (abfd, sect_name);
3013 if (stabsect == NULL)
3015 printf (_("No %s section present\n\n"),
3016 sanitize_string (sect_name));
3020 if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
3022 non_fatal (_("reading %s section of %s failed: %s"),
3023 sect_name, bfd_get_filename (abfd),
3024 bfd_errmsg (bfd_get_error ()));
3030 *size_ptr = bfd_section_size (abfd, stabsect);
3032 *entsize_ptr = stabsect->entsize;
3037 /* Stabs entries use a 12 byte format:
3038 4 byte string table index
3040 1 byte stab other field
3041 2 byte stab desc field
3043 FIXME: This will have to change for a 64 bit object format. */
3045 #define STRDXOFF (0)
3047 #define OTHEROFF (5)
3050 #define STABSIZE (12)
3052 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3053 using string table section STRSECT_NAME (in `strtab'). */
3056 print_section_stabs (bfd *abfd,
3057 const char *stabsect_name,
3058 unsigned *string_offset_ptr)
3061 unsigned file_string_table_offset = 0;
3062 unsigned next_file_string_table_offset = *string_offset_ptr;
3063 bfd_byte *stabp, *stabs_end;
3066 stabs_end = stabp + stab_size;
3068 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
3069 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3071 /* Loop through all symbols and print them.
3073 We start the index at -1 because there is a dummy symbol on
3074 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3075 for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
3079 unsigned char type, other;
3080 unsigned short desc;
3083 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3084 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3085 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3086 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3087 value = bfd_h_get_32 (abfd, stabp + VALOFF);
3089 printf ("\n%-6d ", i);
3090 /* Either print the stab name, or, if unnamed, print its number
3091 again (makes consistent formatting for tools like awk). */
3092 name = bfd_get_stab_name (type);
3094 printf ("%-6s", sanitize_string (name));
3095 else if (type == N_UNDF)
3098 printf ("%-6d", type);
3099 printf (" %-6d %-6d ", other, desc);
3100 bfd_printf_vma (abfd, value);
3101 printf (" %-6lu", strx);
3103 /* Symbols with type == 0 (N_UNDF) specify the length of the
3104 string table associated with this file. We use that info
3105 to know how to relocate the *next* file's string table indices. */
3108 file_string_table_offset = next_file_string_table_offset;
3109 next_file_string_table_offset += value;
3113 bfd_size_type amt = strx + file_string_table_offset;
3115 /* Using the (possibly updated) string table offset, print the
3116 string (if any) associated with this symbol. */
3117 if (amt < stabstr_size)
3118 /* PR 17512: file: 079-79389-0.001:0.1.
3119 FIXME: May need to sanitize this string before displaying. */
3120 printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
3126 *string_offset_ptr = next_file_string_table_offset;
3131 const char * section_name;
3132 const char * string_section_name;
3133 unsigned string_offset;
3138 find_stabs_section (bfd *abfd, asection *section, void *names)
3141 stab_section_names * sought = (stab_section_names *) names;
3143 /* Check for section names for which stabsect_name is a prefix, to
3144 handle .stab.N, etc. */
3145 len = strlen (sought->section_name);
3147 /* If the prefix matches, and the files section name ends with a
3148 nul or a digit, then we match. I.e., we want either an exact
3149 match or a section followed by a number. */
3150 if (strncmp (sought->section_name, section->name, len) == 0
3151 && (section->name[len] == 0
3152 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
3155 strtab = read_section_stabs (abfd, sought->string_section_name,
3156 &stabstr_size, NULL);
3160 stabs = read_section_stabs (abfd, section->name, &stab_size, NULL);
3162 print_section_stabs (abfd, section->name, &sought->string_offset);
3168 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3170 stab_section_names s;
3172 s.section_name = stabsect_name;
3173 s.string_section_name = strsect_name;
3174 s.string_offset = 0;
3176 bfd_map_over_sections (abfd, find_stabs_section, & s);
3182 /* Dump the any sections containing stabs debugging information. */
3185 dump_stabs (bfd *abfd)
3187 dump_stabs_section (abfd, ".stab", ".stabstr");
3188 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3189 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
3192 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3194 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3198 dump_bfd_header (bfd *abfd)
3202 printf (_("architecture: %s, "),
3203 bfd_printable_arch_mach (bfd_get_arch (abfd),
3204 bfd_get_mach (abfd)));
3205 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
3207 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3208 PF (HAS_RELOC, "HAS_RELOC");
3209 PF (EXEC_P, "EXEC_P");
3210 PF (HAS_LINENO, "HAS_LINENO");
3211 PF (HAS_DEBUG, "HAS_DEBUG");
3212 PF (HAS_SYMS, "HAS_SYMS");
3213 PF (HAS_LOCALS, "HAS_LOCALS");
3214 PF (DYNAMIC, "DYNAMIC");
3215 PF (WP_TEXT, "WP_TEXT");
3216 PF (D_PAGED, "D_PAGED");
3217 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3218 printf (_("\nstart address 0x"));
3219 bfd_printf_vma (abfd, abfd->start_address);
3224 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3225 it is passed, or a pointer to newly-allocated storage, in which case
3226 dump_ctf() will free it when it no longer needs it. */
3229 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
3232 const char *blanks = arg;
3235 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
3240 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3242 make_ctfsect (const char *name, bfd_byte *data,
3247 ctfsect.cts_name = name;
3248 ctfsect.cts_entsize = 1;
3249 ctfsect.cts_size = size;
3250 ctfsect.cts_data = data;
3255 /* Dump one CTF archive member. */
3258 dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
3260 ctf_file_t *parent = (ctf_file_t *) arg;
3261 const char *things[] = {"Labels", "Data objects", "Function objects",
3262 "Variables", "Types", "Strings", ""};
3266 /* Only print out the name of non-default-named archive members.
3267 The name .ctf appears everywhere, even for things that aren't
3268 really archives, so printing it out is liable to be confusing. */
3269 if (strcmp (name, ".ctf") != 0)
3270 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
3272 ctf_import (ctf, parent);
3273 for (i = 1, thing = things; *thing[0]; thing++, i++)
3275 ctf_dump_state_t *s = NULL;
3278 printf ("\n %s:\n", *thing);
3279 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
3280 (void *) " ")) != NULL)
3282 printf ("%s\n", item);
3286 if (ctf_errno (ctf))
3288 non_fatal (_("Iteration failed: %s, %s\n"), *thing,
3289 ctf_errmsg (ctf_errno (ctf)));
3296 /* Dump the CTF debugging information. */
3299 dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
3301 ctf_archive_t *ctfa, *parenta = NULL;
3302 bfd_byte *ctfdata, *parentdata = NULL;
3303 bfd_size_type ctfsize, parentsize;
3305 ctf_file_t *parent = NULL;
3308 if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
3309 bfd_fatal (bfd_get_filename (abfd));
3312 && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
3314 bfd_fatal (bfd_get_filename (abfd));
3316 /* Load the CTF file and dump it. */
3318 ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
3319 if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3321 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3322 bfd_fatal (bfd_get_filename (abfd));
3327 ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
3328 if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3330 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3331 bfd_fatal (bfd_get_filename (abfd));
3334 /* Assume that the applicable parent archive member is the default one.
3335 (This is what all known implementations are expected to do, if they
3336 put CTFs and their parents in archives together.) */
3337 if ((parent = ctf_arc_open_by_name (parenta, NULL, &err)) == NULL)
3339 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3340 bfd_fatal (bfd_get_filename (abfd));
3344 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
3346 ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
3347 ctf_file_close (parent);
3349 ctf_close (parenta);
3356 dump_bfd_private_header (bfd *abfd)
3358 if (!bfd_print_private_bfd_data (abfd, stdout))
3359 non_fatal (_("warning: private headers incomplete: %s"),
3360 bfd_errmsg (bfd_get_error ()));
3364 dump_target_specific (bfd *abfd)
3366 const struct objdump_private_desc * const *desc;
3367 struct objdump_private_option *opt;
3370 /* Find the desc. */
3371 for (desc = objdump_private_vectors; *desc != NULL; desc++)
3372 if ((*desc)->filter (abfd))
3377 non_fatal (_("option -P/--private not supported by this file"));
3381 /* Clear all options. */
3382 for (opt = (*desc)->options; opt->name; opt++)
3383 opt->selected = FALSE;
3385 /* Decode options. */
3386 b = dump_private_options;
3389 e = strchr (b, ',');
3394 for (opt = (*desc)->options; opt->name; opt++)
3395 if (strcmp (opt->name, b) == 0)
3397 opt->selected = TRUE;
3400 if (opt->name == NULL)
3401 non_fatal (_("target specific dump '%s' not supported"), b);
3412 (*desc)->dump (abfd);
3415 /* Display a section in hexadecimal format with associated characters.
3416 Each line prefixed by the zero padded address. */
3419 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3421 bfd_byte *data = NULL;
3422 bfd_size_type datasize;
3423 bfd_vma addr_offset;
3424 bfd_vma start_offset;
3425 bfd_vma stop_offset;
3426 unsigned int opb = bfd_octets_per_byte (abfd);
3427 /* Bytes per line. */
3428 const int onaline = 16;
3433 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3436 if (! process_section_p (section))
3439 if ((datasize = bfd_section_size (abfd, section)) == 0)
3442 /* Compute the address range to display. */
3443 if (start_address == (bfd_vma) -1
3444 || start_address < section->vma)
3447 start_offset = start_address - section->vma;
3449 if (stop_address == (bfd_vma) -1)
3450 stop_offset = datasize / opb;
3453 if (stop_address < section->vma)
3456 stop_offset = stop_address - section->vma;
3458 if (stop_offset > datasize / opb)
3459 stop_offset = datasize / opb;
3462 if (start_offset >= stop_offset)
3465 printf (_("Contents of section %s:"), sanitize_string (section->name));
3466 if (display_file_offsets)
3467 printf (_(" (Starting at file offset: 0x%lx)"),
3468 (unsigned long) (section->filepos + start_offset));
3471 if (!bfd_get_full_section_contents (abfd, section, &data))
3473 non_fatal (_("Reading section %s failed because: %s"),
3474 section->name, bfd_errmsg (bfd_get_error ()));
3480 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3481 if (strlen (buf) >= sizeof (buf))
3485 while (buf[count] == '0' && buf[count+1] != '\0')
3487 count = strlen (buf) - count;
3491 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3492 if (strlen (buf) >= sizeof (buf))
3496 while (buf[count] == '0' && buf[count+1] != '\0')
3498 count = strlen (buf) - count;
3502 for (addr_offset = start_offset;
3503 addr_offset < stop_offset; addr_offset += onaline / opb)
3507 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3508 count = strlen (buf);
3509 if ((size_t) count >= sizeof (buf))
3513 while (count < width)
3518 fputs (buf + count - width, stdout);
3521 for (j = addr_offset * opb;
3522 j < addr_offset * opb + onaline; j++)
3524 if (j < stop_offset * opb)
3525 printf ("%02x", (unsigned) (data[j]));
3533 for (j = addr_offset * opb;
3534 j < addr_offset * opb + onaline; j++)
3536 if (j >= stop_offset * opb)
3539 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3546 /* Actually display the various requested regions. */
3549 dump_data (bfd *abfd)
3551 bfd_map_over_sections (abfd, dump_section, NULL);
3554 /* Should perhaps share code and display with nm? */
3557 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3566 max_count = dynsymcount;
3567 printf ("DYNAMIC SYMBOL TABLE:\n");
3572 max_count = symcount;
3573 printf ("SYMBOL TABLE:\n");
3577 printf (_("no symbols\n"));
3579 for (count = 0; count < max_count; count++)
3583 if (*current == NULL)
3584 printf (_("no information for symbol number %ld\n"), count);
3586 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3587 printf (_("could not determine the type of symbol number %ld\n"),
3590 else if (process_section_p ((* current)->section)
3591 && (dump_special_syms
3592 || !bfd_is_target_special_symbol (cur_bfd, *current)))
3594 const char *name = (*current)->name;
3596 if (do_demangle && name != NULL && *name != '\0')
3600 /* If we want to demangle the name, we demangle it
3601 here, and temporarily clobber it while calling
3602 bfd_print_symbol. FIXME: This is a gross hack. */
3603 alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3605 (*current)->name = alloc;
3606 bfd_print_symbol (cur_bfd, stdout, *current,
3607 bfd_print_symbol_all);
3610 (*current)->name = name;
3615 bfd_print_symbol (cur_bfd, stdout, *current,
3616 bfd_print_symbol_all);
3626 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3629 char *last_filename, *last_functionname;
3630 unsigned int last_line;
3631 unsigned int last_discriminator;
3633 /* Get column headers lined up reasonably. */
3641 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3642 width = strlen (buf) - 7;
3644 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3647 last_filename = NULL;
3648 last_functionname = NULL;
3650 last_discriminator = 0;
3652 for (p = relpp; relcount && *p != NULL; p++, relcount--)
3655 const char *filename, *functionname;
3656 unsigned int linenumber;
3657 unsigned int discriminator;
3658 const char *sym_name;
3659 const char *section_name;
3660 bfd_vma addend2 = 0;
3662 if (start_address != (bfd_vma) -1
3663 && q->address < start_address)
3665 if (stop_address != (bfd_vma) -1
3666 && q->address > stop_address)
3669 if (with_line_numbers
3671 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3672 &filename, &functionname,
3673 &linenumber, &discriminator))
3675 if (functionname != NULL
3676 && (last_functionname == NULL
3677 || strcmp (functionname, last_functionname) != 0))
3679 printf ("%s():\n", sanitize_string (functionname));
3680 if (last_functionname != NULL)
3681 free (last_functionname);
3682 last_functionname = xstrdup (functionname);
3686 && (linenumber != last_line
3687 || (filename != NULL
3688 && last_filename != NULL
3689 && filename_cmp (filename, last_filename) != 0)
3690 || (discriminator != last_discriminator)))
3692 if (discriminator > 0)
3693 printf ("%s:%u\n", filename == NULL ? "???" :
3694 sanitize_string (filename), linenumber);
3696 printf ("%s:%u (discriminator %u)\n",
3697 filename == NULL ? "???" : sanitize_string (filename),
3698 linenumber, discriminator);
3699 last_line = linenumber;
3700 last_discriminator = discriminator;
3701 if (last_filename != NULL)
3702 free (last_filename);
3703 if (filename == NULL)
3704 last_filename = NULL;
3706 last_filename = xstrdup (filename);
3710 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3712 sym_name = (*(q->sym_ptr_ptr))->name;
3713 section_name = (*(q->sym_ptr_ptr))->section->name;
3718 section_name = NULL;
3721 bfd_printf_vma (abfd, q->address);
3722 if (q->howto == NULL)
3723 printf (" *unknown* ");
3724 else if (q->howto->name)
3726 const char *name = q->howto->name;
3728 /* R_SPARC_OLO10 relocations contain two addends.
3729 But because 'arelent' lacks enough storage to
3730 store them both, the 64-bit ELF Sparc backend
3731 records this as two relocations. One R_SPARC_LO10
3732 and one R_SPARC_13, both pointing to the same
3733 address. This is merely so that we have some
3734 place to store both addend fields.
3736 Undo this transformation, otherwise the output
3737 will be confusing. */
3738 if (abfd->xvec->flavour == bfd_target_elf_flavour
3739 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3741 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3743 arelent *q2 = *(p + 1);
3746 && q->address == q2->address
3747 && !strcmp (q2->howto->name, "R_SPARC_13"))
3749 name = "R_SPARC_OLO10";
3750 addend2 = q2->addend;
3754 printf (" %-16s ", name);
3757 printf (" %-16d ", q->howto->type);
3761 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3765 if (section_name == NULL)
3766 section_name = "*unknown*";
3767 printf ("[%s]", sanitize_string (section_name));
3772 bfd_signed_vma addend = q->addend;
3780 bfd_printf_vma (abfd, addend);
3785 bfd_printf_vma (abfd, addend2);
3791 if (last_filename != NULL)
3792 free (last_filename);
3793 if (last_functionname != NULL)
3794 free (last_functionname);
3798 dump_relocs_in_section (bfd *abfd,
3800 void *dummy ATTRIBUTE_UNUSED)
3802 arelent **relpp = NULL;
3806 if ( bfd_is_abs_section (section)
3807 || bfd_is_und_section (section)
3808 || bfd_is_com_section (section)
3809 || (! process_section_p (section))
3810 || ((section->flags & SEC_RELOC) == 0))
3813 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3815 relsize = bfd_get_reloc_upper_bound (abfd, section);
3818 printf (" (none)\n\n");
3826 relpp = (arelent **) xmalloc (relsize);
3827 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3833 non_fatal (_("failed to read relocs in: %s"),
3834 sanitize_string (bfd_get_filename (abfd)));
3835 bfd_fatal (_("error message was"));
3837 else if (relcount == 0)
3838 printf (" (none)\n\n");
3842 dump_reloc_set (abfd, section, relpp, relcount);
3849 dump_relocs (bfd *abfd)
3851 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3855 dump_dynamic_relocs (bfd *abfd)
3861 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3863 bfd_fatal (bfd_get_filename (abfd));
3865 printf ("DYNAMIC RELOCATION RECORDS");
3868 printf (" (none)\n\n");
3871 relpp = (arelent **) xmalloc (relsize);
3872 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3875 bfd_fatal (bfd_get_filename (abfd));
3876 else if (relcount == 0)
3877 printf (" (none)\n\n");
3881 dump_reloc_set (abfd, NULL, relpp, relcount);
3888 /* Creates a table of paths, to search for source files. */
3891 add_include_path (const char *path)
3895 include_path_count++;
3896 include_paths = (const char **)
3897 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3898 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3899 if (path[1] == ':' && path[2] == 0)
3900 path = concat (path, ".", (const char *) 0);
3902 include_paths[include_path_count - 1] = path;
3906 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3910 if ((section->flags & SEC_DEBUGGING) == 0)
3912 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3913 section->vma += adjust_section_vma;
3915 section->lma += adjust_section_vma;
3919 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3922 sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
3927 mask = (bfd_vma) 1 << (arch_size - 1);
3928 return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
3931 /* Dump selected contents of ABFD. */
3934 dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
3936 const struct elf_backend_data * bed;
3938 if (bfd_big_endian (abfd))
3939 byte_get = byte_get_big_endian;
3940 else if (bfd_little_endian (abfd))
3941 byte_get = byte_get_little_endian;
3945 /* Load any separate debug information files.
3946 We do this now and without checking do_follow_links because separate
3947 debug info files may contain symbol tables that we will need when
3948 displaying information about the main file. Any memory allocated by
3949 load_separate_debug_files will be released when we call
3950 free_debug_memory below.
3952 The test on is_mainfile is there because the chain of separate debug
3953 info files is a global variable shared by all invocations of dump_bfd. */
3956 load_separate_debug_files (abfd, bfd_get_filename (abfd));
3958 /* If asked to do so, recursively dump the separate files. */
3959 if (do_follow_links)
3963 for (i = first_separate_info; i != NULL; i = i->next)
3964 dump_bfd (i->handle, FALSE);
3968 /* Adjust user-specified start and stop limits for targets that use
3969 signed addresses. */
3970 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
3971 && (bed = get_elf_backend_data (abfd)) != NULL
3972 && bed->sign_extend_vma)
3974 start_address = sign_extend_address (abfd, start_address,
3976 stop_address = sign_extend_address (abfd, stop_address,
3980 /* If we are adjusting section VMA's, change them all now. Changing
3981 the BFD information is a hack. However, we must do it, or
3982 bfd_find_nearest_line will not do the right thing. */
3983 if (adjust_section_vma != 0)
3985 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3986 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3989 if (! dump_debugging_tags && ! suppress_bfd_header)
3990 printf (_("\n%s: file format %s\n"),
3991 sanitize_string (bfd_get_filename (abfd)),
3994 print_arelt_descr (stdout, abfd, TRUE, FALSE);
3995 if (dump_file_header)
3996 dump_bfd_header (abfd);
3997 if (dump_private_headers)
3998 dump_bfd_private_header (abfd);
3999 if (dump_private_options != NULL)
4000 dump_target_specific (abfd);
4001 if (! dump_debugging_tags && ! suppress_bfd_header)
4008 || dump_dwarf_section_info)
4010 syms = slurp_symtab (abfd);
4012 /* If following links, load any symbol tables from the linked files as well. */
4013 if (do_follow_links && is_mainfile)
4017 for (i = first_separate_info; i != NULL; i = i->next)
4019 asymbol ** extra_syms;
4020 long old_symcount = symcount;
4022 extra_syms = slurp_symtab (i->handle);
4026 if (old_symcount == 0)
4032 syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
4033 memcpy (syms + old_symcount,
4035 symcount * sizeof (asymbol *));
4039 symcount += old_symcount;
4044 if (dump_section_headers)
4045 dump_headers (abfd);
4047 if (dump_dynamic_symtab || dump_dynamic_reloc_info
4048 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
4049 dynsyms = slurp_dynamic_symtab (abfd);
4053 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
4054 dynsymcount, dynsyms, &synthsyms);
4060 dump_symbols (abfd, FALSE);
4061 if (dump_dynamic_symtab)
4062 dump_symbols (abfd, TRUE);
4063 if (dump_dwarf_section_info)
4065 if (dump_ctf_section_info)
4066 dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
4067 if (dump_stab_section_info)
4069 if (dump_reloc_info && ! disassemble)
4071 if (dump_dynamic_reloc_info && ! disassemble)
4072 dump_dynamic_relocs (abfd);
4073 if (dump_section_contents)
4076 disassemble_data (abfd);
4082 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
4083 if (dhandle != NULL)
4085 if (!print_debugging_info (stdout, dhandle, abfd, syms,
4087 dump_debugging_tags ? TRUE : FALSE))
4089 non_fatal (_("%s: printing debugging information failed"),
4090 bfd_get_filename (abfd));
4096 /* PR 6483: If there was no STABS debug info in the file, try
4098 else if (! dump_dwarf_section_info)
4100 dwarf_select_sections_all ();
4128 free_debug_memory ();
4132 display_object_bfd (bfd *abfd)
4136 if (bfd_check_format_matches (abfd, bfd_object, &matching))
4138 dump_bfd (abfd, TRUE);
4142 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4144 nonfatal (bfd_get_filename (abfd));
4145 list_matching_formats (matching);
4150 if (bfd_get_error () != bfd_error_file_not_recognized)
4152 nonfatal (bfd_get_filename (abfd));
4156 if (bfd_check_format_matches (abfd, bfd_core, &matching))
4158 dump_bfd (abfd, TRUE);
4162 nonfatal (bfd_get_filename (abfd));
4164 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4166 list_matching_formats (matching);
4172 display_any_bfd (bfd *file, int level)
4174 /* Decompress sections unless dumping the section contents. */
4175 if (!dump_section_contents)
4176 file->flags |= BFD_DECOMPRESS;
4178 /* If the file is an archive, process all of its elements. */
4179 if (bfd_check_format (file, bfd_archive))
4182 bfd *last_arfile = NULL;
4185 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
4186 else if (level > 100)
4188 /* Prevent corrupted files from spinning us into an
4189 infinite loop. 100 is an arbitrary heuristic. */
4190 fatal (_("Archive nesting is too deep"));
4194 printf (_("In nested archive %s:\n"),
4195 sanitize_string (bfd_get_filename (file)));
4199 bfd_set_error (bfd_error_no_error);
4201 arfile = bfd_openr_next_archived_file (file, arfile);
4204 if (bfd_get_error () != bfd_error_no_more_archived_files)
4205 nonfatal (bfd_get_filename (file));
4209 display_any_bfd (arfile, level + 1);
4211 if (last_arfile != NULL)
4213 bfd_close (last_arfile);
4214 /* PR 17512: file: ac585d01. */
4215 if (arfile == last_arfile)
4221 last_arfile = arfile;
4224 if (last_arfile != NULL)
4225 bfd_close (last_arfile);
4228 display_object_bfd (file);
4232 display_file (char *filename, char *target, bfd_boolean last_file)
4236 if (get_file_size (filename) < 1)
4242 file = bfd_openr (filename, target);
4245 nonfatal (filename);
4249 display_any_bfd (file, 0);
4251 /* This is an optimization to improve the speed of objdump, especially when
4252 dumping a file with lots of associated debug informatiom. Calling
4253 bfd_close on such a file can take a non-trivial amount of time as there
4254 are lots of lists to walk and buffers to free. This is only really
4255 necessary however if we are about to load another file and we need the
4256 memory back. Otherwise, if we are about to exit, then we can save (a lot
4257 of) time by only doing a quick close, and allowing the OS to reclaim the
4262 bfd_close_all_done (file);
4266 main (int argc, char **argv)
4269 char *target = default_target;
4270 bfd_boolean seenflag = FALSE;
4272 #if defined (HAVE_SETLOCALE)
4273 #if defined (HAVE_LC_MESSAGES)
4274 setlocale (LC_MESSAGES, "");
4276 setlocale (LC_CTYPE, "");
4279 bindtextdomain (PACKAGE, LOCALEDIR);
4280 textdomain (PACKAGE);
4282 program_name = *argv;
4283 xmalloc_set_program_name (program_name);
4284 bfd_set_error_program_name (program_name);
4286 START_PROGRESS (program_name, 0);
4288 expandargv (&argc, &argv);
4290 if (bfd_init () != BFD_INIT_MAGIC)
4291 fatal (_("fatal error: libbfd ABI mismatch"));
4292 set_default_bfd_target ();
4294 while ((c = getopt_long (argc, argv,
4295 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4296 long_options, (int *) 0))
4302 break; /* We've been given a long option. */
4309 if (disassembler_options)
4310 /* Ignore potential memory leak for now. */
4311 options = concat (disassembler_options, ",",
4312 optarg, (const char *) NULL);
4315 disassembler_options = remove_whitespace_and_extra_commas (options);
4322 display_file_offsets = TRUE;
4325 with_line_numbers = TRUE;
4334 enum demangling_styles style;
4336 style = cplus_demangle_name_to_style (optarg);
4337 if (style == unknown_demangling)
4338 fatal (_("unknown demangling style `%s'"),
4341 cplus_demangle_set_style (style);
4344 case OPTION_RECURSE_LIMIT:
4345 demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4347 case OPTION_NO_RECURSE_LIMIT:
4348 demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4351 do_wide = wide_output = TRUE;
4353 case OPTION_ADJUST_VMA:
4354 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4356 case OPTION_START_ADDRESS:
4357 start_address = parse_vma (optarg, "--start-address");
4358 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4359 fatal (_("error: the start address should be before the end address"));
4361 case OPTION_STOP_ADDRESS:
4362 stop_address = parse_vma (optarg, "--stop-address");
4363 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4364 fatal (_("error: the stop address should be after the start address"));
4368 prefix_length = strlen (prefix);
4369 /* Remove an unnecessary trailing '/' */
4370 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4373 case OPTION_PREFIX_STRIP:
4374 prefix_strip = atoi (optarg);
4375 if (prefix_strip < 0)
4376 fatal (_("error: prefix strip must be non-negative"));
4378 case OPTION_INSN_WIDTH:
4379 insn_width = strtoul (optarg, NULL, 0);
4380 if (insn_width <= 0)
4381 fatal (_("error: instruction width must be positive"));
4383 case OPTION_INLINES:
4384 unwind_inlines = TRUE;
4387 if (strcmp (optarg, "B") == 0)
4388 endian = BFD_ENDIAN_BIG;
4389 else if (strcmp (optarg, "L") == 0)
4390 endian = BFD_ENDIAN_LITTLE;
4393 nonfatal (_("unrecognized -E option"));
4398 if (strncmp (optarg, "big", strlen (optarg)) == 0)
4399 endian = BFD_ENDIAN_BIG;
4400 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4401 endian = BFD_ENDIAN_LITTLE;
4404 non_fatal (_("unrecognized --endian type `%s'"), optarg);
4411 dump_file_header = TRUE;
4415 formats_info = TRUE;
4419 add_include_path (optarg);
4422 dump_private_headers = TRUE;
4426 dump_private_options = optarg;
4430 dump_private_headers = TRUE;
4432 dump_reloc_info = TRUE;
4433 dump_file_header = TRUE;
4434 dump_ar_hdrs = TRUE;
4435 dump_section_headers = TRUE;
4443 dump_dynamic_symtab = TRUE;
4449 disasm_sym = optarg;
4452 disassemble_zeroes = TRUE;
4456 disassemble_all = TRUE;
4461 with_source_code = TRUE;
4464 case OPTION_SOURCE_COMMENT:
4466 with_source_code = TRUE;
4469 source_comment = xstrdup (sanitize_string (optarg));
4471 source_comment = xstrdup ("# ");
4479 dump_debugging_tags = 1;
4484 dump_dwarf_section_info = TRUE;
4487 dwarf_select_sections_by_letters (optarg);
4489 dwarf_select_sections_all ();
4492 dump_dwarf_section_info = TRUE;
4495 dwarf_select_sections_by_names (optarg);
4497 dwarf_select_sections_all ();
4499 case OPTION_DWARF_DEPTH:
4502 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4505 case OPTION_DWARF_START:
4508 dwarf_start_die = strtoul (optarg, & cp, 0);
4509 suppress_bfd_header = 1;
4512 case OPTION_DWARF_CHECK:
4516 dump_ctf_section_info = TRUE;
4517 dump_ctf_section_name = xstrdup (optarg);
4520 case OPTION_CTF_PARENT:
4521 dump_ctf_parent_name = xstrdup (optarg);
4524 dump_stab_section_info = TRUE;
4528 dump_section_contents = TRUE;
4532 dump_reloc_info = TRUE;
4536 dump_dynamic_reloc_info = TRUE;
4540 dump_ar_hdrs = TRUE;
4544 dump_section_headers = TRUE;
4549 show_version = TRUE;
4555 /* No need to set seenflag or to break - usage() does not return. */
4562 print_version ("objdump");
4568 exit_status = display_info ();
4572 display_file ("a.out", target, TRUE);
4574 for (; optind < argc;)
4576 display_file (argv[optind], target, optind == argc - 1);
4582 free (dump_ctf_section_name);
4583 free (dump_ctf_parent_name);
4584 free ((void *) source_comment);
4586 END_PROGRESS (program_name);