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. */
127 static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
129 /* A structure to record the sections mentioned in -j switches. */
132 const char * name; /* The name of the section. */
133 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
134 struct only * next; /* Pointer to the next structure in the list. */
136 /* Pointer to an array of 'only' structures.
137 This pointer is NULL if the -j switch has not been used. */
138 static struct only * only_list = NULL;
140 /* Variables for handling include file path table. */
141 static const char **include_paths;
142 static int include_path_count;
144 /* Extra info to pass to the section disassembler and address printing
146 struct objdump_disasm_info
150 bfd_boolean require_sec;
151 arelent ** dynrelbuf;
153 disassembler_ftype disassemble_fn;
158 /* Architecture to disassemble for, or default if NULL. */
159 static char *machine = NULL;
161 /* Target specific options to the disassembler. */
162 static char *disassembler_options = NULL;
164 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
165 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
167 /* The symbol table. */
168 static asymbol **syms;
170 /* Number of symbols in `syms'. */
171 static long symcount = 0;
173 /* The sorted symbol table. */
174 static asymbol **sorted_syms;
176 /* Number of symbols in `sorted_syms'. */
177 static long sorted_symcount = 0;
179 /* The dynamic symbol table. */
180 static asymbol **dynsyms;
182 /* The synthetic symbol table. */
183 static asymbol *synthsyms;
184 static long synthcount = 0;
186 /* Number of symbols in `dynsyms'. */
187 static long dynsymcount = 0;
189 static bfd_byte *stabs;
190 static bfd_size_type stab_size;
192 static bfd_byte *strtab;
193 static bfd_size_type stabstr_size;
195 static bfd_boolean is_relocatable = FALSE;
197 /* Handlers for -P/--private. */
198 static const struct objdump_private_desc * const objdump_private_vectors[] =
200 OBJDUMP_PRIVATE_VECTORS
204 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
206 usage (FILE *stream, int status)
208 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
209 fprintf (stream, _(" Display information from object <file(s)>.\n"));
210 fprintf (stream, _(" At least one of the following switches must be given:\n"));
211 fprintf (stream, _("\
212 -a, --archive-headers Display archive header information\n\
213 -f, --file-headers Display the contents of the overall file header\n\
214 -p, --private-headers Display object format specific file header contents\n\
215 -P, --private=OPT,OPT... Display object format specific contents\n\
216 -h, --[section-]headers Display the contents of the section headers\n\
217 -x, --all-headers Display the contents of all headers\n\
218 -d, --disassemble Display assembler contents of executable sections\n\
219 -D, --disassemble-all Display assembler contents of all sections\n\
220 --disassemble=<sym> Display assembler contents from <sym>\n\
221 -S, --source Intermix source code with disassembly\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,
322 static struct option long_options[]=
324 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
325 {"all-headers", no_argument, NULL, 'x'},
326 {"private-headers", no_argument, NULL, 'p'},
327 {"private", required_argument, NULL, 'P'},
328 {"architecture", required_argument, NULL, 'm'},
329 {"archive-headers", no_argument, NULL, 'a'},
330 {"debugging", no_argument, NULL, 'g'},
331 {"debugging-tags", no_argument, NULL, 'e'},
332 {"demangle", optional_argument, NULL, 'C'},
333 {"disassemble", optional_argument, NULL, 'd'},
334 {"disassemble-all", no_argument, NULL, 'D'},
335 {"disassembler-options", required_argument, NULL, 'M'},
336 {"disassemble-zeroes", no_argument, NULL, 'z'},
337 {"dynamic-reloc", no_argument, NULL, 'R'},
338 {"dynamic-syms", no_argument, NULL, 'T'},
339 {"endian", required_argument, NULL, OPTION_ENDIAN},
340 {"file-headers", no_argument, NULL, 'f'},
341 {"file-offsets", no_argument, NULL, 'F'},
342 {"file-start-context", no_argument, &file_start_context, 1},
343 {"full-contents", no_argument, NULL, 's'},
344 {"headers", no_argument, NULL, 'h'},
345 {"help", no_argument, NULL, 'H'},
346 {"info", no_argument, NULL, 'i'},
347 {"line-numbers", no_argument, NULL, 'l'},
348 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
349 {"prefix-addresses", no_argument, &prefix_addresses, 1},
350 {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
351 {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
352 {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
353 {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
354 {"reloc", no_argument, NULL, 'r'},
355 {"section", required_argument, NULL, 'j'},
356 {"section-headers", no_argument, NULL, 'h'},
357 {"show-raw-insn", no_argument, &show_raw_insn, 1},
358 {"source", no_argument, NULL, 'S'},
359 {"special-syms", no_argument, &dump_special_syms, 1},
360 {"include", required_argument, NULL, 'I'},
361 {"dwarf", optional_argument, NULL, OPTION_DWARF},
362 {"ctf", required_argument, NULL, OPTION_CTF},
363 {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
364 {"stabs", no_argument, NULL, 'G'},
365 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
366 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
367 {"syms", no_argument, NULL, 't'},
368 {"target", required_argument, NULL, 'b'},
369 {"version", no_argument, NULL, 'V'},
370 {"wide", no_argument, NULL, 'w'},
371 {"prefix", required_argument, NULL, OPTION_PREFIX},
372 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
373 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
374 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
375 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
376 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
377 {"inlines", no_argument, 0, OPTION_INLINES},
378 {0, no_argument, 0, 0}
382 nonfatal (const char *msg)
388 /* Returns a version of IN with any control characters
389 replaced by escape sequences. Uses a static buffer
393 sanitize_string (const char * in)
395 static char * buffer = NULL;
396 static size_t buffer_len = 0;
397 const char * original = in;
404 /* See if any conversion is necessary. In the majority
405 of cases it will not be needed. */
418 /* Copy the input, translating as needed. */
420 if (buffer_len < (strlen (in) * 2))
422 free ((void *) buffer);
423 buffer_len = strlen (in) * 2;
424 buffer = xmalloc (buffer_len + 1);
450 /* Returns TRUE if the specified section should be dumped. */
453 process_section_p (asection * section)
457 if (only_list == NULL)
460 for (only = only_list; only; only = only->next)
461 if (strcmp (only->name, section->name) == 0)
470 /* Add an entry to the 'only' list. */
473 add_only (char * name)
477 /* First check to make sure that we do not
478 already have an entry for this name. */
479 for (only = only_list; only; only = only->next)
480 if (strcmp (only->name, name) == 0)
483 only = xmalloc (sizeof * only);
486 only->next = only_list;
490 /* Release the memory used by the 'only' list.
491 PR 11225: Issue a warning message for unseen sections.
492 Only do this if none of the sections were seen. This is mainly to support
493 tools like the GAS testsuite where an object file is dumped with a list of
494 generic section names known to be present in a range of different file
498 free_only_list (void)
500 bfd_boolean at_least_one_seen = FALSE;
504 if (only_list == NULL)
507 for (only = only_list; only; only = only->next)
510 at_least_one_seen = TRUE;
514 for (only = only_list; only; only = next)
516 if (! at_least_one_seen)
518 non_fatal (_("section '%s' mentioned in a -j option, "
519 "but not found in any input file"),
530 dump_section_header (bfd *abfd, asection *section, void *data)
533 unsigned int opb = bfd_octets_per_byte (abfd);
534 int longest_section_name = *((int *) data);
536 /* Ignore linker created section. See elfNN_ia64_object_p in
538 if (section->flags & SEC_LINKER_CREATED)
541 /* PR 10413: Skip sections that we are ignoring. */
542 if (! process_section_p (section))
545 printf ("%3d %-*s %08lx ", section->index, longest_section_name,
546 sanitize_string (bfd_get_section_name (abfd, section)),
547 (unsigned long) bfd_section_size (abfd, section) / opb);
548 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
550 bfd_printf_vma (abfd, section->lma);
551 printf (" %08lx 2**%u", (unsigned long) section->filepos,
552 bfd_get_section_alignment (abfd, section));
558 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
560 PF (SEC_HAS_CONTENTS, "CONTENTS");
561 PF (SEC_ALLOC, "ALLOC");
562 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
563 PF (SEC_LOAD, "LOAD");
564 PF (SEC_RELOC, "RELOC");
565 PF (SEC_READONLY, "READONLY");
566 PF (SEC_CODE, "CODE");
567 PF (SEC_DATA, "DATA");
569 PF (SEC_DEBUGGING, "DEBUGGING");
570 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
571 PF (SEC_EXCLUDE, "EXCLUDE");
572 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
573 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
575 PF (SEC_TIC54X_BLOCK, "BLOCK");
576 PF (SEC_TIC54X_CLINK, "CLINK");
578 PF (SEC_SMALL_DATA, "SMALL_DATA");
579 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
581 PF (SEC_COFF_SHARED, "SHARED");
582 PF (SEC_COFF_NOREAD, "NOREAD");
584 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
585 PF (SEC_ELF_PURECODE, "PURECODE");
586 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
587 PF (SEC_GROUP, "GROUP");
588 if (bfd_get_arch (abfd) == bfd_arch_mep)
590 PF (SEC_MEP_VLIW, "VLIW");
593 if ((section->flags & SEC_LINK_ONCE) != 0)
596 struct coff_comdat_info *comdat;
598 switch (section->flags & SEC_LINK_DUPLICATES)
602 case SEC_LINK_DUPLICATES_DISCARD:
603 ls = "LINK_ONCE_DISCARD";
605 case SEC_LINK_DUPLICATES_ONE_ONLY:
606 ls = "LINK_ONCE_ONE_ONLY";
608 case SEC_LINK_DUPLICATES_SAME_SIZE:
609 ls = "LINK_ONCE_SAME_SIZE";
611 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
612 ls = "LINK_ONCE_SAME_CONTENTS";
615 printf ("%s%s", comma, ls);
617 comdat = bfd_coff_get_comdat_section (abfd, section);
619 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
628 /* Called on each SECTION in ABFD, update the int variable pointed to by
629 DATA which contains the string length of the longest section name. */
632 find_longest_section_name (bfd *abfd, asection *section, void *data)
634 int *longest_so_far = (int *) data;
638 /* Ignore linker created section. */
639 if (section->flags & SEC_LINKER_CREATED)
642 /* Skip sections that we are ignoring. */
643 if (! process_section_p (section))
646 name = bfd_get_section_name (abfd, section);
647 len = (int) strlen (name);
648 if (len > *longest_so_far)
649 *longest_so_far = len;
653 dump_headers (bfd *abfd)
655 /* The default width of 13 is just an arbitrary choice. */
656 int max_section_name_length = 13;
662 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
663 if (bfd_get_arch_size (abfd) == 32)
669 printf (_("Sections:\n"));
672 bfd_map_over_sections (abfd, find_longest_section_name,
673 &max_section_name_length);
675 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
676 max_section_name_length, "Name",
677 bfd_vma_width, "VMA",
678 bfd_vma_width, "LMA");
681 printf (_(" Flags"));
684 bfd_map_over_sections (abfd, dump_section_header,
685 &max_section_name_length);
689 slurp_symtab (bfd *abfd)
694 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
700 storage = bfd_get_symtab_upper_bound (abfd);
703 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
704 bfd_fatal (_("error message was"));
707 sy = (asymbol **) xmalloc (storage);
709 symcount = bfd_canonicalize_symtab (abfd, sy);
711 bfd_fatal (bfd_get_filename (abfd));
715 /* Read in the dynamic symbols. */
718 slurp_dynamic_symtab (bfd *abfd)
723 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
726 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
728 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
734 bfd_fatal (bfd_get_filename (abfd));
737 sy = (asymbol **) xmalloc (storage);
739 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
741 bfd_fatal (bfd_get_filename (abfd));
745 /* Some symbol names are significant and should be kept in the
746 table of sorted symbol names, even if they are marked as
747 debugging/section symbols. */
750 is_significant_symbol_name (const char * name)
752 return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
755 /* Filter out (in place) symbols that are useless for disassembly.
756 COUNT is the number of elements in SYMBOLS.
757 Return the number of useful symbols. */
760 remove_useless_symbols (asymbol **symbols, long count)
762 asymbol **in_ptr = symbols, **out_ptr = symbols;
766 asymbol *sym = *in_ptr++;
768 if (sym->name == NULL || sym->name[0] == '\0')
770 if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
771 && ! is_significant_symbol_name (sym->name))
773 if (bfd_is_und_section (sym->section)
774 || bfd_is_com_section (sym->section))
779 return out_ptr - symbols;
782 /* Sort symbols into value order. */
785 compare_symbols (const void *ap, const void *bp)
787 const asymbol *a = * (const asymbol **) ap;
788 const asymbol *b = * (const asymbol **) bp;
798 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
800 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
803 if (a->section > b->section)
805 else if (a->section < b->section)
808 an = bfd_asymbol_name (a);
809 bn = bfd_asymbol_name (b);
813 /* The symbols gnu_compiled and gcc2_compiled convey no real
814 information, so put them after other symbols with the same value. */
815 af = (strstr (an, "gnu_compiled") != NULL
816 || strstr (an, "gcc2_compiled") != NULL);
817 bf = (strstr (bn, "gnu_compiled") != NULL
818 || strstr (bn, "gcc2_compiled") != NULL);
825 /* We use a heuristic for the file name, to try to sort it after
826 more useful symbols. It may not work on non Unix systems, but it
827 doesn't really matter; the only difference is precisely which
828 symbol names get printed. */
830 #define file_symbol(s, sn, snl) \
831 (((s)->flags & BSF_FILE) != 0 \
832 || ((sn)[(snl) - 2] == '.' \
833 && ((sn)[(snl) - 1] == 'o' \
834 || (sn)[(snl) - 1] == 'a')))
836 af = file_symbol (a, an, anl);
837 bf = file_symbol (b, bn, bnl);
844 /* Try to sort global symbols before local symbols before function
845 symbols before debugging symbols. */
850 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
852 if ((aflags & BSF_DEBUGGING) != 0)
857 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
859 if ((aflags & BSF_FUNCTION) != 0)
864 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
866 if ((aflags & BSF_LOCAL) != 0)
871 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
873 if ((aflags & BSF_GLOBAL) != 0)
879 if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
880 && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
885 if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
886 asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
888 if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
889 bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
891 return asz > bsz ? -1 : 1;
894 /* Symbols that start with '.' might be section names, so sort them
895 after symbols that don't start with '.'. */
896 if (an[0] == '.' && bn[0] != '.')
898 if (an[0] != '.' && bn[0] == '.')
901 /* Finally, if we can't distinguish them in any other way, try to
902 get consistent results by sorting the symbols by name. */
903 return strcmp (an, bn);
906 /* Sort relocs into address order. */
909 compare_relocs (const void *ap, const void *bp)
911 const arelent *a = * (const arelent **) ap;
912 const arelent *b = * (const arelent **) bp;
914 if (a->address > b->address)
916 else if (a->address < b->address)
919 /* So that associated relocations tied to the same address show up
920 in the correct order, we don't do any further sorting. */
929 /* Print an address (VMA) to the output stream in INFO.
930 If SKIP_ZEROES is TRUE, omit leading zeroes. */
933 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
934 bfd_boolean skip_zeroes)
938 struct objdump_disasm_info *aux;
940 aux = (struct objdump_disasm_info *) inf->application_data;
941 bfd_sprintf_vma (aux->abfd, buf, vma);
946 for (p = buf; *p == '0'; ++p)
951 (*inf->fprintf_func) (inf->stream, "%s", p);
954 /* Print the name of a symbol. */
957 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
961 const char *name, *version_string = NULL;
962 bfd_boolean hidden = FALSE;
965 name = bfd_asymbol_name (sym);
966 if (do_demangle && name[0] != '\0')
968 /* Demangle the name. */
969 alloc = bfd_demangle (abfd, name, demangle_flags);
974 if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
975 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
977 if (bfd_is_und_section (bfd_get_section (sym)))
980 name = sanitize_string (name);
984 (*inf->fprintf_func) (inf->stream, "%s", name);
985 if (version_string && *version_string != '\0')
986 (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
992 if (version_string && *version_string != '\0')
993 printf (hidden ? "@%s" : "@@%s", version_string);
1000 static inline bfd_boolean
1001 sym_ok (bfd_boolean want_section,
1002 bfd * abfd ATTRIBUTE_UNUSED,
1005 struct disassemble_info * inf)
1009 /* Note - we cannot just compare section pointers because they could
1010 be different, but the same... Ie the symbol that we are trying to
1011 find could have come from a separate debug info file. Under such
1012 circumstances the symbol will be associated with a section in the
1013 debug info file, whilst the section we want is in a normal file.
1014 So the section pointers will be different, but the section names
1015 will be the same. */
1016 if (strcmp (bfd_section_name (abfd, sorted_syms[place]->section),
1017 bfd_section_name (abfd, sec)) != 0)
1021 return inf->symbol_is_valid (sorted_syms[place], inf);
1024 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1025 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1026 require the symbol to be in the section. Returns NULL if there is no
1027 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1028 of the symbol in sorted_syms. */
1031 find_symbol_for_address (bfd_vma vma,
1032 struct disassemble_info *inf,
1035 /* @@ Would it speed things up to cache the last two symbols returned,
1036 and maybe their address ranges? For many processors, only one memory
1037 operand can be present at a time, so the 2-entry cache wouldn't be
1038 constantly churned by code doing heavy memory accesses. */
1040 /* Indices in `sorted_syms'. */
1042 long max_count = sorted_symcount;
1044 struct objdump_disasm_info *aux;
1048 bfd_boolean want_section;
1051 if (sorted_symcount < 1)
1054 aux = (struct objdump_disasm_info *) inf->application_data;
1057 opb = inf->octets_per_byte;
1059 /* Perform a binary search looking for the closest symbol to the
1060 required value. We are searching the range (min, max_count]. */
1061 while (min + 1 < max_count)
1065 thisplace = (max_count + min) / 2;
1066 sym = sorted_syms[thisplace];
1068 if (bfd_asymbol_value (sym) > vma)
1069 max_count = thisplace;
1070 else if (bfd_asymbol_value (sym) < vma)
1079 /* The symbol we want is now in min, the low end of the range we
1080 were searching. If there are several symbols with the same
1081 value, we want the first (non-section/non-debugging) one. */
1083 while (thisplace > 0
1084 && (bfd_asymbol_value (sorted_syms[thisplace])
1085 == bfd_asymbol_value (sorted_syms[thisplace - 1]))
1086 && ((sorted_syms[thisplace - 1]->flags
1087 & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
1091 /* Prefer a symbol in the current section if we have multple symbols
1092 with the same value, as can occur with overlays or zero size
1095 while (min < max_count
1096 && (bfd_asymbol_value (sorted_syms[min])
1097 == bfd_asymbol_value (sorted_syms[thisplace])))
1099 if (sym_ok (TRUE, abfd, min, sec, inf))
1106 return sorted_syms[thisplace];
1111 /* If the file is relocatable, and the symbol could be from this
1112 section, prefer a symbol from this section over symbols from
1113 others, even if the other symbol's value might be closer.
1115 Note that this may be wrong for some symbol references if the
1116 sections have overlapping memory ranges, but in that case there's
1117 no way to tell what's desired without looking at the relocation
1120 Also give the target a chance to reject symbols. */
1121 want_section = (aux->require_sec
1122 || ((abfd->flags & HAS_RELOC) != 0
1123 && vma >= bfd_get_section_vma (abfd, sec)
1124 && vma < (bfd_get_section_vma (abfd, sec)
1125 + bfd_section_size (abfd, sec) / opb)));
1127 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1130 long newplace = sorted_symcount;
1132 for (i = min - 1; i >= 0; i--)
1134 if (sym_ok (want_section, abfd, i, sec, inf))
1136 if (newplace == sorted_symcount)
1139 if (bfd_asymbol_value (sorted_syms[i])
1140 != bfd_asymbol_value (sorted_syms[newplace]))
1143 /* Remember this symbol and keep searching until we reach
1144 an earlier address. */
1149 if (newplace != sorted_symcount)
1150 thisplace = newplace;
1153 /* We didn't find a good symbol with a smaller value.
1154 Look for one with a larger value. */
1155 for (i = thisplace + 1; i < sorted_symcount; i++)
1157 if (sym_ok (want_section, abfd, i, sec, inf))
1165 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1166 /* There is no suitable symbol. */
1170 /* If we have not found an exact match for the specified address
1171 and we have dynamic relocations available, then we can produce
1172 a better result by matching a relocation to the address and
1173 using the symbol associated with that relocation. */
1174 rel_count = aux->dynrelcount;
1176 && sorted_syms[thisplace]->value != vma
1178 && aux->dynrelbuf != NULL
1179 && aux->dynrelbuf[0]->address <= vma
1180 && aux->dynrelbuf[rel_count - 1]->address >= vma
1181 /* If we have matched a synthetic symbol, then stick with that. */
1182 && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
1185 arelent ** rel_high;
1187 rel_low = aux->dynrelbuf;
1188 rel_high = rel_low + rel_count - 1;
1189 while (rel_low <= rel_high)
1191 arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
1192 arelent * rel = *rel_mid;
1194 if (rel->address == vma)
1196 /* Absolute relocations do not provide a more helpful
1197 symbolic address. Find a non-absolute relocation
1198 with the same address. */
1199 arelent **rel_vma = rel_mid;
1201 rel_mid >= rel_low && rel_mid[0]->address == vma;
1205 for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
1209 if (rel->sym_ptr_ptr != NULL
1210 && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
1213 * place = thisplace;
1214 return * rel->sym_ptr_ptr;
1220 if (vma < rel->address)
1222 else if (vma >= rel_mid[1]->address)
1223 rel_low = rel_mid + 1;
1232 return sorted_syms[thisplace];
1235 /* Print an address and the offset to the nearest symbol. */
1238 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
1239 bfd_vma vma, struct disassemble_info *inf,
1240 bfd_boolean skip_zeroes)
1242 objdump_print_value (vma, inf, skip_zeroes);
1248 (*inf->fprintf_func) (inf->stream, " <%s",
1249 sanitize_string (bfd_get_section_name (abfd, sec)));
1250 secaddr = bfd_get_section_vma (abfd, sec);
1253 (*inf->fprintf_func) (inf->stream, "-0x");
1254 objdump_print_value (secaddr - vma, inf, TRUE);
1256 else if (vma > secaddr)
1258 (*inf->fprintf_func) (inf->stream, "+0x");
1259 objdump_print_value (vma - secaddr, inf, TRUE);
1261 (*inf->fprintf_func) (inf->stream, ">");
1265 (*inf->fprintf_func) (inf->stream, " <");
1267 objdump_print_symname (abfd, inf, sym);
1269 if (bfd_asymbol_value (sym) == vma)
1271 /* Undefined symbols in an executables and dynamic objects do not have
1272 a value associated with them, so it does not make sense to display
1273 an offset relative to them. Normally we would not be provided with
1274 this kind of symbol, but the target backend might choose to do so,
1275 and the code in find_symbol_for_address might return an as yet
1276 unresolved symbol associated with a dynamic reloc. */
1277 else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
1278 && bfd_is_und_section (sym->section))
1280 else if (bfd_asymbol_value (sym) > vma)
1282 (*inf->fprintf_func) (inf->stream, "-0x");
1283 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1285 else if (vma > bfd_asymbol_value (sym))
1287 (*inf->fprintf_func) (inf->stream, "+0x");
1288 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1291 (*inf->fprintf_func) (inf->stream, ">");
1294 if (display_file_offsets)
1295 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1296 (long int)(sec->filepos + (vma - sec->vma)));
1299 /* Print an address (VMA), symbolically if possible.
1300 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1303 objdump_print_addr (bfd_vma vma,
1304 struct disassemble_info *inf,
1305 bfd_boolean skip_zeroes)
1307 struct objdump_disasm_info *aux;
1308 asymbol *sym = NULL;
1309 bfd_boolean skip_find = FALSE;
1311 aux = (struct objdump_disasm_info *) inf->application_data;
1313 if (sorted_symcount < 1)
1315 (*inf->fprintf_func) (inf->stream, "0x");
1316 objdump_print_value (vma, inf, skip_zeroes);
1318 if (display_file_offsets)
1319 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1320 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1324 if (aux->reloc != NULL
1325 && aux->reloc->sym_ptr_ptr != NULL
1326 && * aux->reloc->sym_ptr_ptr != NULL)
1328 sym = * aux->reloc->sym_ptr_ptr;
1330 /* Adjust the vma to the reloc. */
1331 vma += bfd_asymbol_value (sym);
1333 if (bfd_is_und_section (bfd_get_section (sym)))
1338 sym = find_symbol_for_address (vma, inf, NULL);
1340 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1344 /* Print VMA to INFO. This function is passed to the disassembler
1348 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1350 objdump_print_addr (vma, inf, ! prefix_addresses);
1353 /* Determine if the given address has a symbol associated with it. */
1356 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1360 sym = find_symbol_for_address (vma, inf, NULL);
1362 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1365 /* Hold the last function name and the last line number we displayed
1366 in a disassembly. */
1368 static char *prev_functionname;
1369 static unsigned int prev_line;
1370 static unsigned int prev_discriminator;
1372 /* We keep a list of all files that we have seen when doing a
1373 disassembly with source, so that we know how much of the file to
1374 display. This can be important for inlined functions. */
1376 struct print_file_list
1378 struct print_file_list *next;
1379 const char *filename;
1380 const char *modname;
1383 const char **linemap;
1386 unsigned max_printed;
1390 static struct print_file_list *print_files;
1392 /* The number of preceding context lines to show when we start
1393 displaying a file for the first time. */
1395 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1397 /* Read a complete file into memory. */
1400 slurp_file (const char *fn, size_t *size, struct stat *fst)
1403 int ps = getpagesize ();
1407 int fd = open (fn, O_RDONLY | O_BINARY);
1411 if (fstat (fd, fst) < 0)
1416 *size = fst->st_size;
1418 msize = (*size + ps - 1) & ~(ps - 1);
1419 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1420 if (map != (char *) -1L)
1426 map = (const char *) malloc (*size);
1427 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1429 free ((void *) map);
1436 #define line_map_decrease 5
1438 /* Precompute array of lines for a mapped file. */
1440 static const char **
1441 index_file (const char *map, size_t size, unsigned int *maxline)
1443 const char *p, *lstart, *end;
1444 int chars_per_line = 45; /* First iteration will use 40. */
1445 unsigned int lineno;
1446 const char **linemap = NULL;
1447 unsigned long line_map_size = 0;
1453 for (p = map; p < end; p++)
1457 if (p + 1 < end && p[1] == '\r')
1460 else if (*p == '\r')
1462 if (p + 1 < end && p[1] == '\n')
1468 /* End of line found. */
1470 if (linemap == NULL || line_map_size < lineno + 1)
1472 unsigned long newsize;
1474 chars_per_line -= line_map_decrease;
1475 if (chars_per_line <= 1)
1477 line_map_size = size / chars_per_line + 1;
1478 if (line_map_size < lineno + 1)
1479 line_map_size = lineno + 1;
1480 newsize = line_map_size * sizeof (char *);
1481 linemap = (const char **) xrealloc (linemap, newsize);
1484 linemap[lineno++] = lstart;
1492 /* Tries to open MODNAME, and if successful adds a node to print_files
1493 linked list and returns that node. Returns NULL on failure. */
1495 static struct print_file_list *
1496 try_print_file_open (const char *origname, const char *modname, struct stat *fst)
1498 struct print_file_list *p;
1500 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1502 p->map = slurp_file (modname, &p->mapsize, fst);
1509 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1512 p->filename = origname;
1513 p->modname = modname;
1514 p->next = print_files;
1520 /* If the source file, as described in the symtab, is not found
1521 try to locate it in one of the paths specified with -I
1522 If found, add location to print_files linked list. */
1524 static struct print_file_list *
1525 update_source_path (const char *filename, bfd *abfd)
1527 struct print_file_list *p;
1532 p = try_print_file_open (filename, filename, &fst);
1535 if (include_path_count == 0)
1538 /* Get the name of the file. */
1539 fname = lbasename (filename);
1541 /* If file exists under a new path, we need to add it to the list
1542 so that show_line knows about it. */
1543 for (i = 0; i < include_path_count; i++)
1545 char *modname = concat (include_paths[i], "/", fname,
1548 p = try_print_file_open (filename, modname, &fst);
1558 long mtime = bfd_get_mtime (abfd);
1560 if (fst.st_mtime > mtime)
1561 warn (_("source file %s is more recent than object file\n"),
1568 /* Print a source file line. */
1571 print_line (struct print_file_list *p, unsigned int linenum)
1577 if (linenum >= p->maxline)
1579 l = p->linemap [linenum];
1580 /* Test fwrite return value to quiet glibc warning. */
1581 len = strcspn (l, "\n\r");
1582 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1586 /* Print a range of source code lines. */
1589 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1593 while (start <= end)
1595 print_line (p, start);
1600 /* Show the line number, or the source line, in a disassembly
1604 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1606 const char *filename;
1607 const char *functionname;
1608 unsigned int linenumber;
1609 unsigned int discriminator;
1613 if (! with_line_numbers && ! with_source_code)
1616 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1617 &filename, &functionname,
1618 &linenumber, &discriminator))
1621 if (filename != NULL && *filename == '\0')
1623 if (functionname != NULL && *functionname == '\0')
1624 functionname = NULL;
1627 && IS_ABSOLUTE_PATH (filename)
1631 const char *fname = filename;
1633 path = xmalloc (prefix_length + PATH_MAX + 1);
1636 memcpy (path, prefix, prefix_length);
1637 path_up = path + prefix_length;
1639 /* Build relocated filename, stripping off leading directories
1640 from the initial filename if requested. */
1641 if (prefix_strip > 0)
1646 /* Skip selected directory levels. */
1647 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1648 if (IS_DIR_SEPARATOR(*s))
1655 /* Update complete filename. */
1656 strncpy (path_up, fname, PATH_MAX);
1657 path_up[PATH_MAX] = '\0';
1665 if (with_line_numbers)
1667 if (functionname != NULL
1668 && (prev_functionname == NULL
1669 || strcmp (functionname, prev_functionname) != 0))
1671 printf ("%s():\n", sanitize_string (functionname));
1675 && (linenumber != prev_line
1676 || discriminator != prev_discriminator))
1678 if (discriminator > 0)
1679 printf ("%s:%u (discriminator %u)\n",
1680 filename == NULL ? "???" : sanitize_string (filename),
1681 linenumber, discriminator);
1683 printf ("%s:%u\n", filename == NULL
1684 ? "???" : sanitize_string (filename),
1689 const char *filename2;
1690 const char *functionname2;
1693 while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
1696 printf ("inlined by %s:%u",
1697 sanitize_string (filename2), line2);
1698 printf (" (%s)\n", sanitize_string (functionname2));
1703 if (with_source_code
1707 struct print_file_list **pp, *p;
1710 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1711 if (filename_cmp ((*pp)->filename, filename) == 0)
1718 filename = xstrdup (filename);
1719 p = update_source_path (filename, abfd);
1722 if (p != NULL && linenumber != p->last_line)
1724 if (file_start_context && p->first)
1728 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1729 if (l >= linenumber)
1731 if (p->max_printed >= l)
1733 if (p->max_printed < linenumber)
1734 l = p->max_printed + 1;
1739 dump_lines (p, l, linenumber);
1740 if (p->max_printed < linenumber)
1741 p->max_printed = linenumber;
1742 p->last_line = linenumber;
1747 if (functionname != NULL
1748 && (prev_functionname == NULL
1749 || strcmp (functionname, prev_functionname) != 0))
1751 if (prev_functionname != NULL)
1752 free (prev_functionname);
1753 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1754 strcpy (prev_functionname, functionname);
1757 if (linenumber > 0 && linenumber != prev_line)
1758 prev_line = linenumber;
1760 if (discriminator != prev_discriminator)
1761 prev_discriminator = discriminator;
1767 /* Pseudo FILE object for strings. */
1775 /* sprintf to a "stream". */
1777 static int ATTRIBUTE_PRINTF_2
1778 objdump_sprintf (SFILE *f, const char *format, ...)
1785 size_t space = f->alloc - f->pos;
1787 va_start (args, format);
1788 n = vsnprintf (f->buffer + f->pos, space, format, args);
1794 f->alloc = (f->alloc + n) * 2;
1795 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1802 /* The number of zeroes we want to see before we start skipping them.
1803 The number is arbitrarily chosen. */
1805 #define DEFAULT_SKIP_ZEROES 8
1807 /* The number of zeroes to skip at the end of a section. If the
1808 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1809 SKIP_ZEROES, they will be disassembled. If there are fewer than
1810 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1811 attempt to avoid disassembling zeroes inserted by section
1814 #define DEFAULT_SKIP_ZEROES_AT_END 3
1816 /* Disassemble some data in memory between given values. */
1819 disassemble_bytes (struct disassemble_info * inf,
1820 disassembler_ftype disassemble_fn,
1823 bfd_vma start_offset,
1824 bfd_vma stop_offset,
1827 arelent ** relppend)
1829 struct objdump_disasm_info *aux;
1831 int octets_per_line;
1832 int skip_addr_chars;
1833 bfd_vma addr_offset;
1834 unsigned int opb = inf->octets_per_byte;
1835 unsigned int skip_zeroes = inf->skip_zeroes;
1836 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1840 aux = (struct objdump_disasm_info *) inf->application_data;
1844 sfile.buffer = (char *) xmalloc (sfile.alloc);
1848 octets_per_line = insn_width;
1850 octets_per_line = 4;
1852 octets_per_line = 16;
1854 /* Figure out how many characters to skip at the start of an
1855 address, to make the disassembly look nicer. We discard leading
1856 zeroes in chunks of 4, ensuring that there is always a leading
1858 skip_addr_chars = 0;
1859 if (! prefix_addresses)
1863 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1865 while (buf[skip_addr_chars] == '0')
1868 /* Don't discard zeros on overflow. */
1869 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1870 skip_addr_chars = 0;
1872 if (skip_addr_chars != 0)
1873 skip_addr_chars = (skip_addr_chars - 1) & -4;
1876 inf->insn_info_valid = 0;
1878 addr_offset = start_offset;
1879 while (addr_offset < stop_offset)
1882 bfd_boolean need_nl = FALSE;
1883 int previous_octets;
1885 /* Remember the length of the previous instruction. */
1886 previous_octets = octets;
1889 /* Make sure we don't use relocs from previous instructions. */
1892 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1894 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1897 if (! disassemble_zeroes
1898 && (inf->insn_info_valid == 0
1899 || inf->branch_delay_insns == 0)
1900 && (z - addr_offset * opb >= skip_zeroes
1901 || (z == stop_offset * opb &&
1902 z - addr_offset * opb < skip_zeroes_at_end)))
1904 /* If there are more nonzero octets to follow, we only skip
1905 zeroes in multiples of 4, to try to avoid running over
1906 the start of an instruction which happens to start with
1908 if (z != stop_offset * opb)
1909 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1911 octets = z - addr_offset * opb;
1913 /* If we are going to display more data, and we are displaying
1914 file offsets, then tell the user how many zeroes we skip
1915 and the file offset from where we resume dumping. */
1916 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1917 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1919 (unsigned long) (section->filepos
1920 + (addr_offset + (octets / opb))));
1930 if (with_line_numbers || with_source_code)
1931 show_line (aux->abfd, section, addr_offset);
1933 if (! prefix_addresses)
1937 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1938 for (s = buf + skip_addr_chars; *s == '0'; s++)
1942 printf ("%s:\t", buf + skip_addr_chars);
1946 aux->require_sec = TRUE;
1947 objdump_print_address (section->vma + addr_offset, inf);
1948 aux->require_sec = FALSE;
1955 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1956 inf->stream = &sfile;
1957 inf->bytes_per_line = 0;
1958 inf->bytes_per_chunk = 0;
1959 inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
1960 | (wide_output ? WIDE_OUTPUT : 0));
1962 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1964 if (inf->disassembler_needs_relocs
1965 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1966 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1967 && *relppp < relppend)
1969 bfd_signed_vma distance_to_rel;
1971 distance_to_rel = (**relppp)->address
1972 - (rel_offset + addr_offset);
1974 /* Check to see if the current reloc is associated with
1975 the instruction that we are about to disassemble. */
1976 if (distance_to_rel == 0
1977 /* FIXME: This is wrong. We are trying to catch
1978 relocs that are addressed part way through the
1979 current instruction, as might happen with a packed
1980 VLIW instruction. Unfortunately we do not know the
1981 length of the current instruction since we have not
1982 disassembled it yet. Instead we take a guess based
1983 upon the length of the previous instruction. The
1984 proper solution is to have a new target-specific
1985 disassembler function which just returns the length
1986 of an instruction at a given address without trying
1987 to display its disassembly. */
1988 || (distance_to_rel > 0
1989 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1991 inf->flags |= INSN_HAS_RELOC;
1992 aux->reloc = **relppp;
1996 if (! disassemble_all
1997 && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1998 == (SEC_CODE | SEC_HAS_CONTENTS))
1999 /* Set a stop_vma so that the disassembler will not read
2000 beyond the next symbol. We assume that symbols appear on
2001 the boundaries between instructions. We only do this when
2002 disassembling code of course, and when -D is in effect. */
2003 inf->stop_vma = section->vma + stop_offset;
2005 inf->stop_offset = stop_offset;
2006 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
2009 inf->fprintf_func = (fprintf_ftype) fprintf;
2010 inf->stream = stdout;
2011 if (insn_width == 0 && inf->bytes_per_line != 0)
2012 octets_per_line = inf->bytes_per_line;
2013 if (octets < (int) opb)
2016 printf ("%s\n", sfile.buffer);
2019 non_fatal (_("disassemble_fn returned length %d"),
2030 octets = octets_per_line;
2031 if (addr_offset + octets / opb > stop_offset)
2032 octets = (stop_offset - addr_offset) * opb;
2034 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
2036 if (ISPRINT (data[j]))
2037 buf[j - addr_offset * opb] = data[j];
2039 buf[j - addr_offset * opb] = '.';
2041 buf[j - addr_offset * opb] = '\0';
2044 if (prefix_addresses
2046 : show_raw_insn >= 0)
2050 /* If ! prefix_addresses and ! wide_output, we print
2051 octets_per_line octets per line. */
2053 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
2054 pb = octets_per_line;
2056 if (inf->bytes_per_chunk)
2057 bpc = inf->bytes_per_chunk;
2061 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
2063 /* PR 21580: Check for a buffer ending early. */
2064 if (j + bpc <= stop_offset * opb)
2068 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2070 for (k = bpc - 1; k >= 0; k--)
2071 printf ("%02x", (unsigned) data[j + k]);
2075 for (k = 0; k < bpc; k++)
2076 printf ("%02x", (unsigned) data[j + k]);
2082 for (; pb < octets_per_line; pb += bpc)
2086 for (k = 0; k < bpc; k++)
2091 /* Separate raw data from instruction by extra space. */
2101 printf ("%s", sfile.buffer);
2103 if (prefix_addresses
2105 : show_raw_insn >= 0)
2113 j = addr_offset * opb + pb;
2115 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
2116 for (s = buf + skip_addr_chars; *s == '0'; s++)
2120 printf ("%s:\t", buf + skip_addr_chars);
2122 pb += octets_per_line;
2125 for (; j < addr_offset * opb + pb; j += bpc)
2127 /* PR 21619: Check for a buffer ending early. */
2128 if (j + bpc <= stop_offset * opb)
2132 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2134 for (k = bpc - 1; k >= 0; k--)
2135 printf ("%02x", (unsigned) data[j + k]);
2139 for (k = 0; k < bpc; k++)
2140 printf ("%02x", (unsigned) data[j + k]);
2154 while ((*relppp) < relppend
2155 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
2157 if (dump_reloc_info || dump_dynamic_reloc_info)
2168 objdump_print_value (section->vma - rel_offset + q->address,
2171 if (q->howto == NULL)
2172 printf (": *unknown*\t");
2173 else if (q->howto->name)
2174 printf (": %s\t", q->howto->name);
2176 printf (": %d\t", q->howto->type);
2178 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
2179 printf ("*unknown*");
2182 const char *sym_name;
2184 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
2185 if (sym_name != NULL && *sym_name != '\0')
2186 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
2191 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
2192 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
2193 if (sym_name == NULL || *sym_name == '\0')
2194 sym_name = "*unknown*";
2195 printf ("%s", sanitize_string (sym_name));
2201 bfd_signed_vma addend = q->addend;
2209 objdump_print_value (addend, inf, TRUE);
2221 addr_offset += octets / opb;
2224 free (sfile.buffer);
2228 disassemble_section (bfd *abfd, asection *section, void *inf)
2230 const struct elf_backend_data * bed;
2231 bfd_vma sign_adjust = 0;
2232 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
2233 struct objdump_disasm_info * paux;
2234 unsigned int opb = pinfo->octets_per_byte;
2235 bfd_byte * data = NULL;
2236 bfd_size_type datasize = 0;
2237 arelent ** rel_pp = NULL;
2238 arelent ** rel_ppstart = NULL;
2239 arelent ** rel_ppend;
2240 bfd_vma stop_offset;
2241 asymbol * sym = NULL;
2245 unsigned long addr_offset;
2246 bfd_boolean do_print;
2249 stop_offset_reached,
2254 /* Sections that do not contain machine
2255 code are not normally disassembled. */
2256 if (! disassemble_all
2257 && only_list == NULL
2258 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2259 != (SEC_CODE | SEC_HAS_CONTENTS)))
2262 if (! process_section_p (section))
2265 datasize = bfd_get_section_size (section);
2269 if (start_address == (bfd_vma) -1
2270 || start_address < section->vma)
2273 addr_offset = start_address - section->vma;
2275 if (stop_address == (bfd_vma) -1)
2276 stop_offset = datasize / opb;
2279 if (stop_address < section->vma)
2282 stop_offset = stop_address - section->vma;
2283 if (stop_offset > datasize / opb)
2284 stop_offset = datasize / opb;
2287 if (addr_offset >= stop_offset)
2290 /* Decide which set of relocs to use. Load them if necessary. */
2291 paux = (struct objdump_disasm_info *) pinfo->application_data;
2292 if (paux->dynrelbuf && dump_dynamic_reloc_info)
2294 rel_pp = paux->dynrelbuf;
2295 rel_count = paux->dynrelcount;
2296 /* Dynamic reloc addresses are absolute, non-dynamic are section
2297 relative. REL_OFFSET specifies the reloc address corresponding
2298 to the start of this section. */
2299 rel_offset = section->vma;
2307 if ((section->flags & SEC_RELOC) != 0
2308 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2312 relsize = bfd_get_reloc_upper_bound (abfd, section);
2314 bfd_fatal (bfd_get_filename (abfd));
2318 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2319 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2321 bfd_fatal (bfd_get_filename (abfd));
2323 /* Sort the relocs by address. */
2324 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2328 rel_ppend = rel_pp + rel_count;
2330 if (!bfd_malloc_and_get_section (abfd, section, &data))
2332 non_fatal (_("Reading section %s failed because: %s"),
2333 section->name, bfd_errmsg (bfd_get_error ()));
2337 paux->sec = section;
2338 pinfo->buffer = data;
2339 pinfo->buffer_vma = section->vma;
2340 pinfo->buffer_length = datasize;
2341 pinfo->section = section;
2343 /* Skip over the relocs belonging to addresses below the
2345 while (rel_pp < rel_ppend
2346 && (*rel_pp)->address < rel_offset + addr_offset)
2349 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
2351 /* Find the nearest symbol forwards from our current position. */
2352 paux->require_sec = TRUE;
2353 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2354 (struct disassemble_info *) inf,
2356 paux->require_sec = FALSE;
2358 /* PR 9774: If the target used signed addresses then we must make
2359 sure that we sign extend the value that we calculate for 'addr'
2360 in the loop below. */
2361 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2362 && (bed = get_elf_backend_data (abfd)) != NULL
2363 && bed->sign_extend_vma)
2364 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2366 /* Disassemble a block of instructions up to the address associated with
2367 the symbol we have just found. Then print the symbol and find the
2368 next symbol on. Repeat until we have disassembled the entire section
2369 or we have reached the end of the address range we are interested in. */
2370 do_print = paux->symbol == NULL;
2371 loop_until = stop_offset_reached;
2373 while (addr_offset < stop_offset)
2377 bfd_vma nextstop_offset;
2380 addr = section->vma + addr_offset;
2381 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2383 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2388 (x < sorted_symcount
2389 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2393 pinfo->symbols = sorted_syms + place;
2394 pinfo->num_symbols = x - place;
2395 pinfo->symtab_pos = place;
2399 pinfo->symbols = NULL;
2400 pinfo->num_symbols = 0;
2401 pinfo->symtab_pos = -1;
2404 /* If we are only disassembling from a specific symbol,
2405 check to see if we should start or stop displaying. */
2406 if (sym && paux->symbol)
2410 /* See if we should stop printing. */
2414 if (sym->flags & BSF_FUNCTION)
2418 case stop_offset_reached:
2419 /* Handled by the while loop. */
2423 /* FIXME: There is an implicit assumption here
2424 that the name of sym is different from
2426 if (! bfd_is_local_label (abfd, sym))
2433 const char * name = bfd_asymbol_name (sym);
2434 char * alloc = NULL;
2436 if (do_demangle && name[0] != '\0')
2438 /* Demangle the name. */
2439 alloc = bfd_demangle (abfd, name, demangle_flags);
2444 /* We are not currently printing. Check to see
2445 if the current symbol matches the requested symbol. */
2446 if (streq (name, paux->symbol))
2450 if (sym->flags & BSF_FUNCTION)
2452 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2453 && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
2455 /* Sym is a function symbol with a size associated
2456 with it. Turn on automatic disassembly for the
2457 next VALUE bytes. */
2458 stop_offset = addr_offset
2459 + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
2460 loop_until = stop_offset_reached;
2464 /* Otherwise we need to tell the loop heuristic to
2465 loop until the next function symbol is encountered. */
2466 loop_until = function_sym;
2471 /* Otherwise loop until the next symbol is encountered. */
2472 loop_until = next_sym;
2480 if (! prefix_addresses && do_print)
2482 pinfo->fprintf_func (pinfo->stream, "\n");
2483 objdump_print_addr_with_sym (abfd, section, sym, addr,
2485 pinfo->fprintf_func (pinfo->stream, ":\n");
2488 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2490 else if (sym == NULL)
2494 #define is_valid_next_sym(SYM) \
2495 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2496 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2497 && pinfo->symbol_is_valid (SYM, pinfo))
2499 /* Search forward for the next appropriate symbol in
2500 SECTION. Note that all the symbols are sorted
2501 together into one big array, and that some sections
2502 may have overlapping addresses. */
2503 while (place < sorted_symcount
2504 && ! is_valid_next_sym (sorted_syms [place]))
2507 if (place >= sorted_symcount)
2510 nextsym = sorted_syms[place];
2513 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2514 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2515 else if (nextsym == NULL)
2516 nextstop_offset = stop_offset;
2518 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2520 if (nextstop_offset > stop_offset
2521 || nextstop_offset <= addr_offset)
2522 nextstop_offset = stop_offset;
2524 /* If a symbol is explicitly marked as being an object
2525 rather than a function, just dump the bytes without
2526 disassembling them. */
2529 || sym->section != section
2530 || bfd_asymbol_value (sym) > addr
2531 || ((sym->flags & BSF_OBJECT) == 0
2532 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2534 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2536 || (sym->flags & BSF_FUNCTION) != 0)
2542 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2543 addr_offset, nextstop_offset,
2544 rel_offset, &rel_pp, rel_ppend);
2546 addr_offset = nextstop_offset;
2552 if (rel_ppstart != NULL)
2556 /* Disassemble the contents of an object file. */
2559 disassemble_data (bfd *abfd)
2561 struct disassemble_info disasm_info;
2562 struct objdump_disasm_info aux;
2566 prev_functionname = NULL;
2568 prev_discriminator = 0;
2570 /* We make a copy of syms to sort. We don't want to sort syms
2571 because that will screw up the relocs. */
2572 sorted_symcount = symcount ? symcount : dynsymcount;
2573 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2574 * sizeof (asymbol *));
2575 memcpy (sorted_syms, symcount ? syms : dynsyms,
2576 sorted_symcount * sizeof (asymbol *));
2578 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2580 for (i = 0; i < synthcount; ++i)
2582 sorted_syms[sorted_symcount] = synthsyms + i;
2586 /* Sort the symbols into section and symbol order. */
2587 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2589 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2591 disasm_info.application_data = (void *) &aux;
2593 aux.require_sec = FALSE;
2594 aux.dynrelbuf = NULL;
2595 aux.dynrelcount = 0;
2597 aux.symbol = disasm_sym;
2599 disasm_info.print_address_func = objdump_print_address;
2600 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2602 if (machine != NULL)
2604 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2607 fatal (_("can't use supplied machine %s"), machine);
2609 abfd->arch_info = inf;
2612 if (endian != BFD_ENDIAN_UNKNOWN)
2614 struct bfd_target *xvec;
2616 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2617 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2618 xvec->byteorder = endian;
2622 /* Use libopcodes to locate a suitable disassembler. */
2623 aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
2624 bfd_big_endian (abfd),
2625 bfd_get_mach (abfd), abfd);
2626 if (!aux.disassemble_fn)
2628 non_fatal (_("can't disassemble for architecture %s\n"),
2629 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2634 disasm_info.flavour = bfd_get_flavour (abfd);
2635 disasm_info.arch = bfd_get_arch (abfd);
2636 disasm_info.mach = bfd_get_mach (abfd);
2637 disasm_info.disassembler_options = disassembler_options;
2638 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2639 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2640 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2641 disasm_info.disassembler_needs_relocs = FALSE;
2643 if (bfd_big_endian (abfd))
2644 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2645 else if (bfd_little_endian (abfd))
2646 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2648 /* ??? Aborting here seems too drastic. We could default to big or little
2650 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2652 /* Allow the target to customize the info structure. */
2653 disassemble_init_for_target (& disasm_info);
2655 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2657 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2659 if (relsize < 0 && dump_dynamic_reloc_info)
2660 bfd_fatal (bfd_get_filename (abfd));
2664 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2665 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2668 if (aux.dynrelcount < 0)
2669 bfd_fatal (bfd_get_filename (abfd));
2671 /* Sort the relocs by address. */
2672 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2676 disasm_info.symtab = sorted_syms;
2677 disasm_info.symtab_size = sorted_symcount;
2679 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2681 if (aux.dynrelbuf != NULL)
2682 free (aux.dynrelbuf);
2687 load_specific_debug_section (enum dwarf_section_display_enum debug,
2688 asection *sec, void *file)
2690 struct dwarf_section *section = &debug_displays [debug].section;
2691 bfd *abfd = (bfd *) file;
2696 if (section->start != NULL)
2698 /* If it is already loaded, do nothing. */
2699 if (streq (section->filename, bfd_get_filename (abfd)))
2701 free (section->start);
2704 section->filename = bfd_get_filename (abfd);
2705 section->reloc_info = NULL;
2706 section->num_relocs = 0;
2707 section->address = bfd_get_section_vma (abfd, sec);
2708 section->user_data = sec;
2709 section->size = bfd_get_section_size (sec);
2710 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2711 alloced = amt = section->size + 1;
2712 if (alloced != amt || alloced == 0)
2714 section->start = NULL;
2715 free_debug_section (debug);
2716 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2717 sanitize_string (section->name),
2718 (unsigned long long) section->size);
2721 section->start = contents = malloc (alloced);
2722 if (section->start == NULL
2723 || !bfd_get_full_section_contents (abfd, sec, &contents))
2725 free_debug_section (debug);
2726 printf (_("\nCan't get contents for section '%s'.\n"),
2727 sanitize_string (section->name));
2730 /* Ensure any string section has a terminating NUL. */
2731 section->start[section->size] = 0;
2733 if (is_relocatable && debug_displays [debug].relocate)
2738 bfd_cache_section_contents (sec, section->start);
2740 ret = bfd_simple_get_relocated_section_contents (abfd,
2747 free_debug_section (debug);
2748 printf (_("\nCan't get contents for section '%s'.\n"),
2749 sanitize_string (section->name));
2753 reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2756 unsigned long reloc_count;
2759 relocs = (arelent **) xmalloc (reloc_size);
2761 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2762 if (reloc_count == 0)
2766 section->reloc_info = relocs;
2767 section->num_relocs = reloc_count;
2776 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2781 if (dsec == NULL || dsec->reloc_info == NULL)
2784 relocs = (arelent **) dsec->reloc_info;
2786 for (; (rp = * relocs) != NULL; ++ relocs)
2787 if (rp->address == offset)
2794 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2796 struct dwarf_section *section = &debug_displays [debug].section;
2797 bfd *abfd = (bfd *) file;
2800 /* If it is already loaded, do nothing. */
2801 if (section->start != NULL)
2803 if (streq (section->filename, bfd_get_filename (abfd)))
2807 /* Locate the debug section. */
2808 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2810 section->name = section->uncompressed_name;
2813 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2815 section->name = section->compressed_name;
2820 return load_specific_debug_section (debug, sec, file);
2824 free_debug_section (enum dwarf_section_display_enum debug)
2826 struct dwarf_section *section = &debug_displays [debug].section;
2828 if (section->start == NULL)
2831 /* PR 17512: file: 0f67f69d. */
2832 if (section->user_data != NULL)
2834 asection * sec = (asection *) section->user_data;
2836 /* If we are freeing contents that are also pointed to by the BFD
2837 library's section structure then make sure to update those pointers
2838 too. Otherwise, the next time we try to load data for this section
2839 we can end up using a stale pointer. */
2840 if (section->start == sec->contents)
2842 sec->contents = NULL;
2843 sec->flags &= ~ SEC_IN_MEMORY;
2844 sec->compress_status = COMPRESS_SECTION_NONE;
2848 free ((char *) section->start);
2849 section->start = NULL;
2850 section->address = 0;
2855 close_debug_file (void * file)
2857 bfd * abfd = (bfd *) file;
2863 open_debug_file (const char * pathname)
2867 data = bfd_openr (pathname, NULL);
2871 if (! bfd_check_format (data, bfd_object))
2878 dump_dwarf_section (bfd *abfd, asection *section,
2879 void *arg ATTRIBUTE_UNUSED)
2881 const char *name = bfd_get_section_name (abfd, section);
2885 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2886 match = ".debug_info";
2890 for (i = 0; i < max; i++)
2891 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2892 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2893 && debug_displays [i].enabled != NULL
2894 && *debug_displays [i].enabled)
2896 struct dwarf_section *sec = &debug_displays [i].section;
2898 if (strcmp (sec->uncompressed_name, match) == 0)
2899 sec->name = sec->uncompressed_name;
2901 sec->name = sec->compressed_name;
2902 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2905 debug_displays [i].display (sec, abfd);
2907 if (i != info && i != abbrev)
2908 free_debug_section ((enum dwarf_section_display_enum) i);
2914 /* Dump the dwarf debugging information. */
2917 dump_dwarf (bfd *abfd)
2919 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2920 if (byte_get == NULL)
2922 warn (_("File %s does not contain any dwarf debug information\n"),
2923 bfd_get_filename (abfd));
2927 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2929 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2931 switch (bfd_get_arch (abfd))
2934 switch (bfd_get_mach (abfd))
2936 case bfd_mach_x86_64:
2937 case bfd_mach_x86_64_intel_syntax:
2938 case bfd_mach_x86_64_nacl:
2939 case bfd_mach_x64_32:
2940 case bfd_mach_x64_32_intel_syntax:
2941 case bfd_mach_x64_32_nacl:
2942 init_dwarf_regnames_x86_64 ();
2946 init_dwarf_regnames_i386 ();
2951 case bfd_arch_iamcu:
2952 init_dwarf_regnames_iamcu ();
2955 case bfd_arch_aarch64:
2956 init_dwarf_regnames_aarch64();
2960 init_dwarf_regnames_s390 ();
2963 case bfd_arch_riscv:
2964 init_dwarf_regnames_riscv ();
2968 /* S12Z has a 24 bit address space. But the only known
2969 producer of dwarf_info encodes addresses into 32 bits. */
2977 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2980 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2981 it. Return NULL on failure. */
2984 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr,
2985 bfd_size_type *entsize_ptr)
2990 stabsect = bfd_get_section_by_name (abfd, sect_name);
2991 if (stabsect == NULL)
2993 printf (_("No %s section present\n\n"),
2994 sanitize_string (sect_name));
2998 if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
3000 non_fatal (_("reading %s section of %s failed: %s"),
3001 sect_name, bfd_get_filename (abfd),
3002 bfd_errmsg (bfd_get_error ()));
3008 *size_ptr = bfd_section_size (abfd, stabsect);
3010 *entsize_ptr = stabsect->entsize;
3015 /* Stabs entries use a 12 byte format:
3016 4 byte string table index
3018 1 byte stab other field
3019 2 byte stab desc field
3021 FIXME: This will have to change for a 64 bit object format. */
3023 #define STRDXOFF (0)
3025 #define OTHEROFF (5)
3028 #define STABSIZE (12)
3030 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3031 using string table section STRSECT_NAME (in `strtab'). */
3034 print_section_stabs (bfd *abfd,
3035 const char *stabsect_name,
3036 unsigned *string_offset_ptr)
3039 unsigned file_string_table_offset = 0;
3040 unsigned next_file_string_table_offset = *string_offset_ptr;
3041 bfd_byte *stabp, *stabs_end;
3044 stabs_end = stabp + stab_size;
3046 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
3047 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3049 /* Loop through all symbols and print them.
3051 We start the index at -1 because there is a dummy symbol on
3052 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3053 for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
3057 unsigned char type, other;
3058 unsigned short desc;
3061 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3062 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3063 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3064 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3065 value = bfd_h_get_32 (abfd, stabp + VALOFF);
3067 printf ("\n%-6d ", i);
3068 /* Either print the stab name, or, if unnamed, print its number
3069 again (makes consistent formatting for tools like awk). */
3070 name = bfd_get_stab_name (type);
3072 printf ("%-6s", sanitize_string (name));
3073 else if (type == N_UNDF)
3076 printf ("%-6d", type);
3077 printf (" %-6d %-6d ", other, desc);
3078 bfd_printf_vma (abfd, value);
3079 printf (" %-6lu", strx);
3081 /* Symbols with type == 0 (N_UNDF) specify the length of the
3082 string table associated with this file. We use that info
3083 to know how to relocate the *next* file's string table indices. */
3086 file_string_table_offset = next_file_string_table_offset;
3087 next_file_string_table_offset += value;
3091 bfd_size_type amt = strx + file_string_table_offset;
3093 /* Using the (possibly updated) string table offset, print the
3094 string (if any) associated with this symbol. */
3095 if (amt < stabstr_size)
3096 /* PR 17512: file: 079-79389-0.001:0.1.
3097 FIXME: May need to sanitize this string before displaying. */
3098 printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
3104 *string_offset_ptr = next_file_string_table_offset;
3109 const char * section_name;
3110 const char * string_section_name;
3111 unsigned string_offset;
3116 find_stabs_section (bfd *abfd, asection *section, void *names)
3119 stab_section_names * sought = (stab_section_names *) names;
3121 /* Check for section names for which stabsect_name is a prefix, to
3122 handle .stab.N, etc. */
3123 len = strlen (sought->section_name);
3125 /* If the prefix matches, and the files section name ends with a
3126 nul or a digit, then we match. I.e., we want either an exact
3127 match or a section followed by a number. */
3128 if (strncmp (sought->section_name, section->name, len) == 0
3129 && (section->name[len] == 0
3130 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
3133 strtab = read_section_stabs (abfd, sought->string_section_name,
3134 &stabstr_size, NULL);
3138 stabs = read_section_stabs (abfd, section->name, &stab_size, NULL);
3140 print_section_stabs (abfd, section->name, &sought->string_offset);
3146 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3148 stab_section_names s;
3150 s.section_name = stabsect_name;
3151 s.string_section_name = strsect_name;
3152 s.string_offset = 0;
3154 bfd_map_over_sections (abfd, find_stabs_section, & s);
3160 /* Dump the any sections containing stabs debugging information. */
3163 dump_stabs (bfd *abfd)
3165 dump_stabs_section (abfd, ".stab", ".stabstr");
3166 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3167 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
3170 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3172 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3176 dump_bfd_header (bfd *abfd)
3180 printf (_("architecture: %s, "),
3181 bfd_printable_arch_mach (bfd_get_arch (abfd),
3182 bfd_get_mach (abfd)));
3183 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
3185 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3186 PF (HAS_RELOC, "HAS_RELOC");
3187 PF (EXEC_P, "EXEC_P");
3188 PF (HAS_LINENO, "HAS_LINENO");
3189 PF (HAS_DEBUG, "HAS_DEBUG");
3190 PF (HAS_SYMS, "HAS_SYMS");
3191 PF (HAS_LOCALS, "HAS_LOCALS");
3192 PF (DYNAMIC, "DYNAMIC");
3193 PF (WP_TEXT, "WP_TEXT");
3194 PF (D_PAGED, "D_PAGED");
3195 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3196 printf (_("\nstart address 0x"));
3197 bfd_printf_vma (abfd, abfd->start_address);
3202 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3203 it is passed, or a pointer to newly-allocated storage, in which case
3204 dump_ctf() will free it when it no longer needs it. */
3207 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
3210 const char *blanks = arg;
3213 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
3218 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3220 make_ctfsect (const char *name, bfd_byte *data,
3225 ctfsect.cts_name = name;
3226 ctfsect.cts_entsize = 1;
3227 ctfsect.cts_size = size;
3228 ctfsect.cts_data = data;
3233 /* Dump one CTF archive member. */
3236 dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
3238 ctf_file_t *parent = (ctf_file_t *) arg;
3239 const char *things[] = {"Labels", "Data objects", "Function objects",
3240 "Variables", "Types", "Strings", ""};
3244 /* Only print out the name of non-default-named archive members.
3245 The name .ctf appears everywhere, even for things that aren't
3246 really archives, so printing it out is liable to be confusing. */
3247 if (strcmp (name, ".ctf") != 0)
3248 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
3250 ctf_import (ctf, parent);
3251 for (i = 1, thing = things; *thing[0]; thing++, i++)
3253 ctf_dump_state_t *s = NULL;
3256 printf ("\n %s:\n", *thing);
3257 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
3258 (void *) " ")) != NULL)
3260 printf ("%s\n", item);
3264 if (ctf_errno (ctf))
3266 non_fatal (_("Iteration failed: %s, %s\n"), *thing,
3267 ctf_errmsg (ctf_errno (ctf)));
3274 /* Dump the CTF debugging information. */
3277 dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
3279 ctf_archive_t *ctfa, *parenta = NULL;
3280 bfd_byte *ctfdata, *parentdata = NULL;
3281 bfd_size_type ctfsize, parentsize;
3283 ctf_file_t *parent = NULL;
3286 if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
3287 bfd_fatal (bfd_get_filename (abfd));
3290 && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
3292 bfd_fatal (bfd_get_filename (abfd));
3294 /* Load the CTF file and dump it. */
3296 ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
3297 if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3299 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3300 bfd_fatal (bfd_get_filename (abfd));
3305 ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
3306 if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3308 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3309 bfd_fatal (bfd_get_filename (abfd));
3312 /* Assume that the applicable parent archive member is the default one.
3313 (This is what all known implementations are expected to do, if they
3314 put CTFs and their parents in archives together.) */
3315 if ((parent = ctf_arc_open_by_name (parenta, NULL, &err)) == NULL)
3317 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3318 bfd_fatal (bfd_get_filename (abfd));
3322 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
3324 ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
3325 ctf_file_close (parent);
3327 ctf_close (parenta);
3334 dump_bfd_private_header (bfd *abfd)
3336 if (!bfd_print_private_bfd_data (abfd, stdout))
3337 non_fatal (_("warning: private headers incomplete: %s"),
3338 bfd_errmsg (bfd_get_error ()));
3342 dump_target_specific (bfd *abfd)
3344 const struct objdump_private_desc * const *desc;
3345 struct objdump_private_option *opt;
3348 /* Find the desc. */
3349 for (desc = objdump_private_vectors; *desc != NULL; desc++)
3350 if ((*desc)->filter (abfd))
3355 non_fatal (_("option -P/--private not supported by this file"));
3359 /* Clear all options. */
3360 for (opt = (*desc)->options; opt->name; opt++)
3361 opt->selected = FALSE;
3363 /* Decode options. */
3364 b = dump_private_options;
3367 e = strchr (b, ',');
3372 for (opt = (*desc)->options; opt->name; opt++)
3373 if (strcmp (opt->name, b) == 0)
3375 opt->selected = TRUE;
3378 if (opt->name == NULL)
3379 non_fatal (_("target specific dump '%s' not supported"), b);
3390 (*desc)->dump (abfd);
3393 /* Display a section in hexadecimal format with associated characters.
3394 Each line prefixed by the zero padded address. */
3397 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3399 bfd_byte *data = NULL;
3400 bfd_size_type datasize;
3401 bfd_vma addr_offset;
3402 bfd_vma start_offset;
3403 bfd_vma stop_offset;
3404 unsigned int opb = bfd_octets_per_byte (abfd);
3405 /* Bytes per line. */
3406 const int onaline = 16;
3411 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3414 if (! process_section_p (section))
3417 if ((datasize = bfd_section_size (abfd, section)) == 0)
3420 /* Compute the address range to display. */
3421 if (start_address == (bfd_vma) -1
3422 || start_address < section->vma)
3425 start_offset = start_address - section->vma;
3427 if (stop_address == (bfd_vma) -1)
3428 stop_offset = datasize / opb;
3431 if (stop_address < section->vma)
3434 stop_offset = stop_address - section->vma;
3436 if (stop_offset > datasize / opb)
3437 stop_offset = datasize / opb;
3440 if (start_offset >= stop_offset)
3443 printf (_("Contents of section %s:"), sanitize_string (section->name));
3444 if (display_file_offsets)
3445 printf (_(" (Starting at file offset: 0x%lx)"),
3446 (unsigned long) (section->filepos + start_offset));
3449 if (!bfd_get_full_section_contents (abfd, section, &data))
3451 non_fatal (_("Reading section %s failed because: %s"),
3452 section->name, bfd_errmsg (bfd_get_error ()));
3458 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3459 if (strlen (buf) >= sizeof (buf))
3463 while (buf[count] == '0' && buf[count+1] != '\0')
3465 count = strlen (buf) - count;
3469 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3470 if (strlen (buf) >= sizeof (buf))
3474 while (buf[count] == '0' && buf[count+1] != '\0')
3476 count = strlen (buf) - count;
3480 for (addr_offset = start_offset;
3481 addr_offset < stop_offset; addr_offset += onaline / opb)
3485 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3486 count = strlen (buf);
3487 if ((size_t) count >= sizeof (buf))
3491 while (count < width)
3496 fputs (buf + count - width, stdout);
3499 for (j = addr_offset * opb;
3500 j < addr_offset * opb + onaline; j++)
3502 if (j < stop_offset * opb)
3503 printf ("%02x", (unsigned) (data[j]));
3511 for (j = addr_offset * opb;
3512 j < addr_offset * opb + onaline; j++)
3514 if (j >= stop_offset * opb)
3517 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3524 /* Actually display the various requested regions. */
3527 dump_data (bfd *abfd)
3529 bfd_map_over_sections (abfd, dump_section, NULL);
3532 /* Should perhaps share code and display with nm? */
3535 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3544 max_count = dynsymcount;
3545 printf ("DYNAMIC SYMBOL TABLE:\n");
3550 max_count = symcount;
3551 printf ("SYMBOL TABLE:\n");
3555 printf (_("no symbols\n"));
3557 for (count = 0; count < max_count; count++)
3561 if (*current == NULL)
3562 printf (_("no information for symbol number %ld\n"), count);
3564 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3565 printf (_("could not determine the type of symbol number %ld\n"),
3568 else if (process_section_p ((* current)->section)
3569 && (dump_special_syms
3570 || !bfd_is_target_special_symbol (cur_bfd, *current)))
3572 const char *name = (*current)->name;
3574 if (do_demangle && name != NULL && *name != '\0')
3578 /* If we want to demangle the name, we demangle it
3579 here, and temporarily clobber it while calling
3580 bfd_print_symbol. FIXME: This is a gross hack. */
3581 alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3583 (*current)->name = alloc;
3584 bfd_print_symbol (cur_bfd, stdout, *current,
3585 bfd_print_symbol_all);
3588 (*current)->name = name;
3593 bfd_print_symbol (cur_bfd, stdout, *current,
3594 bfd_print_symbol_all);
3604 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3607 char *last_filename, *last_functionname;
3608 unsigned int last_line;
3609 unsigned int last_discriminator;
3611 /* Get column headers lined up reasonably. */
3619 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3620 width = strlen (buf) - 7;
3622 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3625 last_filename = NULL;
3626 last_functionname = NULL;
3628 last_discriminator = 0;
3630 for (p = relpp; relcount && *p != NULL; p++, relcount--)
3633 const char *filename, *functionname;
3634 unsigned int linenumber;
3635 unsigned int discriminator;
3636 const char *sym_name;
3637 const char *section_name;
3638 bfd_vma addend2 = 0;
3640 if (start_address != (bfd_vma) -1
3641 && q->address < start_address)
3643 if (stop_address != (bfd_vma) -1
3644 && q->address > stop_address)
3647 if (with_line_numbers
3649 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3650 &filename, &functionname,
3651 &linenumber, &discriminator))
3653 if (functionname != NULL
3654 && (last_functionname == NULL
3655 || strcmp (functionname, last_functionname) != 0))
3657 printf ("%s():\n", sanitize_string (functionname));
3658 if (last_functionname != NULL)
3659 free (last_functionname);
3660 last_functionname = xstrdup (functionname);
3664 && (linenumber != last_line
3665 || (filename != NULL
3666 && last_filename != NULL
3667 && filename_cmp (filename, last_filename) != 0)
3668 || (discriminator != last_discriminator)))
3670 if (discriminator > 0)
3671 printf ("%s:%u\n", filename == NULL ? "???" :
3672 sanitize_string (filename), linenumber);
3674 printf ("%s:%u (discriminator %u)\n",
3675 filename == NULL ? "???" : sanitize_string (filename),
3676 linenumber, discriminator);
3677 last_line = linenumber;
3678 last_discriminator = discriminator;
3679 if (last_filename != NULL)
3680 free (last_filename);
3681 if (filename == NULL)
3682 last_filename = NULL;
3684 last_filename = xstrdup (filename);
3688 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3690 sym_name = (*(q->sym_ptr_ptr))->name;
3691 section_name = (*(q->sym_ptr_ptr))->section->name;
3696 section_name = NULL;
3699 bfd_printf_vma (abfd, q->address);
3700 if (q->howto == NULL)
3701 printf (" *unknown* ");
3702 else if (q->howto->name)
3704 const char *name = q->howto->name;
3706 /* R_SPARC_OLO10 relocations contain two addends.
3707 But because 'arelent' lacks enough storage to
3708 store them both, the 64-bit ELF Sparc backend
3709 records this as two relocations. One R_SPARC_LO10
3710 and one R_SPARC_13, both pointing to the same
3711 address. This is merely so that we have some
3712 place to store both addend fields.
3714 Undo this transformation, otherwise the output
3715 will be confusing. */
3716 if (abfd->xvec->flavour == bfd_target_elf_flavour
3717 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3719 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3721 arelent *q2 = *(p + 1);
3724 && q->address == q2->address
3725 && !strcmp (q2->howto->name, "R_SPARC_13"))
3727 name = "R_SPARC_OLO10";
3728 addend2 = q2->addend;
3732 printf (" %-16s ", name);
3735 printf (" %-16d ", q->howto->type);
3739 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3743 if (section_name == NULL)
3744 section_name = "*unknown*";
3745 printf ("[%s]", sanitize_string (section_name));
3750 bfd_signed_vma addend = q->addend;
3758 bfd_printf_vma (abfd, addend);
3763 bfd_printf_vma (abfd, addend2);
3769 if (last_filename != NULL)
3770 free (last_filename);
3771 if (last_functionname != NULL)
3772 free (last_functionname);
3776 dump_relocs_in_section (bfd *abfd,
3778 void *dummy ATTRIBUTE_UNUSED)
3780 arelent **relpp = NULL;
3784 if ( bfd_is_abs_section (section)
3785 || bfd_is_und_section (section)
3786 || bfd_is_com_section (section)
3787 || (! process_section_p (section))
3788 || ((section->flags & SEC_RELOC) == 0))
3791 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3793 relsize = bfd_get_reloc_upper_bound (abfd, section);
3796 printf (" (none)\n\n");
3804 relpp = (arelent **) xmalloc (relsize);
3805 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3811 non_fatal (_("failed to read relocs in: %s"),
3812 sanitize_string (bfd_get_filename (abfd)));
3813 bfd_fatal (_("error message was"));
3815 else if (relcount == 0)
3816 printf (" (none)\n\n");
3820 dump_reloc_set (abfd, section, relpp, relcount);
3827 dump_relocs (bfd *abfd)
3829 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3833 dump_dynamic_relocs (bfd *abfd)
3839 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3841 bfd_fatal (bfd_get_filename (abfd));
3843 printf ("DYNAMIC RELOCATION RECORDS");
3846 printf (" (none)\n\n");
3849 relpp = (arelent **) xmalloc (relsize);
3850 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3853 bfd_fatal (bfd_get_filename (abfd));
3854 else if (relcount == 0)
3855 printf (" (none)\n\n");
3859 dump_reloc_set (abfd, NULL, relpp, relcount);
3866 /* Creates a table of paths, to search for source files. */
3869 add_include_path (const char *path)
3873 include_path_count++;
3874 include_paths = (const char **)
3875 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3876 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3877 if (path[1] == ':' && path[2] == 0)
3878 path = concat (path, ".", (const char *) 0);
3880 include_paths[include_path_count - 1] = path;
3884 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3888 if ((section->flags & SEC_DEBUGGING) == 0)
3890 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3891 section->vma += adjust_section_vma;
3893 section->lma += adjust_section_vma;
3897 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3900 sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
3905 mask = (bfd_vma) 1 << (arch_size - 1);
3906 return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
3909 /* Dump selected contents of ABFD. */
3912 dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
3914 const struct elf_backend_data * bed;
3916 if (bfd_big_endian (abfd))
3917 byte_get = byte_get_big_endian;
3918 else if (bfd_little_endian (abfd))
3919 byte_get = byte_get_little_endian;
3923 /* Load any separate debug information files.
3924 We do this now and without checking do_follow_links because separate
3925 debug info files may contain symbol tables that we will need when
3926 displaying information about the main file. Any memory allocated by
3927 load_separate_debug_files will be released when we call
3928 free_debug_memory below.
3930 The test on is_mainfile is there because the chain of separate debug
3931 info files is a global variable shared by all invocations of dump_bfd. */
3934 load_separate_debug_files (abfd, bfd_get_filename (abfd));
3936 /* If asked to do so, recursively dump the separate files. */
3937 if (do_follow_links)
3941 for (i = first_separate_info; i != NULL; i = i->next)
3942 dump_bfd (i->handle, FALSE);
3946 /* Adjust user-specified start and stop limits for targets that use
3947 signed addresses. */
3948 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
3949 && (bed = get_elf_backend_data (abfd)) != NULL
3950 && bed->sign_extend_vma)
3952 start_address = sign_extend_address (abfd, start_address,
3954 stop_address = sign_extend_address (abfd, stop_address,
3958 /* If we are adjusting section VMA's, change them all now. Changing
3959 the BFD information is a hack. However, we must do it, or
3960 bfd_find_nearest_line will not do the right thing. */
3961 if (adjust_section_vma != 0)
3963 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3964 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3967 if (! dump_debugging_tags && ! suppress_bfd_header)
3968 printf (_("\n%s: file format %s\n"),
3969 sanitize_string (bfd_get_filename (abfd)),
3972 print_arelt_descr (stdout, abfd, TRUE, FALSE);
3973 if (dump_file_header)
3974 dump_bfd_header (abfd);
3975 if (dump_private_headers)
3976 dump_bfd_private_header (abfd);
3977 if (dump_private_options != NULL)
3978 dump_target_specific (abfd);
3979 if (! dump_debugging_tags && ! suppress_bfd_header)
3986 || dump_dwarf_section_info)
3988 syms = slurp_symtab (abfd);
3990 /* If following links, load any symbol tables from the linked files as well. */
3991 if (do_follow_links && is_mainfile)
3995 for (i = first_separate_info; i != NULL; i = i->next)
3997 asymbol ** extra_syms;
3998 long old_symcount = symcount;
4000 extra_syms = slurp_symtab (i->handle);
4004 if (old_symcount == 0)
4010 syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
4011 memcpy (syms + old_symcount,
4013 symcount * sizeof (asymbol *));
4017 symcount += old_symcount;
4022 if (dump_section_headers)
4023 dump_headers (abfd);
4025 if (dump_dynamic_symtab || dump_dynamic_reloc_info
4026 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
4027 dynsyms = slurp_dynamic_symtab (abfd);
4031 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
4032 dynsymcount, dynsyms, &synthsyms);
4038 dump_symbols (abfd, FALSE);
4039 if (dump_dynamic_symtab)
4040 dump_symbols (abfd, TRUE);
4041 if (dump_dwarf_section_info)
4043 if (dump_ctf_section_info)
4044 dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
4045 if (dump_stab_section_info)
4047 if (dump_reloc_info && ! disassemble)
4049 if (dump_dynamic_reloc_info && ! disassemble)
4050 dump_dynamic_relocs (abfd);
4051 if (dump_section_contents)
4054 disassemble_data (abfd);
4060 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
4061 if (dhandle != NULL)
4063 if (!print_debugging_info (stdout, dhandle, abfd, syms,
4065 dump_debugging_tags ? TRUE : FALSE))
4067 non_fatal (_("%s: printing debugging information failed"),
4068 bfd_get_filename (abfd));
4074 /* PR 6483: If there was no STABS debug info in the file, try
4076 else if (! dump_dwarf_section_info)
4078 dwarf_select_sections_all ();
4106 free_debug_memory ();
4110 display_object_bfd (bfd *abfd)
4114 if (bfd_check_format_matches (abfd, bfd_object, &matching))
4116 dump_bfd (abfd, TRUE);
4120 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4122 nonfatal (bfd_get_filename (abfd));
4123 list_matching_formats (matching);
4128 if (bfd_get_error () != bfd_error_file_not_recognized)
4130 nonfatal (bfd_get_filename (abfd));
4134 if (bfd_check_format_matches (abfd, bfd_core, &matching))
4136 dump_bfd (abfd, TRUE);
4140 nonfatal (bfd_get_filename (abfd));
4142 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4144 list_matching_formats (matching);
4150 display_any_bfd (bfd *file, int level)
4152 /* Decompress sections unless dumping the section contents. */
4153 if (!dump_section_contents)
4154 file->flags |= BFD_DECOMPRESS;
4156 /* If the file is an archive, process all of its elements. */
4157 if (bfd_check_format (file, bfd_archive))
4160 bfd *last_arfile = NULL;
4163 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
4164 else if (level > 100)
4166 /* Prevent corrupted files from spinning us into an
4167 infinite loop. 100 is an arbitrary heuristic. */
4168 fatal (_("Archive nesting is too deep"));
4172 printf (_("In nested archive %s:\n"),
4173 sanitize_string (bfd_get_filename (file)));
4177 bfd_set_error (bfd_error_no_error);
4179 arfile = bfd_openr_next_archived_file (file, arfile);
4182 if (bfd_get_error () != bfd_error_no_more_archived_files)
4183 nonfatal (bfd_get_filename (file));
4187 display_any_bfd (arfile, level + 1);
4189 if (last_arfile != NULL)
4191 bfd_close (last_arfile);
4192 /* PR 17512: file: ac585d01. */
4193 if (arfile == last_arfile)
4199 last_arfile = arfile;
4202 if (last_arfile != NULL)
4203 bfd_close (last_arfile);
4206 display_object_bfd (file);
4210 display_file (char *filename, char *target, bfd_boolean last_file)
4214 if (get_file_size (filename) < 1)
4220 file = bfd_openr (filename, target);
4223 nonfatal (filename);
4227 display_any_bfd (file, 0);
4229 /* This is an optimization to improve the speed of objdump, especially when
4230 dumping a file with lots of associated debug informatiom. Calling
4231 bfd_close on such a file can take a non-trivial amount of time as there
4232 are lots of lists to walk and buffers to free. This is only really
4233 necessary however if we are about to load another file and we need the
4234 memory back. Otherwise, if we are about to exit, then we can save (a lot
4235 of) time by only doing a quick close, and allowing the OS to reclaim the
4240 bfd_close_all_done (file);
4244 main (int argc, char **argv)
4247 char *target = default_target;
4248 bfd_boolean seenflag = FALSE;
4250 #if defined (HAVE_SETLOCALE)
4251 #if defined (HAVE_LC_MESSAGES)
4252 setlocale (LC_MESSAGES, "");
4254 setlocale (LC_CTYPE, "");
4257 bindtextdomain (PACKAGE, LOCALEDIR);
4258 textdomain (PACKAGE);
4260 program_name = *argv;
4261 xmalloc_set_program_name (program_name);
4262 bfd_set_error_program_name (program_name);
4264 START_PROGRESS (program_name, 0);
4266 expandargv (&argc, &argv);
4268 if (bfd_init () != BFD_INIT_MAGIC)
4269 fatal (_("fatal error: libbfd ABI mismatch"));
4270 set_default_bfd_target ();
4272 while ((c = getopt_long (argc, argv,
4273 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4274 long_options, (int *) 0))
4280 break; /* We've been given a long option. */
4287 if (disassembler_options)
4288 /* Ignore potential memory leak for now. */
4289 options = concat (disassembler_options, ",",
4290 optarg, (const char *) NULL);
4293 disassembler_options = remove_whitespace_and_extra_commas (options);
4300 display_file_offsets = TRUE;
4303 with_line_numbers = TRUE;
4312 enum demangling_styles style;
4314 style = cplus_demangle_name_to_style (optarg);
4315 if (style == unknown_demangling)
4316 fatal (_("unknown demangling style `%s'"),
4319 cplus_demangle_set_style (style);
4322 case OPTION_RECURSE_LIMIT:
4323 demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4325 case OPTION_NO_RECURSE_LIMIT:
4326 demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4329 do_wide = wide_output = TRUE;
4331 case OPTION_ADJUST_VMA:
4332 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4334 case OPTION_START_ADDRESS:
4335 start_address = parse_vma (optarg, "--start-address");
4336 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4337 fatal (_("error: the start address should be before the end address"));
4339 case OPTION_STOP_ADDRESS:
4340 stop_address = parse_vma (optarg, "--stop-address");
4341 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4342 fatal (_("error: the stop address should be after the start address"));
4346 prefix_length = strlen (prefix);
4347 /* Remove an unnecessary trailing '/' */
4348 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4351 case OPTION_PREFIX_STRIP:
4352 prefix_strip = atoi (optarg);
4353 if (prefix_strip < 0)
4354 fatal (_("error: prefix strip must be non-negative"));
4356 case OPTION_INSN_WIDTH:
4357 insn_width = strtoul (optarg, NULL, 0);
4358 if (insn_width <= 0)
4359 fatal (_("error: instruction width must be positive"));
4361 case OPTION_INLINES:
4362 unwind_inlines = TRUE;
4365 if (strcmp (optarg, "B") == 0)
4366 endian = BFD_ENDIAN_BIG;
4367 else if (strcmp (optarg, "L") == 0)
4368 endian = BFD_ENDIAN_LITTLE;
4371 nonfatal (_("unrecognized -E option"));
4376 if (strncmp (optarg, "big", strlen (optarg)) == 0)
4377 endian = BFD_ENDIAN_BIG;
4378 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4379 endian = BFD_ENDIAN_LITTLE;
4382 non_fatal (_("unrecognized --endian type `%s'"), optarg);
4389 dump_file_header = TRUE;
4393 formats_info = TRUE;
4397 add_include_path (optarg);
4400 dump_private_headers = TRUE;
4404 dump_private_options = optarg;
4408 dump_private_headers = TRUE;
4410 dump_reloc_info = TRUE;
4411 dump_file_header = TRUE;
4412 dump_ar_hdrs = TRUE;
4413 dump_section_headers = TRUE;
4421 dump_dynamic_symtab = TRUE;
4427 disasm_sym = optarg;
4430 disassemble_zeroes = TRUE;
4434 disassemble_all = TRUE;
4439 with_source_code = TRUE;
4448 dump_debugging_tags = 1;
4453 dump_dwarf_section_info = TRUE;
4456 dwarf_select_sections_by_letters (optarg);
4458 dwarf_select_sections_all ();
4461 dump_dwarf_section_info = TRUE;
4464 dwarf_select_sections_by_names (optarg);
4466 dwarf_select_sections_all ();
4468 case OPTION_DWARF_DEPTH:
4471 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4474 case OPTION_DWARF_START:
4477 dwarf_start_die = strtoul (optarg, & cp, 0);
4478 suppress_bfd_header = 1;
4481 case OPTION_DWARF_CHECK:
4485 dump_ctf_section_info = TRUE;
4486 dump_ctf_section_name = xstrdup (optarg);
4489 case OPTION_CTF_PARENT:
4490 dump_ctf_parent_name = xstrdup (optarg);
4493 dump_stab_section_info = TRUE;
4497 dump_section_contents = TRUE;
4501 dump_reloc_info = TRUE;
4505 dump_dynamic_reloc_info = TRUE;
4509 dump_ar_hdrs = TRUE;
4513 dump_section_headers = TRUE;
4518 show_version = TRUE;
4524 /* No need to set seenflag or to break - usage() does not return. */
4531 print_version ("objdump");
4537 exit_status = display_info ();
4541 display_file ("a.out", target, TRUE);
4543 for (; optind < argc;)
4545 display_file (argv[optind], target, optind == argc - 1);
4551 free (dump_ctf_section_name);
4552 free (dump_ctf_parent_name);
4554 END_PROGRESS (program_name);