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. */
63 #include "safe-ctype.h"
65 #include "libiberty.h"
67 #include "filenames.h"
76 /* Internal headers for the ELF .stab-dump code - sorry. */
77 #define BYTES_IN_WORD 32
78 #include "aout/aout64.h"
81 static int exit_status = 0;
83 static char *default_target = NULL; /* Default at runtime. */
85 /* The following variables are set based on arguments passed on the
87 static int show_version = 0; /* Show the version number. */
88 static int dump_section_contents; /* -s */
89 static int dump_section_headers; /* -h */
90 static bfd_boolean dump_file_header; /* -f */
91 static int dump_symtab; /* -t */
92 static int dump_dynamic_symtab; /* -T */
93 static int dump_reloc_info; /* -r */
94 static int dump_dynamic_reloc_info; /* -R */
95 static int dump_ar_hdrs; /* -a */
96 static int dump_private_headers; /* -p */
97 static char *dump_private_options; /* -P */
98 static int prefix_addresses; /* --prefix-addresses */
99 static int with_line_numbers; /* -l */
100 static bfd_boolean with_source_code; /* -S */
101 static int show_raw_insn; /* --show-raw-insn */
102 static int dump_dwarf_section_info; /* --dwarf */
103 static int dump_stab_section_info; /* --stabs */
105 static int dump_ctf_section_info; /* --ctf */
106 static char *dump_ctf_section_name;
107 static char *dump_ctf_parent_name; /* --ctf-parent */
109 static int do_demangle; /* -C, --demangle */
110 static bfd_boolean disassemble; /* -d */
111 static bfd_boolean disassemble_all; /* -D */
112 static int disassemble_zeroes; /* --disassemble-zeroes */
113 static bfd_boolean formats_info; /* -i */
114 static int wide_output; /* -w */
115 static int insn_width; /* --insn-width */
116 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
117 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
118 static int dump_debugging; /* --debugging */
119 static int dump_debugging_tags; /* --debugging-tags */
120 static int suppress_bfd_header;
121 static int dump_special_syms = 0; /* --special-syms */
122 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
123 static int file_start_context = 0; /* --file-start-context */
124 static bfd_boolean display_file_offsets;/* -F */
125 static const char *prefix; /* --prefix */
126 static int prefix_strip; /* --prefix-strip */
127 static size_t prefix_length;
128 static bfd_boolean unwind_inlines; /* --inlines. */
129 static const char * disasm_sym; /* Disassembly start symbol. */
131 static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
133 /* A structure to record the sections mentioned in -j switches. */
136 const char * name; /* The name of the section. */
137 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
138 struct only * next; /* Pointer to the next structure in the list. */
140 /* Pointer to an array of 'only' structures.
141 This pointer is NULL if the -j switch has not been used. */
142 static struct only * only_list = NULL;
144 /* Variables for handling include file path table. */
145 static const char **include_paths;
146 static int include_path_count;
148 /* Extra info to pass to the section disassembler and address printing
150 struct objdump_disasm_info
154 bfd_boolean require_sec;
155 arelent ** dynrelbuf;
157 disassembler_ftype disassemble_fn;
162 /* Architecture to disassemble for, or default if NULL. */
163 static char *machine = NULL;
165 /* Target specific options to the disassembler. */
166 static char *disassembler_options = NULL;
168 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
169 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
171 /* The symbol table. */
172 static asymbol **syms;
174 /* Number of symbols in `syms'. */
175 static long symcount = 0;
177 /* The sorted symbol table. */
178 static asymbol **sorted_syms;
180 /* Number of symbols in `sorted_syms'. */
181 static long sorted_symcount = 0;
183 /* The dynamic symbol table. */
184 static asymbol **dynsyms;
186 /* The synthetic symbol table. */
187 static asymbol *synthsyms;
188 static long synthcount = 0;
190 /* Number of symbols in `dynsyms'. */
191 static long dynsymcount = 0;
193 static bfd_byte *stabs;
194 static bfd_size_type stab_size;
196 static bfd_byte *strtab;
197 static bfd_size_type stabstr_size;
199 static bfd_boolean is_relocatable = FALSE;
201 /* Handlers for -P/--private. */
202 static const struct objdump_private_desc * const objdump_private_vectors[] =
204 OBJDUMP_PRIVATE_VECTORS
208 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
210 usage (FILE *stream, int status)
212 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
213 fprintf (stream, _(" Display information from object <file(s)>.\n"));
214 fprintf (stream, _(" At least one of the following switches must be given:\n"));
215 fprintf (stream, _("\
216 -a, --archive-headers Display archive header information\n\
217 -f, --file-headers Display the contents of the overall file header\n\
218 -p, --private-headers Display object format specific file header contents\n\
219 -P, --private=OPT,OPT... Display object format specific contents\n\
220 -h, --[section-]headers Display the contents of the section headers\n\
221 -x, --all-headers Display the contents of all headers\n\
222 -d, --disassemble Display assembler contents of executable sections\n\
223 -D, --disassemble-all Display assembler contents of all sections\n\
224 --disassemble=<sym> Display assembler contents from <sym>\n\
225 -S, --source Intermix source code with disassembly\n\
226 -s, --full-contents Display the full contents of all sections requested\n\
227 -g, --debugging Display debug information in object file\n\
228 -e, --debugging-tags Display debug information using ctags style\n\
229 -G, --stabs Display (in raw form) any STABS info in the file\n\
230 -W[lLiaprmfFsoRtUuTgAckK] or\n\
231 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
232 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
233 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
234 =addr,=cu_index,=links,=follow-links]\n\
235 Display DWARF info in the file\n"));
237 fprintf (stream, _("\
238 --ctf=SECTION Display CTF info from SECTION\n"));
240 fprintf (stream, _("\
241 -t, --syms Display the contents of the symbol table(s)\n\
242 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
243 -r, --reloc Display the relocation entries in the file\n\
244 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
245 @<file> Read options from <file>\n\
246 -v, --version Display this program's version number\n\
247 -i, --info List object formats and architectures supported\n\
248 -H, --help Display this information\n\
252 const struct objdump_private_desc * const *desc;
254 fprintf (stream, _("\n The following switches are optional:\n"));
255 fprintf (stream, _("\
256 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
257 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
258 -j, --section=NAME Only display information for section NAME\n\
259 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
260 -EB --endian=big Assume big endian format when disassembling\n\
261 -EL --endian=little Assume little endian format when disassembling\n\
262 --file-start-context Include context from start of file (with -S)\n\
263 -I, --include=DIR Add DIR to search list for source files\n\
264 -l, --line-numbers Include line numbers and filenames in output\n\
265 -F, --file-offsets Include file offsets when displaying information\n\
266 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
267 The STYLE, if specified, can be `auto', `gnu',\n\
268 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
270 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
271 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
272 -w, --wide Format output for more than 80 columns\n\
273 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
274 --start-address=ADDR Only process data whose address is >= ADDR\n\
275 --stop-address=ADDR Only process data whose address is <= ADDR\n\
276 --prefix-addresses Print complete address alongside disassembly\n\
277 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
278 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
279 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
280 --special-syms Include special symbols in symbol dumps\n\
281 --inlines Print all inlines for source line (with -l)\n\
282 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
283 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
284 fprintf (stream, _("\
285 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
286 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
288 --dwarf-check Make additional dwarf internal consistency checks.\
291 fprintf (stream, _("\
292 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
294 list_supported_targets (program_name, stream);
295 list_supported_architectures (program_name, stream);
297 disassembler_usage (stream);
299 if (objdump_private_vectors[0] != NULL)
302 _("\nOptions supported for -P/--private switch:\n"));
303 for (desc = objdump_private_vectors; *desc != NULL; desc++)
304 (*desc)->help (stream);
307 if (REPORT_BUGS_TO[0] && status == 0)
308 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
312 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
316 OPTION_START_ADDRESS,
326 OPTION_RECURSE_LIMIT,
327 OPTION_NO_RECURSE_LIMIT,
335 static struct option long_options[]=
337 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
338 {"all-headers", no_argument, NULL, 'x'},
339 {"private-headers", no_argument, NULL, 'p'},
340 {"private", required_argument, NULL, 'P'},
341 {"architecture", required_argument, NULL, 'm'},
342 {"archive-headers", no_argument, NULL, 'a'},
343 {"debugging", no_argument, NULL, 'g'},
344 {"debugging-tags", no_argument, NULL, 'e'},
345 {"demangle", optional_argument, NULL, 'C'},
346 {"disassemble", optional_argument, NULL, 'd'},
347 {"disassemble-all", no_argument, NULL, 'D'},
348 {"disassembler-options", required_argument, NULL, 'M'},
349 {"disassemble-zeroes", no_argument, NULL, 'z'},
350 {"dynamic-reloc", no_argument, NULL, 'R'},
351 {"dynamic-syms", no_argument, NULL, 'T'},
352 {"endian", required_argument, NULL, OPTION_ENDIAN},
353 {"file-headers", no_argument, NULL, 'f'},
354 {"file-offsets", no_argument, NULL, 'F'},
355 {"file-start-context", no_argument, &file_start_context, 1},
356 {"full-contents", no_argument, NULL, 's'},
357 {"headers", no_argument, NULL, 'h'},
358 {"help", no_argument, NULL, 'H'},
359 {"info", no_argument, NULL, 'i'},
360 {"line-numbers", no_argument, NULL, 'l'},
361 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
362 {"prefix-addresses", no_argument, &prefix_addresses, 1},
363 {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
364 {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
365 {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
366 {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
367 {"reloc", no_argument, NULL, 'r'},
368 {"section", required_argument, NULL, 'j'},
369 {"section-headers", no_argument, NULL, 'h'},
370 {"show-raw-insn", no_argument, &show_raw_insn, 1},
371 {"source", no_argument, NULL, 'S'},
372 {"special-syms", no_argument, &dump_special_syms, 1},
373 {"include", required_argument, NULL, 'I'},
374 {"dwarf", optional_argument, NULL, OPTION_DWARF},
376 {"ctf", required_argument, NULL, OPTION_CTF},
377 {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
379 {"stabs", no_argument, NULL, 'G'},
380 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
381 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
382 {"syms", no_argument, NULL, 't'},
383 {"target", required_argument, NULL, 'b'},
384 {"version", no_argument, NULL, 'V'},
385 {"wide", no_argument, NULL, 'w'},
386 {"prefix", required_argument, NULL, OPTION_PREFIX},
387 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
388 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
389 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
390 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
391 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
392 {"inlines", no_argument, 0, OPTION_INLINES},
393 {0, no_argument, 0, 0}
397 nonfatal (const char *msg)
403 /* Returns a version of IN with any control characters
404 replaced by escape sequences. Uses a static buffer
408 sanitize_string (const char * in)
410 static char * buffer = NULL;
411 static size_t buffer_len = 0;
412 const char * original = in;
419 /* See if any conversion is necessary. In the majority
420 of cases it will not be needed. */
433 /* Copy the input, translating as needed. */
435 if (buffer_len < (strlen (in) * 2))
437 free ((void *) buffer);
438 buffer_len = strlen (in) * 2;
439 buffer = xmalloc (buffer_len + 1);
465 /* Returns TRUE if the specified section should be dumped. */
468 process_section_p (asection * section)
472 if (only_list == NULL)
475 for (only = only_list; only; only = only->next)
476 if (strcmp (only->name, section->name) == 0)
485 /* Add an entry to the 'only' list. */
488 add_only (char * name)
492 /* First check to make sure that we do not
493 already have an entry for this name. */
494 for (only = only_list; only; only = only->next)
495 if (strcmp (only->name, name) == 0)
498 only = xmalloc (sizeof * only);
501 only->next = only_list;
505 /* Release the memory used by the 'only' list.
506 PR 11225: Issue a warning message for unseen sections.
507 Only do this if none of the sections were seen. This is mainly to support
508 tools like the GAS testsuite where an object file is dumped with a list of
509 generic section names known to be present in a range of different file
513 free_only_list (void)
515 bfd_boolean at_least_one_seen = FALSE;
519 if (only_list == NULL)
522 for (only = only_list; only; only = only->next)
525 at_least_one_seen = TRUE;
529 for (only = only_list; only; only = next)
531 if (! at_least_one_seen)
533 non_fatal (_("section '%s' mentioned in a -j option, "
534 "but not found in any input file"),
545 dump_section_header (bfd *abfd, asection *section, void *data)
548 unsigned int opb = bfd_octets_per_byte (abfd);
549 int longest_section_name = *((int *) data);
551 /* Ignore linker created section. See elfNN_ia64_object_p in
553 if (section->flags & SEC_LINKER_CREATED)
556 /* PR 10413: Skip sections that we are ignoring. */
557 if (! process_section_p (section))
560 printf ("%3d %-*s %08lx ", section->index, longest_section_name,
561 sanitize_string (bfd_get_section_name (abfd, section)),
562 (unsigned long) bfd_section_size (abfd, section) / opb);
563 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
565 bfd_printf_vma (abfd, section->lma);
566 printf (" %08lx 2**%u", (unsigned long) section->filepos,
567 bfd_get_section_alignment (abfd, section));
573 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
575 PF (SEC_HAS_CONTENTS, "CONTENTS");
576 PF (SEC_ALLOC, "ALLOC");
577 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
578 PF (SEC_LOAD, "LOAD");
579 PF (SEC_RELOC, "RELOC");
580 PF (SEC_READONLY, "READONLY");
581 PF (SEC_CODE, "CODE");
582 PF (SEC_DATA, "DATA");
584 PF (SEC_DEBUGGING, "DEBUGGING");
585 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
586 PF (SEC_EXCLUDE, "EXCLUDE");
587 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
588 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
590 PF (SEC_TIC54X_BLOCK, "BLOCK");
591 PF (SEC_TIC54X_CLINK, "CLINK");
593 PF (SEC_SMALL_DATA, "SMALL_DATA");
594 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
596 PF (SEC_COFF_SHARED, "SHARED");
597 PF (SEC_COFF_NOREAD, "NOREAD");
599 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
600 PF (SEC_ELF_PURECODE, "PURECODE");
601 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
602 PF (SEC_GROUP, "GROUP");
603 if (bfd_get_arch (abfd) == bfd_arch_mep)
605 PF (SEC_MEP_VLIW, "VLIW");
608 if ((section->flags & SEC_LINK_ONCE) != 0)
611 struct coff_comdat_info *comdat;
613 switch (section->flags & SEC_LINK_DUPLICATES)
617 case SEC_LINK_DUPLICATES_DISCARD:
618 ls = "LINK_ONCE_DISCARD";
620 case SEC_LINK_DUPLICATES_ONE_ONLY:
621 ls = "LINK_ONCE_ONE_ONLY";
623 case SEC_LINK_DUPLICATES_SAME_SIZE:
624 ls = "LINK_ONCE_SAME_SIZE";
626 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
627 ls = "LINK_ONCE_SAME_CONTENTS";
630 printf ("%s%s", comma, ls);
632 comdat = bfd_coff_get_comdat_section (abfd, section);
634 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
643 /* Called on each SECTION in ABFD, update the int variable pointed to by
644 DATA which contains the string length of the longest section name. */
647 find_longest_section_name (bfd *abfd, asection *section, void *data)
649 int *longest_so_far = (int *) data;
653 /* Ignore linker created section. */
654 if (section->flags & SEC_LINKER_CREATED)
657 /* Skip sections that we are ignoring. */
658 if (! process_section_p (section))
661 name = bfd_get_section_name (abfd, section);
662 len = (int) strlen (name);
663 if (len > *longest_so_far)
664 *longest_so_far = len;
668 dump_headers (bfd *abfd)
670 /* The default width of 13 is just an arbitrary choice. */
671 int max_section_name_length = 13;
677 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
678 if (bfd_get_arch_size (abfd) == 32)
684 printf (_("Sections:\n"));
687 bfd_map_over_sections (abfd, find_longest_section_name,
688 &max_section_name_length);
690 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
691 max_section_name_length, "Name",
692 bfd_vma_width, "VMA",
693 bfd_vma_width, "LMA");
696 printf (_(" Flags"));
699 bfd_map_over_sections (abfd, dump_section_header,
700 &max_section_name_length);
704 slurp_symtab (bfd *abfd)
709 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
715 storage = bfd_get_symtab_upper_bound (abfd);
718 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
719 bfd_fatal (_("error message was"));
722 sy = (asymbol **) xmalloc (storage);
724 symcount = bfd_canonicalize_symtab (abfd, sy);
726 bfd_fatal (bfd_get_filename (abfd));
730 /* Read in the dynamic symbols. */
733 slurp_dynamic_symtab (bfd *abfd)
738 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
741 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
743 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
749 bfd_fatal (bfd_get_filename (abfd));
752 sy = (asymbol **) xmalloc (storage);
754 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
756 bfd_fatal (bfd_get_filename (abfd));
760 /* Some symbol names are significant and should be kept in the
761 table of sorted symbol names, even if they are marked as
762 debugging/section symbols. */
765 is_significant_symbol_name (const char * name)
767 return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
770 /* Filter out (in place) symbols that are useless for disassembly.
771 COUNT is the number of elements in SYMBOLS.
772 Return the number of useful symbols. */
775 remove_useless_symbols (asymbol **symbols, long count)
777 asymbol **in_ptr = symbols, **out_ptr = symbols;
781 asymbol *sym = *in_ptr++;
783 if (sym->name == NULL || sym->name[0] == '\0')
785 if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
786 && ! is_significant_symbol_name (sym->name))
788 if (bfd_is_und_section (sym->section)
789 || bfd_is_com_section (sym->section))
794 return out_ptr - symbols;
797 /* Sort symbols into value order. */
800 compare_symbols (const void *ap, const void *bp)
802 const asymbol *a = * (const asymbol **) ap;
803 const asymbol *b = * (const asymbol **) bp;
813 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
815 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
818 if (a->section > b->section)
820 else if (a->section < b->section)
823 an = bfd_asymbol_name (a);
824 bn = bfd_asymbol_name (b);
828 /* The symbols gnu_compiled and gcc2_compiled convey no real
829 information, so put them after other symbols with the same value. */
830 af = (strstr (an, "gnu_compiled") != NULL
831 || strstr (an, "gcc2_compiled") != NULL);
832 bf = (strstr (bn, "gnu_compiled") != NULL
833 || strstr (bn, "gcc2_compiled") != NULL);
840 /* We use a heuristic for the file name, to try to sort it after
841 more useful symbols. It may not work on non Unix systems, but it
842 doesn't really matter; the only difference is precisely which
843 symbol names get printed. */
845 #define file_symbol(s, sn, snl) \
846 (((s)->flags & BSF_FILE) != 0 \
847 || ((sn)[(snl) - 2] == '.' \
848 && ((sn)[(snl) - 1] == 'o' \
849 || (sn)[(snl) - 1] == 'a')))
851 af = file_symbol (a, an, anl);
852 bf = file_symbol (b, bn, bnl);
859 /* Try to sort global symbols before local symbols before function
860 symbols before debugging symbols. */
865 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
867 if ((aflags & BSF_DEBUGGING) != 0)
872 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
874 if ((aflags & BSF_FUNCTION) != 0)
879 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
881 if ((aflags & BSF_LOCAL) != 0)
886 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
888 if ((aflags & BSF_GLOBAL) != 0)
894 if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
895 && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
900 if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
901 asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
903 if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
904 bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
906 return asz > bsz ? -1 : 1;
909 /* Symbols that start with '.' might be section names, so sort them
910 after symbols that don't start with '.'. */
911 if (an[0] == '.' && bn[0] != '.')
913 if (an[0] != '.' && bn[0] == '.')
916 /* Finally, if we can't distinguish them in any other way, try to
917 get consistent results by sorting the symbols by name. */
918 return strcmp (an, bn);
921 /* Sort relocs into address order. */
924 compare_relocs (const void *ap, const void *bp)
926 const arelent *a = * (const arelent **) ap;
927 const arelent *b = * (const arelent **) bp;
929 if (a->address > b->address)
931 else if (a->address < b->address)
934 /* So that associated relocations tied to the same address show up
935 in the correct order, we don't do any further sorting. */
944 /* Print an address (VMA) to the output stream in INFO.
945 If SKIP_ZEROES is TRUE, omit leading zeroes. */
948 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
949 bfd_boolean skip_zeroes)
953 struct objdump_disasm_info *aux;
955 aux = (struct objdump_disasm_info *) inf->application_data;
956 bfd_sprintf_vma (aux->abfd, buf, vma);
961 for (p = buf; *p == '0'; ++p)
966 (*inf->fprintf_func) (inf->stream, "%s", p);
969 /* Print the name of a symbol. */
972 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
976 const char *name, *version_string = NULL;
977 bfd_boolean hidden = FALSE;
980 name = bfd_asymbol_name (sym);
981 if (do_demangle && name[0] != '\0')
983 /* Demangle the name. */
984 alloc = bfd_demangle (abfd, name, demangle_flags);
989 if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
990 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
992 if (bfd_is_und_section (bfd_get_section (sym)))
995 name = sanitize_string (name);
999 (*inf->fprintf_func) (inf->stream, "%s", name);
1000 if (version_string && *version_string != '\0')
1001 (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
1006 printf ("%s", name);
1007 if (version_string && *version_string != '\0')
1008 printf (hidden ? "@%s" : "@@%s", version_string);
1015 static inline bfd_boolean
1016 sym_ok (bfd_boolean want_section,
1017 bfd * abfd ATTRIBUTE_UNUSED,
1020 struct disassemble_info * inf)
1024 /* Note - we cannot just compare section pointers because they could
1025 be different, but the same... Ie the symbol that we are trying to
1026 find could have come from a separate debug info file. Under such
1027 circumstances the symbol will be associated with a section in the
1028 debug info file, whilst the section we want is in a normal file.
1029 So the section pointers will be different, but the section names
1030 will be the same. */
1031 if (strcmp (bfd_section_name (abfd, sorted_syms[place]->section),
1032 bfd_section_name (abfd, sec)) != 0)
1036 return inf->symbol_is_valid (sorted_syms[place], inf);
1039 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1040 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1041 require the symbol to be in the section. Returns NULL if there is no
1042 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1043 of the symbol in sorted_syms. */
1046 find_symbol_for_address (bfd_vma vma,
1047 struct disassemble_info *inf,
1050 /* @@ Would it speed things up to cache the last two symbols returned,
1051 and maybe their address ranges? For many processors, only one memory
1052 operand can be present at a time, so the 2-entry cache wouldn't be
1053 constantly churned by code doing heavy memory accesses. */
1055 /* Indices in `sorted_syms'. */
1057 long max_count = sorted_symcount;
1059 struct objdump_disasm_info *aux;
1063 bfd_boolean want_section;
1066 if (sorted_symcount < 1)
1069 aux = (struct objdump_disasm_info *) inf->application_data;
1072 opb = inf->octets_per_byte;
1074 /* Perform a binary search looking for the closest symbol to the
1075 required value. We are searching the range (min, max_count]. */
1076 while (min + 1 < max_count)
1080 thisplace = (max_count + min) / 2;
1081 sym = sorted_syms[thisplace];
1083 if (bfd_asymbol_value (sym) > vma)
1084 max_count = thisplace;
1085 else if (bfd_asymbol_value (sym) < vma)
1094 /* The symbol we want is now in min, the low end of the range we
1095 were searching. If there are several symbols with the same
1096 value, we want the first (non-section/non-debugging) one. */
1098 while (thisplace > 0
1099 && (bfd_asymbol_value (sorted_syms[thisplace])
1100 == bfd_asymbol_value (sorted_syms[thisplace - 1]))
1101 && ((sorted_syms[thisplace - 1]->flags
1102 & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
1106 /* Prefer a symbol in the current section if we have multple symbols
1107 with the same value, as can occur with overlays or zero size
1110 while (min < max_count
1111 && (bfd_asymbol_value (sorted_syms[min])
1112 == bfd_asymbol_value (sorted_syms[thisplace])))
1114 if (sym_ok (TRUE, abfd, min, sec, inf))
1121 return sorted_syms[thisplace];
1126 /* If the file is relocatable, and the symbol could be from this
1127 section, prefer a symbol from this section over symbols from
1128 others, even if the other symbol's value might be closer.
1130 Note that this may be wrong for some symbol references if the
1131 sections have overlapping memory ranges, but in that case there's
1132 no way to tell what's desired without looking at the relocation
1135 Also give the target a chance to reject symbols. */
1136 want_section = (aux->require_sec
1137 || ((abfd->flags & HAS_RELOC) != 0
1138 && vma >= bfd_get_section_vma (abfd, sec)
1139 && vma < (bfd_get_section_vma (abfd, sec)
1140 + bfd_section_size (abfd, sec) / opb)));
1142 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1145 long newplace = sorted_symcount;
1147 for (i = min - 1; i >= 0; i--)
1149 if (sym_ok (want_section, abfd, i, sec, inf))
1151 if (newplace == sorted_symcount)
1154 if (bfd_asymbol_value (sorted_syms[i])
1155 != bfd_asymbol_value (sorted_syms[newplace]))
1158 /* Remember this symbol and keep searching until we reach
1159 an earlier address. */
1164 if (newplace != sorted_symcount)
1165 thisplace = newplace;
1168 /* We didn't find a good symbol with a smaller value.
1169 Look for one with a larger value. */
1170 for (i = thisplace + 1; i < sorted_symcount; i++)
1172 if (sym_ok (want_section, abfd, i, sec, inf))
1180 if (! sym_ok (want_section, abfd, thisplace, sec, inf))
1181 /* There is no suitable symbol. */
1185 /* If we have not found an exact match for the specified address
1186 and we have dynamic relocations available, then we can produce
1187 a better result by matching a relocation to the address and
1188 using the symbol associated with that relocation. */
1189 rel_count = aux->dynrelcount;
1191 && sorted_syms[thisplace]->value != vma
1193 && aux->dynrelbuf != NULL
1194 && aux->dynrelbuf[0]->address <= vma
1195 && aux->dynrelbuf[rel_count - 1]->address >= vma
1196 /* If we have matched a synthetic symbol, then stick with that. */
1197 && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
1200 arelent ** rel_high;
1202 rel_low = aux->dynrelbuf;
1203 rel_high = rel_low + rel_count - 1;
1204 while (rel_low <= rel_high)
1206 arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
1207 arelent * rel = *rel_mid;
1209 if (rel->address == vma)
1211 /* Absolute relocations do not provide a more helpful
1212 symbolic address. Find a non-absolute relocation
1213 with the same address. */
1214 arelent **rel_vma = rel_mid;
1216 rel_mid >= rel_low && rel_mid[0]->address == vma;
1220 for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
1224 if (rel->sym_ptr_ptr != NULL
1225 && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
1228 * place = thisplace;
1229 return * rel->sym_ptr_ptr;
1235 if (vma < rel->address)
1237 else if (vma >= rel_mid[1]->address)
1238 rel_low = rel_mid + 1;
1247 return sorted_syms[thisplace];
1250 /* Print an address and the offset to the nearest symbol. */
1253 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
1254 bfd_vma vma, struct disassemble_info *inf,
1255 bfd_boolean skip_zeroes)
1257 objdump_print_value (vma, inf, skip_zeroes);
1263 (*inf->fprintf_func) (inf->stream, " <%s",
1264 sanitize_string (bfd_get_section_name (abfd, sec)));
1265 secaddr = bfd_get_section_vma (abfd, sec);
1268 (*inf->fprintf_func) (inf->stream, "-0x");
1269 objdump_print_value (secaddr - vma, inf, TRUE);
1271 else if (vma > secaddr)
1273 (*inf->fprintf_func) (inf->stream, "+0x");
1274 objdump_print_value (vma - secaddr, inf, TRUE);
1276 (*inf->fprintf_func) (inf->stream, ">");
1280 (*inf->fprintf_func) (inf->stream, " <");
1282 objdump_print_symname (abfd, inf, sym);
1284 if (bfd_asymbol_value (sym) == vma)
1286 /* Undefined symbols in an executables and dynamic objects do not have
1287 a value associated with them, so it does not make sense to display
1288 an offset relative to them. Normally we would not be provided with
1289 this kind of symbol, but the target backend might choose to do so,
1290 and the code in find_symbol_for_address might return an as yet
1291 unresolved symbol associated with a dynamic reloc. */
1292 else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
1293 && bfd_is_und_section (sym->section))
1295 else if (bfd_asymbol_value (sym) > vma)
1297 (*inf->fprintf_func) (inf->stream, "-0x");
1298 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1300 else if (vma > bfd_asymbol_value (sym))
1302 (*inf->fprintf_func) (inf->stream, "+0x");
1303 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1306 (*inf->fprintf_func) (inf->stream, ">");
1309 if (display_file_offsets)
1310 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1311 (long int)(sec->filepos + (vma - sec->vma)));
1314 /* Print an address (VMA), symbolically if possible.
1315 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1318 objdump_print_addr (bfd_vma vma,
1319 struct disassemble_info *inf,
1320 bfd_boolean skip_zeroes)
1322 struct objdump_disasm_info *aux;
1323 asymbol *sym = NULL;
1324 bfd_boolean skip_find = FALSE;
1326 aux = (struct objdump_disasm_info *) inf->application_data;
1328 if (sorted_symcount < 1)
1330 (*inf->fprintf_func) (inf->stream, "0x");
1331 objdump_print_value (vma, inf, skip_zeroes);
1333 if (display_file_offsets)
1334 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1335 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1339 if (aux->reloc != NULL
1340 && aux->reloc->sym_ptr_ptr != NULL
1341 && * aux->reloc->sym_ptr_ptr != NULL)
1343 sym = * aux->reloc->sym_ptr_ptr;
1345 /* Adjust the vma to the reloc. */
1346 vma += bfd_asymbol_value (sym);
1348 if (bfd_is_und_section (bfd_get_section (sym)))
1353 sym = find_symbol_for_address (vma, inf, NULL);
1355 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1359 /* Print VMA to INFO. This function is passed to the disassembler
1363 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1365 objdump_print_addr (vma, inf, ! prefix_addresses);
1368 /* Determine if the given address has a symbol associated with it. */
1371 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1375 sym = find_symbol_for_address (vma, inf, NULL);
1377 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1380 /* Hold the last function name and the last line number we displayed
1381 in a disassembly. */
1383 static char *prev_functionname;
1384 static unsigned int prev_line;
1385 static unsigned int prev_discriminator;
1387 /* We keep a list of all files that we have seen when doing a
1388 disassembly with source, so that we know how much of the file to
1389 display. This can be important for inlined functions. */
1391 struct print_file_list
1393 struct print_file_list *next;
1394 const char *filename;
1395 const char *modname;
1398 const char **linemap;
1401 unsigned max_printed;
1405 static struct print_file_list *print_files;
1407 /* The number of preceding context lines to show when we start
1408 displaying a file for the first time. */
1410 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1412 /* Read a complete file into memory. */
1415 slurp_file (const char *fn, size_t *size, struct stat *fst)
1418 int ps = getpagesize ();
1422 int fd = open (fn, O_RDONLY | O_BINARY);
1426 if (fstat (fd, fst) < 0)
1431 *size = fst->st_size;
1433 msize = (*size + ps - 1) & ~(ps - 1);
1434 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1435 if (map != (char *) -1L)
1441 map = (const char *) malloc (*size);
1442 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1444 free ((void *) map);
1451 #define line_map_decrease 5
1453 /* Precompute array of lines for a mapped file. */
1455 static const char **
1456 index_file (const char *map, size_t size, unsigned int *maxline)
1458 const char *p, *lstart, *end;
1459 int chars_per_line = 45; /* First iteration will use 40. */
1460 unsigned int lineno;
1461 const char **linemap = NULL;
1462 unsigned long line_map_size = 0;
1468 for (p = map; p < end; p++)
1472 if (p + 1 < end && p[1] == '\r')
1475 else if (*p == '\r')
1477 if (p + 1 < end && p[1] == '\n')
1483 /* End of line found. */
1485 if (linemap == NULL || line_map_size < lineno + 1)
1487 unsigned long newsize;
1489 chars_per_line -= line_map_decrease;
1490 if (chars_per_line <= 1)
1492 line_map_size = size / chars_per_line + 1;
1493 if (line_map_size < lineno + 1)
1494 line_map_size = lineno + 1;
1495 newsize = line_map_size * sizeof (char *);
1496 linemap = (const char **) xrealloc (linemap, newsize);
1499 linemap[lineno++] = lstart;
1507 /* Tries to open MODNAME, and if successful adds a node to print_files
1508 linked list and returns that node. Returns NULL on failure. */
1510 static struct print_file_list *
1511 try_print_file_open (const char *origname, const char *modname, struct stat *fst)
1513 struct print_file_list *p;
1515 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1517 p->map = slurp_file (modname, &p->mapsize, fst);
1524 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1527 p->filename = origname;
1528 p->modname = modname;
1529 p->next = print_files;
1535 /* If the source file, as described in the symtab, is not found
1536 try to locate it in one of the paths specified with -I
1537 If found, add location to print_files linked list. */
1539 static struct print_file_list *
1540 update_source_path (const char *filename, bfd *abfd)
1542 struct print_file_list *p;
1547 p = try_print_file_open (filename, filename, &fst);
1550 if (include_path_count == 0)
1553 /* Get the name of the file. */
1554 fname = lbasename (filename);
1556 /* If file exists under a new path, we need to add it to the list
1557 so that show_line knows about it. */
1558 for (i = 0; i < include_path_count; i++)
1560 char *modname = concat (include_paths[i], "/", fname,
1563 p = try_print_file_open (filename, modname, &fst);
1573 long mtime = bfd_get_mtime (abfd);
1575 if (fst.st_mtime > mtime)
1576 warn (_("source file %s is more recent than object file\n"),
1583 /* Print a source file line. */
1586 print_line (struct print_file_list *p, unsigned int linenum)
1592 if (linenum >= p->maxline)
1594 l = p->linemap [linenum];
1595 /* Test fwrite return value to quiet glibc warning. */
1596 len = strcspn (l, "\n\r");
1597 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1601 /* Print a range of source code lines. */
1604 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1608 while (start <= end)
1610 print_line (p, start);
1615 /* Show the line number, or the source line, in a disassembly
1619 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1621 const char *filename;
1622 const char *functionname;
1623 unsigned int linenumber;
1624 unsigned int discriminator;
1628 if (! with_line_numbers && ! with_source_code)
1631 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1632 &filename, &functionname,
1633 &linenumber, &discriminator))
1636 if (filename != NULL && *filename == '\0')
1638 if (functionname != NULL && *functionname == '\0')
1639 functionname = NULL;
1642 && IS_ABSOLUTE_PATH (filename)
1646 const char *fname = filename;
1648 path = xmalloc (prefix_length + PATH_MAX + 1);
1651 memcpy (path, prefix, prefix_length);
1652 path_up = path + prefix_length;
1654 /* Build relocated filename, stripping off leading directories
1655 from the initial filename if requested. */
1656 if (prefix_strip > 0)
1661 /* Skip selected directory levels. */
1662 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1663 if (IS_DIR_SEPARATOR(*s))
1670 /* Update complete filename. */
1671 strncpy (path_up, fname, PATH_MAX);
1672 path_up[PATH_MAX] = '\0';
1680 if (with_line_numbers)
1682 if (functionname != NULL
1683 && (prev_functionname == NULL
1684 || strcmp (functionname, prev_functionname) != 0))
1686 printf ("%s():\n", sanitize_string (functionname));
1690 && (linenumber != prev_line
1691 || discriminator != prev_discriminator))
1693 if (discriminator > 0)
1694 printf ("%s:%u (discriminator %u)\n",
1695 filename == NULL ? "???" : sanitize_string (filename),
1696 linenumber, discriminator);
1698 printf ("%s:%u\n", filename == NULL
1699 ? "???" : sanitize_string (filename),
1704 const char *filename2;
1705 const char *functionname2;
1708 while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
1711 printf ("inlined by %s:%u",
1712 sanitize_string (filename2), line2);
1713 printf (" (%s)\n", sanitize_string (functionname2));
1718 if (with_source_code
1722 struct print_file_list **pp, *p;
1725 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1726 if (filename_cmp ((*pp)->filename, filename) == 0)
1733 filename = xstrdup (filename);
1734 p = update_source_path (filename, abfd);
1737 if (p != NULL && linenumber != p->last_line)
1739 if (file_start_context && p->first)
1743 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1744 if (l >= linenumber)
1746 if (p->max_printed >= l)
1748 if (p->max_printed < linenumber)
1749 l = p->max_printed + 1;
1754 dump_lines (p, l, linenumber);
1755 if (p->max_printed < linenumber)
1756 p->max_printed = linenumber;
1757 p->last_line = linenumber;
1762 if (functionname != NULL
1763 && (prev_functionname == NULL
1764 || strcmp (functionname, prev_functionname) != 0))
1766 if (prev_functionname != NULL)
1767 free (prev_functionname);
1768 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1769 strcpy (prev_functionname, functionname);
1772 if (linenumber > 0 && linenumber != prev_line)
1773 prev_line = linenumber;
1775 if (discriminator != prev_discriminator)
1776 prev_discriminator = discriminator;
1782 /* Pseudo FILE object for strings. */
1790 /* sprintf to a "stream". */
1792 static int ATTRIBUTE_PRINTF_2
1793 objdump_sprintf (SFILE *f, const char *format, ...)
1800 size_t space = f->alloc - f->pos;
1802 va_start (args, format);
1803 n = vsnprintf (f->buffer + f->pos, space, format, args);
1809 f->alloc = (f->alloc + n) * 2;
1810 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1817 /* The number of zeroes we want to see before we start skipping them.
1818 The number is arbitrarily chosen. */
1820 #define DEFAULT_SKIP_ZEROES 8
1822 /* The number of zeroes to skip at the end of a section. If the
1823 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1824 SKIP_ZEROES, they will be disassembled. If there are fewer than
1825 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1826 attempt to avoid disassembling zeroes inserted by section
1829 #define DEFAULT_SKIP_ZEROES_AT_END 3
1831 /* Disassemble some data in memory between given values. */
1834 disassemble_bytes (struct disassemble_info * inf,
1835 disassembler_ftype disassemble_fn,
1838 bfd_vma start_offset,
1839 bfd_vma stop_offset,
1842 arelent ** relppend)
1844 struct objdump_disasm_info *aux;
1846 int octets_per_line;
1847 int skip_addr_chars;
1848 bfd_vma addr_offset;
1849 unsigned int opb = inf->octets_per_byte;
1850 unsigned int skip_zeroes = inf->skip_zeroes;
1851 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1855 aux = (struct objdump_disasm_info *) inf->application_data;
1859 sfile.buffer = (char *) xmalloc (sfile.alloc);
1863 octets_per_line = insn_width;
1865 octets_per_line = 4;
1867 octets_per_line = 16;
1869 /* Figure out how many characters to skip at the start of an
1870 address, to make the disassembly look nicer. We discard leading
1871 zeroes in chunks of 4, ensuring that there is always a leading
1873 skip_addr_chars = 0;
1874 if (! prefix_addresses)
1878 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1880 while (buf[skip_addr_chars] == '0')
1883 /* Don't discard zeros on overflow. */
1884 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1885 skip_addr_chars = 0;
1887 if (skip_addr_chars != 0)
1888 skip_addr_chars = (skip_addr_chars - 1) & -4;
1891 inf->insn_info_valid = 0;
1893 addr_offset = start_offset;
1894 while (addr_offset < stop_offset)
1897 bfd_boolean need_nl = FALSE;
1898 int previous_octets;
1900 /* Remember the length of the previous instruction. */
1901 previous_octets = octets;
1904 /* Make sure we don't use relocs from previous instructions. */
1907 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1909 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1912 if (! disassemble_zeroes
1913 && (inf->insn_info_valid == 0
1914 || inf->branch_delay_insns == 0)
1915 && (z - addr_offset * opb >= skip_zeroes
1916 || (z == stop_offset * opb &&
1917 z - addr_offset * opb < skip_zeroes_at_end)))
1919 /* If there are more nonzero octets to follow, we only skip
1920 zeroes in multiples of 4, to try to avoid running over
1921 the start of an instruction which happens to start with
1923 if (z != stop_offset * opb)
1924 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1926 octets = z - addr_offset * opb;
1928 /* If we are going to display more data, and we are displaying
1929 file offsets, then tell the user how many zeroes we skip
1930 and the file offset from where we resume dumping. */
1931 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1932 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1934 (unsigned long) (section->filepos
1935 + (addr_offset + (octets / opb))));
1945 if (with_line_numbers || with_source_code)
1946 show_line (aux->abfd, section, addr_offset);
1948 if (! prefix_addresses)
1952 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1953 for (s = buf + skip_addr_chars; *s == '0'; s++)
1957 printf ("%s:\t", buf + skip_addr_chars);
1961 aux->require_sec = TRUE;
1962 objdump_print_address (section->vma + addr_offset, inf);
1963 aux->require_sec = FALSE;
1970 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1971 inf->stream = &sfile;
1972 inf->bytes_per_line = 0;
1973 inf->bytes_per_chunk = 0;
1974 inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
1975 | (wide_output ? WIDE_OUTPUT : 0));
1977 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1979 if (inf->disassembler_needs_relocs
1980 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1981 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1982 && *relppp < relppend)
1984 bfd_signed_vma distance_to_rel;
1986 distance_to_rel = (**relppp)->address
1987 - (rel_offset + addr_offset);
1989 /* Check to see if the current reloc is associated with
1990 the instruction that we are about to disassemble. */
1991 if (distance_to_rel == 0
1992 /* FIXME: This is wrong. We are trying to catch
1993 relocs that are addressed part way through the
1994 current instruction, as might happen with a packed
1995 VLIW instruction. Unfortunately we do not know the
1996 length of the current instruction since we have not
1997 disassembled it yet. Instead we take a guess based
1998 upon the length of the previous instruction. The
1999 proper solution is to have a new target-specific
2000 disassembler function which just returns the length
2001 of an instruction at a given address without trying
2002 to display its disassembly. */
2003 || (distance_to_rel > 0
2004 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
2006 inf->flags |= INSN_HAS_RELOC;
2007 aux->reloc = **relppp;
2011 if (! disassemble_all
2012 && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2013 == (SEC_CODE | SEC_HAS_CONTENTS))
2014 /* Set a stop_vma so that the disassembler will not read
2015 beyond the next symbol. We assume that symbols appear on
2016 the boundaries between instructions. We only do this when
2017 disassembling code of course, and when -D is in effect. */
2018 inf->stop_vma = section->vma + stop_offset;
2020 inf->stop_offset = stop_offset;
2021 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
2024 inf->fprintf_func = (fprintf_ftype) fprintf;
2025 inf->stream = stdout;
2026 if (insn_width == 0 && inf->bytes_per_line != 0)
2027 octets_per_line = inf->bytes_per_line;
2028 if (octets < (int) opb)
2031 printf ("%s\n", sfile.buffer);
2034 non_fatal (_("disassemble_fn returned length %d"),
2045 octets = octets_per_line;
2046 if (addr_offset + octets / opb > stop_offset)
2047 octets = (stop_offset - addr_offset) * opb;
2049 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
2051 if (ISPRINT (data[j]))
2052 buf[j - addr_offset * opb] = data[j];
2054 buf[j - addr_offset * opb] = '.';
2056 buf[j - addr_offset * opb] = '\0';
2059 if (prefix_addresses
2061 : show_raw_insn >= 0)
2065 /* If ! prefix_addresses and ! wide_output, we print
2066 octets_per_line octets per line. */
2068 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
2069 pb = octets_per_line;
2071 if (inf->bytes_per_chunk)
2072 bpc = inf->bytes_per_chunk;
2076 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
2078 /* PR 21580: Check for a buffer ending early. */
2079 if (j + bpc <= stop_offset * opb)
2083 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2085 for (k = bpc - 1; k >= 0; k--)
2086 printf ("%02x", (unsigned) data[j + k]);
2090 for (k = 0; k < bpc; k++)
2091 printf ("%02x", (unsigned) data[j + k]);
2097 for (; pb < octets_per_line; pb += bpc)
2101 for (k = 0; k < bpc; k++)
2106 /* Separate raw data from instruction by extra space. */
2116 printf ("%s", sfile.buffer);
2118 if (prefix_addresses
2120 : show_raw_insn >= 0)
2128 j = addr_offset * opb + pb;
2130 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
2131 for (s = buf + skip_addr_chars; *s == '0'; s++)
2135 printf ("%s:\t", buf + skip_addr_chars);
2137 pb += octets_per_line;
2140 for (; j < addr_offset * opb + pb; j += bpc)
2142 /* PR 21619: Check for a buffer ending early. */
2143 if (j + bpc <= stop_offset * opb)
2147 if (inf->display_endian == BFD_ENDIAN_LITTLE)
2149 for (k = bpc - 1; k >= 0; k--)
2150 printf ("%02x", (unsigned) data[j + k]);
2154 for (k = 0; k < bpc; k++)
2155 printf ("%02x", (unsigned) data[j + k]);
2169 while ((*relppp) < relppend
2170 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
2172 if (dump_reloc_info || dump_dynamic_reloc_info)
2183 objdump_print_value (section->vma - rel_offset + q->address,
2186 if (q->howto == NULL)
2187 printf (": *unknown*\t");
2188 else if (q->howto->name)
2189 printf (": %s\t", q->howto->name);
2191 printf (": %d\t", q->howto->type);
2193 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
2194 printf ("*unknown*");
2197 const char *sym_name;
2199 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
2200 if (sym_name != NULL && *sym_name != '\0')
2201 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
2206 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
2207 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
2208 if (sym_name == NULL || *sym_name == '\0')
2209 sym_name = "*unknown*";
2210 printf ("%s", sanitize_string (sym_name));
2216 bfd_signed_vma addend = q->addend;
2224 objdump_print_value (addend, inf, TRUE);
2236 addr_offset += octets / opb;
2239 free (sfile.buffer);
2243 disassemble_section (bfd *abfd, asection *section, void *inf)
2245 const struct elf_backend_data * bed;
2246 bfd_vma sign_adjust = 0;
2247 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
2248 struct objdump_disasm_info * paux;
2249 unsigned int opb = pinfo->octets_per_byte;
2250 bfd_byte * data = NULL;
2251 bfd_size_type datasize = 0;
2252 arelent ** rel_pp = NULL;
2253 arelent ** rel_ppstart = NULL;
2254 arelent ** rel_ppend;
2255 bfd_vma stop_offset;
2256 asymbol * sym = NULL;
2260 unsigned long addr_offset;
2261 bfd_boolean do_print;
2264 stop_offset_reached,
2269 /* Sections that do not contain machine
2270 code are not normally disassembled. */
2271 if (! disassemble_all
2272 && only_list == NULL
2273 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2274 != (SEC_CODE | SEC_HAS_CONTENTS)))
2277 if (! process_section_p (section))
2280 datasize = bfd_get_section_size (section);
2284 if (start_address == (bfd_vma) -1
2285 || start_address < section->vma)
2288 addr_offset = start_address - section->vma;
2290 if (stop_address == (bfd_vma) -1)
2291 stop_offset = datasize / opb;
2294 if (stop_address < section->vma)
2297 stop_offset = stop_address - section->vma;
2298 if (stop_offset > datasize / opb)
2299 stop_offset = datasize / opb;
2302 if (addr_offset >= stop_offset)
2305 /* Decide which set of relocs to use. Load them if necessary. */
2306 paux = (struct objdump_disasm_info *) pinfo->application_data;
2307 if (paux->dynrelbuf && dump_dynamic_reloc_info)
2309 rel_pp = paux->dynrelbuf;
2310 rel_count = paux->dynrelcount;
2311 /* Dynamic reloc addresses are absolute, non-dynamic are section
2312 relative. REL_OFFSET specifies the reloc address corresponding
2313 to the start of this section. */
2314 rel_offset = section->vma;
2322 if ((section->flags & SEC_RELOC) != 0
2323 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2327 relsize = bfd_get_reloc_upper_bound (abfd, section);
2329 bfd_fatal (bfd_get_filename (abfd));
2333 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2334 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2336 bfd_fatal (bfd_get_filename (abfd));
2338 /* Sort the relocs by address. */
2339 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2343 rel_ppend = rel_pp + rel_count;
2345 if (!bfd_malloc_and_get_section (abfd, section, &data))
2347 non_fatal (_("Reading section %s failed because: %s"),
2348 section->name, bfd_errmsg (bfd_get_error ()));
2352 paux->sec = section;
2353 pinfo->buffer = data;
2354 pinfo->buffer_vma = section->vma;
2355 pinfo->buffer_length = datasize;
2356 pinfo->section = section;
2358 /* Skip over the relocs belonging to addresses below the
2360 while (rel_pp < rel_ppend
2361 && (*rel_pp)->address < rel_offset + addr_offset)
2364 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
2366 /* Find the nearest symbol forwards from our current position. */
2367 paux->require_sec = TRUE;
2368 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2369 (struct disassemble_info *) inf,
2371 paux->require_sec = FALSE;
2373 /* PR 9774: If the target used signed addresses then we must make
2374 sure that we sign extend the value that we calculate for 'addr'
2375 in the loop below. */
2376 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2377 && (bed = get_elf_backend_data (abfd)) != NULL
2378 && bed->sign_extend_vma)
2379 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2381 /* Disassemble a block of instructions up to the address associated with
2382 the symbol we have just found. Then print the symbol and find the
2383 next symbol on. Repeat until we have disassembled the entire section
2384 or we have reached the end of the address range we are interested in. */
2385 do_print = paux->symbol == NULL;
2386 loop_until = stop_offset_reached;
2388 while (addr_offset < stop_offset)
2392 bfd_vma nextstop_offset;
2395 addr = section->vma + addr_offset;
2396 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2398 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2403 (x < sorted_symcount
2404 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2408 pinfo->symbols = sorted_syms + place;
2409 pinfo->num_symbols = x - place;
2410 pinfo->symtab_pos = place;
2414 pinfo->symbols = NULL;
2415 pinfo->num_symbols = 0;
2416 pinfo->symtab_pos = -1;
2419 /* If we are only disassembling from a specific symbol,
2420 check to see if we should start or stop displaying. */
2421 if (sym && paux->symbol)
2425 /* See if we should stop printing. */
2429 if (sym->flags & BSF_FUNCTION)
2433 case stop_offset_reached:
2434 /* Handled by the while loop. */
2438 /* FIXME: There is an implicit assumption here
2439 that the name of sym is different from
2441 if (! bfd_is_local_label (abfd, sym))
2448 const char * name = bfd_asymbol_name (sym);
2449 char * alloc = NULL;
2451 if (do_demangle && name[0] != '\0')
2453 /* Demangle the name. */
2454 alloc = bfd_demangle (abfd, name, demangle_flags);
2459 /* We are not currently printing. Check to see
2460 if the current symbol matches the requested symbol. */
2461 if (streq (name, paux->symbol))
2465 if (sym->flags & BSF_FUNCTION)
2467 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2468 && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
2470 /* Sym is a function symbol with a size associated
2471 with it. Turn on automatic disassembly for the
2472 next VALUE bytes. */
2473 stop_offset = addr_offset
2474 + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
2475 loop_until = stop_offset_reached;
2479 /* Otherwise we need to tell the loop heuristic to
2480 loop until the next function symbol is encountered. */
2481 loop_until = function_sym;
2486 /* Otherwise loop until the next symbol is encountered. */
2487 loop_until = next_sym;
2495 if (! prefix_addresses && do_print)
2497 pinfo->fprintf_func (pinfo->stream, "\n");
2498 objdump_print_addr_with_sym (abfd, section, sym, addr,
2500 pinfo->fprintf_func (pinfo->stream, ":\n");
2503 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2505 else if (sym == NULL)
2509 #define is_valid_next_sym(SYM) \
2510 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2511 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2512 && pinfo->symbol_is_valid (SYM, pinfo))
2514 /* Search forward for the next appropriate symbol in
2515 SECTION. Note that all the symbols are sorted
2516 together into one big array, and that some sections
2517 may have overlapping addresses. */
2518 while (place < sorted_symcount
2519 && ! is_valid_next_sym (sorted_syms [place]))
2522 if (place >= sorted_symcount)
2525 nextsym = sorted_syms[place];
2528 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2529 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2530 else if (nextsym == NULL)
2531 nextstop_offset = stop_offset;
2533 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2535 if (nextstop_offset > stop_offset
2536 || nextstop_offset <= addr_offset)
2537 nextstop_offset = stop_offset;
2539 /* If a symbol is explicitly marked as being an object
2540 rather than a function, just dump the bytes without
2541 disassembling them. */
2544 || sym->section != section
2545 || bfd_asymbol_value (sym) > addr
2546 || ((sym->flags & BSF_OBJECT) == 0
2547 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2549 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2551 || (sym->flags & BSF_FUNCTION) != 0)
2557 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2558 addr_offset, nextstop_offset,
2559 rel_offset, &rel_pp, rel_ppend);
2561 addr_offset = nextstop_offset;
2567 if (rel_ppstart != NULL)
2571 /* Disassemble the contents of an object file. */
2574 disassemble_data (bfd *abfd)
2576 struct disassemble_info disasm_info;
2577 struct objdump_disasm_info aux;
2581 prev_functionname = NULL;
2583 prev_discriminator = 0;
2585 /* We make a copy of syms to sort. We don't want to sort syms
2586 because that will screw up the relocs. */
2587 sorted_symcount = symcount ? symcount : dynsymcount;
2588 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2589 * sizeof (asymbol *));
2590 memcpy (sorted_syms, symcount ? syms : dynsyms,
2591 sorted_symcount * sizeof (asymbol *));
2593 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2595 for (i = 0; i < synthcount; ++i)
2597 sorted_syms[sorted_symcount] = synthsyms + i;
2601 /* Sort the symbols into section and symbol order. */
2602 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2604 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2606 disasm_info.application_data = (void *) &aux;
2608 aux.require_sec = FALSE;
2609 aux.dynrelbuf = NULL;
2610 aux.dynrelcount = 0;
2612 aux.symbol = disasm_sym;
2614 disasm_info.print_address_func = objdump_print_address;
2615 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2617 if (machine != NULL)
2619 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2622 fatal (_("can't use supplied machine %s"), machine);
2624 abfd->arch_info = inf;
2627 if (endian != BFD_ENDIAN_UNKNOWN)
2629 struct bfd_target *xvec;
2631 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2632 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2633 xvec->byteorder = endian;
2637 /* Use libopcodes to locate a suitable disassembler. */
2638 aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
2639 bfd_big_endian (abfd),
2640 bfd_get_mach (abfd), abfd);
2641 if (!aux.disassemble_fn)
2643 non_fatal (_("can't disassemble for architecture %s\n"),
2644 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2649 disasm_info.flavour = bfd_get_flavour (abfd);
2650 disasm_info.arch = bfd_get_arch (abfd);
2651 disasm_info.mach = bfd_get_mach (abfd);
2652 disasm_info.disassembler_options = disassembler_options;
2653 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2654 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2655 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2656 disasm_info.disassembler_needs_relocs = FALSE;
2658 if (bfd_big_endian (abfd))
2659 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2660 else if (bfd_little_endian (abfd))
2661 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2663 /* ??? Aborting here seems too drastic. We could default to big or little
2665 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2667 /* Allow the target to customize the info structure. */
2668 disassemble_init_for_target (& disasm_info);
2670 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2672 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2674 if (relsize < 0 && dump_dynamic_reloc_info)
2675 bfd_fatal (bfd_get_filename (abfd));
2679 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2680 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2683 if (aux.dynrelcount < 0)
2684 bfd_fatal (bfd_get_filename (abfd));
2686 /* Sort the relocs by address. */
2687 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2691 disasm_info.symtab = sorted_syms;
2692 disasm_info.symtab_size = sorted_symcount;
2694 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2696 if (aux.dynrelbuf != NULL)
2697 free (aux.dynrelbuf);
2702 load_specific_debug_section (enum dwarf_section_display_enum debug,
2703 asection *sec, void *file)
2705 struct dwarf_section *section = &debug_displays [debug].section;
2706 bfd *abfd = (bfd *) file;
2711 if (section->start != NULL)
2713 /* If it is already loaded, do nothing. */
2714 if (streq (section->filename, bfd_get_filename (abfd)))
2716 free (section->start);
2719 section->filename = bfd_get_filename (abfd);
2720 section->reloc_info = NULL;
2721 section->num_relocs = 0;
2722 section->address = bfd_get_section_vma (abfd, sec);
2723 section->user_data = sec;
2724 section->size = bfd_get_section_size (sec);
2725 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2726 alloced = amt = section->size + 1;
2727 if (alloced != amt || alloced == 0)
2729 section->start = NULL;
2730 free_debug_section (debug);
2731 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2732 sanitize_string (section->name),
2733 (unsigned long long) section->size);
2736 section->start = contents = malloc (alloced);
2737 if (section->start == NULL
2738 || !bfd_get_full_section_contents (abfd, sec, &contents))
2740 free_debug_section (debug);
2741 printf (_("\nCan't get contents for section '%s'.\n"),
2742 sanitize_string (section->name));
2745 /* Ensure any string section has a terminating NUL. */
2746 section->start[section->size] = 0;
2748 if (is_relocatable && debug_displays [debug].relocate)
2753 bfd_cache_section_contents (sec, section->start);
2755 ret = bfd_simple_get_relocated_section_contents (abfd,
2762 free_debug_section (debug);
2763 printf (_("\nCan't get contents for section '%s'.\n"),
2764 sanitize_string (section->name));
2768 reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2771 unsigned long reloc_count;
2774 relocs = (arelent **) xmalloc (reloc_size);
2776 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2777 if (reloc_count == 0)
2781 section->reloc_info = relocs;
2782 section->num_relocs = reloc_count;
2791 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2796 if (dsec == NULL || dsec->reloc_info == NULL)
2799 relocs = (arelent **) dsec->reloc_info;
2801 for (; (rp = * relocs) != NULL; ++ relocs)
2802 if (rp->address == offset)
2809 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2811 struct dwarf_section *section = &debug_displays [debug].section;
2812 bfd *abfd = (bfd *) file;
2815 /* If it is already loaded, do nothing. */
2816 if (section->start != NULL)
2818 if (streq (section->filename, bfd_get_filename (abfd)))
2822 /* Locate the debug section. */
2823 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2825 section->name = section->uncompressed_name;
2828 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2830 section->name = section->compressed_name;
2835 return load_specific_debug_section (debug, sec, file);
2839 free_debug_section (enum dwarf_section_display_enum debug)
2841 struct dwarf_section *section = &debug_displays [debug].section;
2843 if (section->start == NULL)
2846 /* PR 17512: file: 0f67f69d. */
2847 if (section->user_data != NULL)
2849 asection * sec = (asection *) section->user_data;
2851 /* If we are freeing contents that are also pointed to by the BFD
2852 library's section structure then make sure to update those pointers
2853 too. Otherwise, the next time we try to load data for this section
2854 we can end up using a stale pointer. */
2855 if (section->start == sec->contents)
2857 sec->contents = NULL;
2858 sec->flags &= ~ SEC_IN_MEMORY;
2859 sec->compress_status = COMPRESS_SECTION_NONE;
2863 free ((char *) section->start);
2864 section->start = NULL;
2865 section->address = 0;
2870 close_debug_file (void * file)
2872 bfd * abfd = (bfd *) file;
2878 open_debug_file (const char * pathname)
2882 data = bfd_openr (pathname, NULL);
2886 if (! bfd_check_format (data, bfd_object))
2893 dump_dwarf_section (bfd *abfd, asection *section,
2894 void *arg ATTRIBUTE_UNUSED)
2896 const char *name = bfd_get_section_name (abfd, section);
2900 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2901 match = ".debug_info";
2905 for (i = 0; i < max; i++)
2906 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2907 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2908 && debug_displays [i].enabled != NULL
2909 && *debug_displays [i].enabled)
2911 struct dwarf_section *sec = &debug_displays [i].section;
2913 if (strcmp (sec->uncompressed_name, match) == 0)
2914 sec->name = sec->uncompressed_name;
2916 sec->name = sec->compressed_name;
2917 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2920 debug_displays [i].display (sec, abfd);
2922 if (i != info && i != abbrev)
2923 free_debug_section ((enum dwarf_section_display_enum) i);
2929 /* Dump the dwarf debugging information. */
2932 dump_dwarf (bfd *abfd)
2934 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2935 if (byte_get == NULL)
2937 warn (_("File %s does not contain any dwarf debug information\n"),
2938 bfd_get_filename (abfd));
2942 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2944 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2946 switch (bfd_get_arch (abfd))
2949 switch (bfd_get_mach (abfd))
2951 case bfd_mach_x86_64:
2952 case bfd_mach_x86_64_intel_syntax:
2953 case bfd_mach_x86_64_nacl:
2954 case bfd_mach_x64_32:
2955 case bfd_mach_x64_32_intel_syntax:
2956 case bfd_mach_x64_32_nacl:
2957 init_dwarf_regnames_x86_64 ();
2961 init_dwarf_regnames_i386 ();
2966 case bfd_arch_iamcu:
2967 init_dwarf_regnames_iamcu ();
2970 case bfd_arch_aarch64:
2971 init_dwarf_regnames_aarch64();
2975 init_dwarf_regnames_s390 ();
2978 case bfd_arch_riscv:
2979 init_dwarf_regnames_riscv ();
2983 /* S12Z has a 24 bit address space. But the only known
2984 producer of dwarf_info encodes addresses into 32 bits. */
2992 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2995 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2996 it. Return NULL on failure. */
2999 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr,
3000 bfd_size_type *entsize_ptr)
3005 stabsect = bfd_get_section_by_name (abfd, sect_name);
3006 if (stabsect == NULL)
3008 printf (_("No %s section present\n\n"),
3009 sanitize_string (sect_name));
3013 if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
3015 non_fatal (_("reading %s section of %s failed: %s"),
3016 sect_name, bfd_get_filename (abfd),
3017 bfd_errmsg (bfd_get_error ()));
3023 *size_ptr = bfd_section_size (abfd, stabsect);
3025 *entsize_ptr = stabsect->entsize;
3030 /* Stabs entries use a 12 byte format:
3031 4 byte string table index
3033 1 byte stab other field
3034 2 byte stab desc field
3036 FIXME: This will have to change for a 64 bit object format. */
3038 #define STRDXOFF (0)
3040 #define OTHEROFF (5)
3043 #define STABSIZE (12)
3045 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3046 using string table section STRSECT_NAME (in `strtab'). */
3049 print_section_stabs (bfd *abfd,
3050 const char *stabsect_name,
3051 unsigned *string_offset_ptr)
3054 unsigned file_string_table_offset = 0;
3055 unsigned next_file_string_table_offset = *string_offset_ptr;
3056 bfd_byte *stabp, *stabs_end;
3059 stabs_end = stabp + stab_size;
3061 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
3062 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3064 /* Loop through all symbols and print them.
3066 We start the index at -1 because there is a dummy symbol on
3067 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3068 for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
3072 unsigned char type, other;
3073 unsigned short desc;
3076 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3077 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3078 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3079 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3080 value = bfd_h_get_32 (abfd, stabp + VALOFF);
3082 printf ("\n%-6d ", i);
3083 /* Either print the stab name, or, if unnamed, print its number
3084 again (makes consistent formatting for tools like awk). */
3085 name = bfd_get_stab_name (type);
3087 printf ("%-6s", sanitize_string (name));
3088 else if (type == N_UNDF)
3091 printf ("%-6d", type);
3092 printf (" %-6d %-6d ", other, desc);
3093 bfd_printf_vma (abfd, value);
3094 printf (" %-6lu", strx);
3096 /* Symbols with type == 0 (N_UNDF) specify the length of the
3097 string table associated with this file. We use that info
3098 to know how to relocate the *next* file's string table indices. */
3101 file_string_table_offset = next_file_string_table_offset;
3102 next_file_string_table_offset += value;
3106 bfd_size_type amt = strx + file_string_table_offset;
3108 /* Using the (possibly updated) string table offset, print the
3109 string (if any) associated with this symbol. */
3110 if (amt < stabstr_size)
3111 /* PR 17512: file: 079-79389-0.001:0.1.
3112 FIXME: May need to sanitize this string before displaying. */
3113 printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
3119 *string_offset_ptr = next_file_string_table_offset;
3124 const char * section_name;
3125 const char * string_section_name;
3126 unsigned string_offset;
3131 find_stabs_section (bfd *abfd, asection *section, void *names)
3134 stab_section_names * sought = (stab_section_names *) names;
3136 /* Check for section names for which stabsect_name is a prefix, to
3137 handle .stab.N, etc. */
3138 len = strlen (sought->section_name);
3140 /* If the prefix matches, and the files section name ends with a
3141 nul or a digit, then we match. I.e., we want either an exact
3142 match or a section followed by a number. */
3143 if (strncmp (sought->section_name, section->name, len) == 0
3144 && (section->name[len] == 0
3145 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
3148 strtab = read_section_stabs (abfd, sought->string_section_name,
3149 &stabstr_size, NULL);
3153 stabs = read_section_stabs (abfd, section->name, &stab_size, NULL);
3155 print_section_stabs (abfd, section->name, &sought->string_offset);
3161 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3163 stab_section_names s;
3165 s.section_name = stabsect_name;
3166 s.string_section_name = strsect_name;
3167 s.string_offset = 0;
3169 bfd_map_over_sections (abfd, find_stabs_section, & s);
3175 /* Dump the any sections containing stabs debugging information. */
3178 dump_stabs (bfd *abfd)
3180 dump_stabs_section (abfd, ".stab", ".stabstr");
3181 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3182 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
3185 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3187 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3191 dump_bfd_header (bfd *abfd)
3195 printf (_("architecture: %s, "),
3196 bfd_printable_arch_mach (bfd_get_arch (abfd),
3197 bfd_get_mach (abfd)));
3198 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
3200 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3201 PF (HAS_RELOC, "HAS_RELOC");
3202 PF (EXEC_P, "EXEC_P");
3203 PF (HAS_LINENO, "HAS_LINENO");
3204 PF (HAS_DEBUG, "HAS_DEBUG");
3205 PF (HAS_SYMS, "HAS_SYMS");
3206 PF (HAS_LOCALS, "HAS_LOCALS");
3207 PF (DYNAMIC, "DYNAMIC");
3208 PF (WP_TEXT, "WP_TEXT");
3209 PF (D_PAGED, "D_PAGED");
3210 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3211 printf (_("\nstart address 0x"));
3212 bfd_printf_vma (abfd, abfd->start_address);
3218 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3219 it is passed, or a pointer to newly-allocated storage, in which case
3220 dump_ctf() will free it when it no longer needs it. */
3223 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
3229 if (asprintf (&new_s, "%s%s", spaces, s) < 0)
3234 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3237 make_ctfsect (const char *name, bfd_byte *data,
3242 ctfsect.cts_name = name;
3243 ctfsect.cts_type = SHT_PROGBITS;
3244 ctfsect.cts_flags = 0;
3245 ctfsect.cts_entsize = 1;
3246 ctfsect.cts_offset = 0;
3247 ctfsect.cts_size = size;
3248 ctfsect.cts_data = data;
3253 /* Dump one CTF archive member. */
3256 dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
3258 ctf_file_t *parent = (ctf_file_t *) arg;
3259 const char *things[] = {"Labels", "Data objects", "Function objects",
3260 "Variables", "Types", "Strings", ""};
3264 /* Only print out the name of non-default-named archive members.
3265 The name .ctf appears everywhere, even for things that aren't
3266 really archives, so printing it out is liable to be confusing. */
3267 if (strcmp (name, ".ctf") != 0)
3268 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
3270 ctf_import (ctf, parent);
3271 for (i = 1, thing = things; *thing[0]; thing++, i++)
3273 ctf_dump_state_t *s = NULL;
3276 printf ("\n %s:\n", *thing);
3277 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
3278 (void *) " ")) != NULL)
3280 printf ("%s\n", item);
3284 if (ctf_errno (ctf))
3286 non_fatal (_("Iteration failed: %s, %s\n"), *thing,
3287 ctf_errmsg (ctf_errno (ctf)));
3294 /* Dump the CTF debugging information. */
3297 dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
3299 ctf_archive_t *ctfa, *parenta = NULL;
3300 bfd_byte *ctfdata, *parentdata = NULL;
3301 bfd_size_type ctfsize, parentsize;
3303 ctf_file_t *parent = NULL;
3306 if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
3307 bfd_fatal (bfd_get_filename (abfd));
3310 && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
3312 bfd_fatal (bfd_get_filename (abfd));
3314 /* Load the CTF file and dump it. */
3316 ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
3317 if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3319 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3320 bfd_fatal (bfd_get_filename (abfd));
3325 ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
3326 if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3328 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3329 bfd_fatal (bfd_get_filename (abfd));
3332 /* Assume that the applicable parent archive member is the default one.
3333 (This is what all known implementations are expected to do, if they
3334 put CTFs and their parents in archives together.) */
3335 if ((parent = ctf_arc_open_by_name (parenta, NULL, &err)) == NULL)
3337 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3338 bfd_fatal (bfd_get_filename (abfd));
3342 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
3344 ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
3345 ctf_file_close (parent);
3347 ctf_close (parenta);
3351 #endif /* HAVE_LIBCTF */
3354 dump_bfd_private_header (bfd *abfd)
3356 if (!bfd_print_private_bfd_data (abfd, stdout))
3357 non_fatal (_("warning: private headers incomplete: %s"),
3358 bfd_errmsg (bfd_get_error ()));
3362 dump_target_specific (bfd *abfd)
3364 const struct objdump_private_desc * const *desc;
3365 struct objdump_private_option *opt;
3368 /* Find the desc. */
3369 for (desc = objdump_private_vectors; *desc != NULL; desc++)
3370 if ((*desc)->filter (abfd))
3375 non_fatal (_("option -P/--private not supported by this file"));
3379 /* Clear all options. */
3380 for (opt = (*desc)->options; opt->name; opt++)
3381 opt->selected = FALSE;
3383 /* Decode options. */
3384 b = dump_private_options;
3387 e = strchr (b, ',');
3392 for (opt = (*desc)->options; opt->name; opt++)
3393 if (strcmp (opt->name, b) == 0)
3395 opt->selected = TRUE;
3398 if (opt->name == NULL)
3399 non_fatal (_("target specific dump '%s' not supported"), b);
3410 (*desc)->dump (abfd);
3413 /* Display a section in hexadecimal format with associated characters.
3414 Each line prefixed by the zero padded address. */
3417 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3419 bfd_byte *data = NULL;
3420 bfd_size_type datasize;
3421 bfd_vma addr_offset;
3422 bfd_vma start_offset;
3423 bfd_vma stop_offset;
3424 unsigned int opb = bfd_octets_per_byte (abfd);
3425 /* Bytes per line. */
3426 const int onaline = 16;
3431 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3434 if (! process_section_p (section))
3437 if ((datasize = bfd_section_size (abfd, section)) == 0)
3440 /* Compute the address range to display. */
3441 if (start_address == (bfd_vma) -1
3442 || start_address < section->vma)
3445 start_offset = start_address - section->vma;
3447 if (stop_address == (bfd_vma) -1)
3448 stop_offset = datasize / opb;
3451 if (stop_address < section->vma)
3454 stop_offset = stop_address - section->vma;
3456 if (stop_offset > datasize / opb)
3457 stop_offset = datasize / opb;
3460 if (start_offset >= stop_offset)
3463 printf (_("Contents of section %s:"), sanitize_string (section->name));
3464 if (display_file_offsets)
3465 printf (_(" (Starting at file offset: 0x%lx)"),
3466 (unsigned long) (section->filepos + start_offset));
3469 if (!bfd_get_full_section_contents (abfd, section, &data))
3471 non_fatal (_("Reading section %s failed because: %s"),
3472 section->name, bfd_errmsg (bfd_get_error ()));
3478 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3479 if (strlen (buf) >= sizeof (buf))
3483 while (buf[count] == '0' && buf[count+1] != '\0')
3485 count = strlen (buf) - count;
3489 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3490 if (strlen (buf) >= sizeof (buf))
3494 while (buf[count] == '0' && buf[count+1] != '\0')
3496 count = strlen (buf) - count;
3500 for (addr_offset = start_offset;
3501 addr_offset < stop_offset; addr_offset += onaline / opb)
3505 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3506 count = strlen (buf);
3507 if ((size_t) count >= sizeof (buf))
3511 while (count < width)
3516 fputs (buf + count - width, stdout);
3519 for (j = addr_offset * opb;
3520 j < addr_offset * opb + onaline; j++)
3522 if (j < stop_offset * opb)
3523 printf ("%02x", (unsigned) (data[j]));
3531 for (j = addr_offset * opb;
3532 j < addr_offset * opb + onaline; j++)
3534 if (j >= stop_offset * opb)
3537 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3544 /* Actually display the various requested regions. */
3547 dump_data (bfd *abfd)
3549 bfd_map_over_sections (abfd, dump_section, NULL);
3552 /* Should perhaps share code and display with nm? */
3555 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3564 max_count = dynsymcount;
3565 printf ("DYNAMIC SYMBOL TABLE:\n");
3570 max_count = symcount;
3571 printf ("SYMBOL TABLE:\n");
3575 printf (_("no symbols\n"));
3577 for (count = 0; count < max_count; count++)
3581 if (*current == NULL)
3582 printf (_("no information for symbol number %ld\n"), count);
3584 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3585 printf (_("could not determine the type of symbol number %ld\n"),
3588 else if (process_section_p ((* current)->section)
3589 && (dump_special_syms
3590 || !bfd_is_target_special_symbol (cur_bfd, *current)))
3592 const char *name = (*current)->name;
3594 if (do_demangle && name != NULL && *name != '\0')
3598 /* If we want to demangle the name, we demangle it
3599 here, and temporarily clobber it while calling
3600 bfd_print_symbol. FIXME: This is a gross hack. */
3601 alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3603 (*current)->name = alloc;
3604 bfd_print_symbol (cur_bfd, stdout, *current,
3605 bfd_print_symbol_all);
3608 (*current)->name = name;
3613 bfd_print_symbol (cur_bfd, stdout, *current,
3614 bfd_print_symbol_all);
3624 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3627 char *last_filename, *last_functionname;
3628 unsigned int last_line;
3629 unsigned int last_discriminator;
3631 /* Get column headers lined up reasonably. */
3639 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3640 width = strlen (buf) - 7;
3642 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3645 last_filename = NULL;
3646 last_functionname = NULL;
3648 last_discriminator = 0;
3650 for (p = relpp; relcount && *p != NULL; p++, relcount--)
3653 const char *filename, *functionname;
3654 unsigned int linenumber;
3655 unsigned int discriminator;
3656 const char *sym_name;
3657 const char *section_name;
3658 bfd_vma addend2 = 0;
3660 if (start_address != (bfd_vma) -1
3661 && q->address < start_address)
3663 if (stop_address != (bfd_vma) -1
3664 && q->address > stop_address)
3667 if (with_line_numbers
3669 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3670 &filename, &functionname,
3671 &linenumber, &discriminator))
3673 if (functionname != NULL
3674 && (last_functionname == NULL
3675 || strcmp (functionname, last_functionname) != 0))
3677 printf ("%s():\n", sanitize_string (functionname));
3678 if (last_functionname != NULL)
3679 free (last_functionname);
3680 last_functionname = xstrdup (functionname);
3684 && (linenumber != last_line
3685 || (filename != NULL
3686 && last_filename != NULL
3687 && filename_cmp (filename, last_filename) != 0)
3688 || (discriminator != last_discriminator)))
3690 if (discriminator > 0)
3691 printf ("%s:%u\n", filename == NULL ? "???" :
3692 sanitize_string (filename), linenumber);
3694 printf ("%s:%u (discriminator %u)\n",
3695 filename == NULL ? "???" : sanitize_string (filename),
3696 linenumber, discriminator);
3697 last_line = linenumber;
3698 last_discriminator = discriminator;
3699 if (last_filename != NULL)
3700 free (last_filename);
3701 if (filename == NULL)
3702 last_filename = NULL;
3704 last_filename = xstrdup (filename);
3708 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3710 sym_name = (*(q->sym_ptr_ptr))->name;
3711 section_name = (*(q->sym_ptr_ptr))->section->name;
3716 section_name = NULL;
3719 bfd_printf_vma (abfd, q->address);
3720 if (q->howto == NULL)
3721 printf (" *unknown* ");
3722 else if (q->howto->name)
3724 const char *name = q->howto->name;
3726 /* R_SPARC_OLO10 relocations contain two addends.
3727 But because 'arelent' lacks enough storage to
3728 store them both, the 64-bit ELF Sparc backend
3729 records this as two relocations. One R_SPARC_LO10
3730 and one R_SPARC_13, both pointing to the same
3731 address. This is merely so that we have some
3732 place to store both addend fields.
3734 Undo this transformation, otherwise the output
3735 will be confusing. */
3736 if (abfd->xvec->flavour == bfd_target_elf_flavour
3737 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3739 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3741 arelent *q2 = *(p + 1);
3744 && q->address == q2->address
3745 && !strcmp (q2->howto->name, "R_SPARC_13"))
3747 name = "R_SPARC_OLO10";
3748 addend2 = q2->addend;
3752 printf (" %-16s ", name);
3755 printf (" %-16d ", q->howto->type);
3759 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3763 if (section_name == NULL)
3764 section_name = "*unknown*";
3765 printf ("[%s]", sanitize_string (section_name));
3770 bfd_signed_vma addend = q->addend;
3778 bfd_printf_vma (abfd, addend);
3783 bfd_printf_vma (abfd, addend2);
3789 if (last_filename != NULL)
3790 free (last_filename);
3791 if (last_functionname != NULL)
3792 free (last_functionname);
3796 dump_relocs_in_section (bfd *abfd,
3798 void *dummy ATTRIBUTE_UNUSED)
3800 arelent **relpp = NULL;
3804 if ( bfd_is_abs_section (section)
3805 || bfd_is_und_section (section)
3806 || bfd_is_com_section (section)
3807 || (! process_section_p (section))
3808 || ((section->flags & SEC_RELOC) == 0))
3811 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3813 relsize = bfd_get_reloc_upper_bound (abfd, section);
3816 printf (" (none)\n\n");
3824 relpp = (arelent **) xmalloc (relsize);
3825 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3831 non_fatal (_("failed to read relocs in: %s"),
3832 sanitize_string (bfd_get_filename (abfd)));
3833 bfd_fatal (_("error message was"));
3835 else if (relcount == 0)
3836 printf (" (none)\n\n");
3840 dump_reloc_set (abfd, section, relpp, relcount);
3847 dump_relocs (bfd *abfd)
3849 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3853 dump_dynamic_relocs (bfd *abfd)
3859 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3861 bfd_fatal (bfd_get_filename (abfd));
3863 printf ("DYNAMIC RELOCATION RECORDS");
3866 printf (" (none)\n\n");
3869 relpp = (arelent **) xmalloc (relsize);
3870 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3873 bfd_fatal (bfd_get_filename (abfd));
3874 else if (relcount == 0)
3875 printf (" (none)\n\n");
3879 dump_reloc_set (abfd, NULL, relpp, relcount);
3886 /* Creates a table of paths, to search for source files. */
3889 add_include_path (const char *path)
3893 include_path_count++;
3894 include_paths = (const char **)
3895 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3896 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3897 if (path[1] == ':' && path[2] == 0)
3898 path = concat (path, ".", (const char *) 0);
3900 include_paths[include_path_count - 1] = path;
3904 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3908 if ((section->flags & SEC_DEBUGGING) == 0)
3910 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3911 section->vma += adjust_section_vma;
3913 section->lma += adjust_section_vma;
3917 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3920 sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
3925 mask = (bfd_vma) 1 << (arch_size - 1);
3926 return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
3929 /* Dump selected contents of ABFD. */
3932 dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
3934 const struct elf_backend_data * bed;
3936 if (bfd_big_endian (abfd))
3937 byte_get = byte_get_big_endian;
3938 else if (bfd_little_endian (abfd))
3939 byte_get = byte_get_little_endian;
3943 /* Load any separate debug information files.
3944 We do this now and without checking do_follow_links because separate
3945 debug info files may contain symbol tables that we will need when
3946 displaying information about the main file. Any memory allocated by
3947 load_separate_debug_files will be released when we call
3948 free_debug_memory below.
3950 The test on is_mainfile is there because the chain of separate debug
3951 info files is a global variable shared by all invocations of dump_bfd. */
3954 load_separate_debug_files (abfd, bfd_get_filename (abfd));
3956 /* If asked to do so, recursively dump the separate files. */
3957 if (do_follow_links)
3961 for (i = first_separate_info; i != NULL; i = i->next)
3962 dump_bfd (i->handle, FALSE);
3966 /* Adjust user-specified start and stop limits for targets that use
3967 signed addresses. */
3968 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
3969 && (bed = get_elf_backend_data (abfd)) != NULL
3970 && bed->sign_extend_vma)
3972 start_address = sign_extend_address (abfd, start_address,
3974 stop_address = sign_extend_address (abfd, stop_address,
3978 /* If we are adjusting section VMA's, change them all now. Changing
3979 the BFD information is a hack. However, we must do it, or
3980 bfd_find_nearest_line will not do the right thing. */
3981 if (adjust_section_vma != 0)
3983 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3984 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3987 if (! dump_debugging_tags && ! suppress_bfd_header)
3988 printf (_("\n%s: file format %s\n"),
3989 sanitize_string (bfd_get_filename (abfd)),
3992 print_arelt_descr (stdout, abfd, TRUE, FALSE);
3993 if (dump_file_header)
3994 dump_bfd_header (abfd);
3995 if (dump_private_headers)
3996 dump_bfd_private_header (abfd);
3997 if (dump_private_options != NULL)
3998 dump_target_specific (abfd);
3999 if (! dump_debugging_tags && ! suppress_bfd_header)
4006 || dump_dwarf_section_info)
4008 syms = slurp_symtab (abfd);
4010 /* If following links, load any symbol tables from the linked files as well. */
4011 if (do_follow_links && is_mainfile)
4015 for (i = first_separate_info; i != NULL; i = i->next)
4017 asymbol ** extra_syms;
4018 long old_symcount = symcount;
4020 extra_syms = slurp_symtab (i->handle);
4024 if (old_symcount == 0)
4030 syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
4031 memcpy (syms + old_symcount,
4033 symcount * sizeof (asymbol *));
4037 symcount += old_symcount;
4042 if (dump_section_headers)
4043 dump_headers (abfd);
4045 if (dump_dynamic_symtab || dump_dynamic_reloc_info
4046 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
4047 dynsyms = slurp_dynamic_symtab (abfd);
4051 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
4052 dynsymcount, dynsyms, &synthsyms);
4058 dump_symbols (abfd, FALSE);
4059 if (dump_dynamic_symtab)
4060 dump_symbols (abfd, TRUE);
4061 if (dump_dwarf_section_info)
4064 if (dump_ctf_section_info)
4065 dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
4067 if (dump_stab_section_info)
4069 if (dump_reloc_info && ! disassemble)
4071 if (dump_dynamic_reloc_info && ! disassemble)
4072 dump_dynamic_relocs (abfd);
4073 if (dump_section_contents)
4076 disassemble_data (abfd);
4082 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
4083 if (dhandle != NULL)
4085 if (!print_debugging_info (stdout, dhandle, abfd, syms,
4087 dump_debugging_tags ? TRUE : FALSE))
4089 non_fatal (_("%s: printing debugging information failed"),
4090 bfd_get_filename (abfd));
4096 /* PR 6483: If there was no STABS debug info in the file, try
4098 else if (! dump_dwarf_section_info)
4100 dwarf_select_sections_all ();
4128 free_debug_memory ();
4132 display_object_bfd (bfd *abfd)
4136 if (bfd_check_format_matches (abfd, bfd_object, &matching))
4138 dump_bfd (abfd, TRUE);
4142 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4144 nonfatal (bfd_get_filename (abfd));
4145 list_matching_formats (matching);
4150 if (bfd_get_error () != bfd_error_file_not_recognized)
4152 nonfatal (bfd_get_filename (abfd));
4156 if (bfd_check_format_matches (abfd, bfd_core, &matching))
4158 dump_bfd (abfd, TRUE);
4162 nonfatal (bfd_get_filename (abfd));
4164 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4166 list_matching_formats (matching);
4172 display_any_bfd (bfd *file, int level)
4174 /* Decompress sections unless dumping the section contents. */
4175 if (!dump_section_contents)
4176 file->flags |= BFD_DECOMPRESS;
4178 /* If the file is an archive, process all of its elements. */
4179 if (bfd_check_format (file, bfd_archive))
4182 bfd *last_arfile = NULL;
4185 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
4186 else if (level > 100)
4188 /* Prevent corrupted files from spinning us into an
4189 infinite loop. 100 is an arbitrary heuristic. */
4190 fatal (_("Archive nesting is too deep"));
4194 printf (_("In nested archive %s:\n"),
4195 sanitize_string (bfd_get_filename (file)));
4199 bfd_set_error (bfd_error_no_error);
4201 arfile = bfd_openr_next_archived_file (file, arfile);
4204 if (bfd_get_error () != bfd_error_no_more_archived_files)
4205 nonfatal (bfd_get_filename (file));
4209 display_any_bfd (arfile, level + 1);
4211 if (last_arfile != NULL)
4213 bfd_close (last_arfile);
4214 /* PR 17512: file: ac585d01. */
4215 if (arfile == last_arfile)
4221 last_arfile = arfile;
4224 if (last_arfile != NULL)
4225 bfd_close (last_arfile);
4228 display_object_bfd (file);
4232 display_file (char *filename, char *target, bfd_boolean last_file)
4236 if (get_file_size (filename) < 1)
4242 file = bfd_openr (filename, target);
4245 nonfatal (filename);
4249 display_any_bfd (file, 0);
4251 /* This is an optimization to improve the speed of objdump, especially when
4252 dumping a file with lots of associated debug informatiom. Calling
4253 bfd_close on such a file can take a non-trivial amount of time as there
4254 are lots of lists to walk and buffers to free. This is only really
4255 necessary however if we are about to load another file and we need the
4256 memory back. Otherwise, if we are about to exit, then we can save (a lot
4257 of) time by only doing a quick close, and allowing the OS to reclaim the
4262 bfd_close_all_done (file);
4266 main (int argc, char **argv)
4269 char *target = default_target;
4270 bfd_boolean seenflag = FALSE;
4272 #if defined (HAVE_SETLOCALE)
4273 #if defined (HAVE_LC_MESSAGES)
4274 setlocale (LC_MESSAGES, "");
4276 setlocale (LC_CTYPE, "");
4279 bindtextdomain (PACKAGE, LOCALEDIR);
4280 textdomain (PACKAGE);
4282 program_name = *argv;
4283 xmalloc_set_program_name (program_name);
4284 bfd_set_error_program_name (program_name);
4286 START_PROGRESS (program_name, 0);
4288 expandargv (&argc, &argv);
4290 if (bfd_init () != BFD_INIT_MAGIC)
4291 fatal (_("fatal error: libbfd ABI mismatch"));
4292 set_default_bfd_target ();
4294 while ((c = getopt_long (argc, argv,
4295 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4296 long_options, (int *) 0))
4302 break; /* We've been given a long option. */
4309 if (disassembler_options)
4310 /* Ignore potential memory leak for now. */
4311 options = concat (disassembler_options, ",",
4312 optarg, (const char *) NULL);
4315 disassembler_options = remove_whitespace_and_extra_commas (options);
4322 display_file_offsets = TRUE;
4325 with_line_numbers = TRUE;
4334 enum demangling_styles style;
4336 style = cplus_demangle_name_to_style (optarg);
4337 if (style == unknown_demangling)
4338 fatal (_("unknown demangling style `%s'"),
4341 cplus_demangle_set_style (style);
4344 case OPTION_RECURSE_LIMIT:
4345 demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4347 case OPTION_NO_RECURSE_LIMIT:
4348 demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4351 do_wide = wide_output = TRUE;
4353 case OPTION_ADJUST_VMA:
4354 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4356 case OPTION_START_ADDRESS:
4357 start_address = parse_vma (optarg, "--start-address");
4358 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4359 fatal (_("error: the start address should be before the end address"));
4361 case OPTION_STOP_ADDRESS:
4362 stop_address = parse_vma (optarg, "--stop-address");
4363 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4364 fatal (_("error: the stop address should be after the start address"));
4368 prefix_length = strlen (prefix);
4369 /* Remove an unnecessary trailing '/' */
4370 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4373 case OPTION_PREFIX_STRIP:
4374 prefix_strip = atoi (optarg);
4375 if (prefix_strip < 0)
4376 fatal (_("error: prefix strip must be non-negative"));
4378 case OPTION_INSN_WIDTH:
4379 insn_width = strtoul (optarg, NULL, 0);
4380 if (insn_width <= 0)
4381 fatal (_("error: instruction width must be positive"));
4383 case OPTION_INLINES:
4384 unwind_inlines = TRUE;
4387 if (strcmp (optarg, "B") == 0)
4388 endian = BFD_ENDIAN_BIG;
4389 else if (strcmp (optarg, "L") == 0)
4390 endian = BFD_ENDIAN_LITTLE;
4393 nonfatal (_("unrecognized -E option"));
4398 if (strncmp (optarg, "big", strlen (optarg)) == 0)
4399 endian = BFD_ENDIAN_BIG;
4400 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4401 endian = BFD_ENDIAN_LITTLE;
4404 non_fatal (_("unrecognized --endian type `%s'"), optarg);
4411 dump_file_header = TRUE;
4415 formats_info = TRUE;
4419 add_include_path (optarg);
4422 dump_private_headers = TRUE;
4426 dump_private_options = optarg;
4430 dump_private_headers = TRUE;
4432 dump_reloc_info = TRUE;
4433 dump_file_header = TRUE;
4434 dump_ar_hdrs = TRUE;
4435 dump_section_headers = TRUE;
4443 dump_dynamic_symtab = TRUE;
4449 disasm_sym = optarg;
4452 disassemble_zeroes = TRUE;
4456 disassemble_all = TRUE;
4461 with_source_code = TRUE;
4470 dump_debugging_tags = 1;
4475 dump_dwarf_section_info = TRUE;
4478 dwarf_select_sections_by_letters (optarg);
4480 dwarf_select_sections_all ();
4483 dump_dwarf_section_info = TRUE;
4486 dwarf_select_sections_by_names (optarg);
4488 dwarf_select_sections_all ();
4490 case OPTION_DWARF_DEPTH:
4493 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4496 case OPTION_DWARF_START:
4499 dwarf_start_die = strtoul (optarg, & cp, 0);
4500 suppress_bfd_header = 1;
4503 case OPTION_DWARF_CHECK:
4508 dump_ctf_section_info = TRUE;
4509 dump_ctf_section_name = xstrdup (optarg);
4512 case OPTION_CTF_PARENT:
4513 dump_ctf_parent_name = xstrdup (optarg);
4517 dump_stab_section_info = TRUE;
4521 dump_section_contents = TRUE;
4525 dump_reloc_info = TRUE;
4529 dump_dynamic_reloc_info = TRUE;
4533 dump_ar_hdrs = TRUE;
4537 dump_section_headers = TRUE;
4542 show_version = TRUE;
4548 /* No need to set seenflag or to break - usage() does not return. */
4555 print_version ("objdump");
4561 exit_status = display_info ();
4565 display_file ("a.out", target, TRUE);
4567 for (; optind < argc;)
4569 display_file (argv[optind], target, optind == argc - 1);
4576 free (dump_ctf_section_name);
4577 free (dump_ctf_parent_name);
4579 END_PROGRESS (program_name);