1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2016 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status = 0;
80 static char *default_target = NULL; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version = 0; /* Show the version number. */
85 static int dump_section_contents; /* -s */
86 static int dump_section_headers; /* -h */
87 static bfd_boolean dump_file_header; /* -f */
88 static int dump_symtab; /* -t */
89 static int dump_dynamic_symtab; /* -T */
90 static int dump_reloc_info; /* -r */
91 static int dump_dynamic_reloc_info; /* -R */
92 static int dump_ar_hdrs; /* -a */
93 static int dump_private_headers; /* -p */
94 static char *dump_private_options; /* -P */
95 static int prefix_addresses; /* --prefix-addresses */
96 static int with_line_numbers; /* -l */
97 static bfd_boolean with_source_code; /* -S */
98 static int show_raw_insn; /* --show-raw-insn */
99 static int dump_dwarf_section_info; /* --dwarf */
100 static int dump_stab_section_info; /* --stabs */
101 static int do_demangle; /* -C, --demangle */
102 static bfd_boolean disassemble; /* -d */
103 static bfd_boolean disassemble_all; /* -D */
104 static int disassemble_zeroes; /* --disassemble-zeroes */
105 static bfd_boolean formats_info; /* -i */
106 static int wide_output; /* -w */
107 static int insn_width; /* --insn-width */
108 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
109 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
110 static int dump_debugging; /* --debugging */
111 static int dump_debugging_tags; /* --debugging-tags */
112 static int suppress_bfd_header;
113 static int dump_special_syms = 0; /* --special-syms */
114 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
115 static int file_start_context = 0; /* --file-start-context */
116 static bfd_boolean display_file_offsets;/* -F */
117 static const char *prefix; /* --prefix */
118 static int prefix_strip; /* --prefix-strip */
119 static size_t prefix_length;
121 /* A structure to record the sections mentioned in -j switches. */
124 const char * name; /* The name of the section. */
125 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
126 struct only * next; /* Pointer to the next structure in the list. */
128 /* Pointer to an array of 'only' structures.
129 This pointer is NULL if the -j switch has not been used. */
130 static struct only * only_list = NULL;
132 /* Variables for handling include file path table. */
133 static const char **include_paths;
134 static int include_path_count;
136 /* Extra info to pass to the section disassembler and address printing
138 struct objdump_disasm_info
142 bfd_boolean require_sec;
143 arelent ** dynrelbuf;
145 disassembler_ftype disassemble_fn;
149 /* Architecture to disassemble for, or default if NULL. */
150 static char *machine = NULL;
152 /* Target specific options to the disassembler. */
153 static char *disassembler_options = NULL;
155 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
156 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
158 /* The symbol table. */
159 static asymbol **syms;
161 /* Number of symbols in `syms'. */
162 static long symcount = 0;
164 /* The sorted symbol table. */
165 static asymbol **sorted_syms;
167 /* Number of symbols in `sorted_syms'. */
168 static long sorted_symcount = 0;
170 /* The dynamic symbol table. */
171 static asymbol **dynsyms;
173 /* The synthetic symbol table. */
174 static asymbol *synthsyms;
175 static long synthcount = 0;
177 /* Number of symbols in `dynsyms'. */
178 static long dynsymcount = 0;
180 static bfd_byte *stabs;
181 static bfd_size_type stab_size;
184 static bfd_size_type stabstr_size;
186 static bfd_boolean is_relocatable = FALSE;
188 /* Handlers for -P/--private. */
189 static const struct objdump_private_desc * const objdump_private_vectors[] =
191 OBJDUMP_PRIVATE_VECTORS
195 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
197 usage (FILE *stream, int status)
199 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
200 fprintf (stream, _(" Display information from object <file(s)>.\n"));
201 fprintf (stream, _(" At least one of the following switches must be given:\n"));
202 fprintf (stream, _("\
203 -a, --archive-headers Display archive header information\n\
204 -f, --file-headers Display the contents of the overall file header\n\
205 -p, --private-headers Display object format specific file header contents\n\
206 -P, --private=OPT,OPT... Display object format specific contents\n\
207 -h, --[section-]headers Display the contents of the section headers\n\
208 -x, --all-headers Display the contents of all headers\n\
209 -d, --disassemble Display assembler contents of executable sections\n\
210 -D, --disassemble-all Display assembler contents of all sections\n\
211 -S, --source Intermix source code with disassembly\n\
212 -s, --full-contents Display the full contents of all sections requested\n\
213 -g, --debugging Display debug information in object file\n\
214 -e, --debugging-tags Display debug information using ctags style\n\
215 -G, --stabs Display (in raw form) any STABS info in the file\n\
216 -W[lLiaprmfFsoRt] or\n\
217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 Display DWARF info in the file\n\
222 -t, --syms Display the contents of the symbol table(s)\n\
223 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
224 -r, --reloc Display the relocation entries in the file\n\
225 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
226 @<file> Read options from <file>\n\
227 -v, --version Display this program's version number\n\
228 -i, --info List object formats and architectures supported\n\
229 -H, --help Display this information\n\
233 const struct objdump_private_desc * const *desc;
235 fprintf (stream, _("\n The following switches are optional:\n"));
236 fprintf (stream, _("\
237 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
238 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
239 -j, --section=NAME Only display information for section NAME\n\
240 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
241 -EB --endian=big Assume big endian format when disassembling\n\
242 -EL --endian=little Assume little endian format when disassembling\n\
243 --file-start-context Include context from start of file (with -S)\n\
244 -I, --include=DIR Add DIR to search list for source files\n\
245 -l, --line-numbers Include line numbers and filenames in output\n\
246 -F, --file-offsets Include file offsets when displaying information\n\
247 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
248 The STYLE, if specified, can be `auto', `gnu',\n\
249 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251 -w, --wide Format output for more than 80 columns\n\
252 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
253 --start-address=ADDR Only process data whose address is >= ADDR\n\
254 --stop-address=ADDR Only process data whose address is <= ADDR\n\
255 --prefix-addresses Print complete address alongside disassembly\n\
256 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
257 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
258 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
259 --special-syms Include special symbols in symbol dumps\n\
260 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
261 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
262 fprintf (stream, _("\
263 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
264 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
266 --dwarf-check Make additional dwarf internal consistency checks.\
268 list_supported_targets (program_name, stream);
269 list_supported_architectures (program_name, stream);
271 disassembler_usage (stream);
273 if (objdump_private_vectors[0] != NULL)
276 _("\nOptions supported for -P/--private switch:\n"));
277 for (desc = objdump_private_vectors; *desc != NULL; desc++)
278 (*desc)->help (stream);
281 if (REPORT_BUGS_TO[0] && status == 0)
282 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
286 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
290 OPTION_START_ADDRESS,
302 static struct option long_options[]=
304 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
305 {"all-headers", no_argument, NULL, 'x'},
306 {"private-headers", no_argument, NULL, 'p'},
307 {"private", required_argument, NULL, 'P'},
308 {"architecture", required_argument, NULL, 'm'},
309 {"archive-headers", no_argument, NULL, 'a'},
310 {"debugging", no_argument, NULL, 'g'},
311 {"debugging-tags", no_argument, NULL, 'e'},
312 {"demangle", optional_argument, NULL, 'C'},
313 {"disassemble", no_argument, NULL, 'd'},
314 {"disassemble-all", no_argument, NULL, 'D'},
315 {"disassembler-options", required_argument, NULL, 'M'},
316 {"disassemble-zeroes", no_argument, NULL, 'z'},
317 {"dynamic-reloc", no_argument, NULL, 'R'},
318 {"dynamic-syms", no_argument, NULL, 'T'},
319 {"endian", required_argument, NULL, OPTION_ENDIAN},
320 {"file-headers", no_argument, NULL, 'f'},
321 {"file-offsets", no_argument, NULL, 'F'},
322 {"file-start-context", no_argument, &file_start_context, 1},
323 {"full-contents", no_argument, NULL, 's'},
324 {"headers", no_argument, NULL, 'h'},
325 {"help", no_argument, NULL, 'H'},
326 {"info", no_argument, NULL, 'i'},
327 {"line-numbers", no_argument, NULL, 'l'},
328 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
329 {"prefix-addresses", no_argument, &prefix_addresses, 1},
330 {"reloc", no_argument, NULL, 'r'},
331 {"section", required_argument, NULL, 'j'},
332 {"section-headers", no_argument, NULL, 'h'},
333 {"show-raw-insn", no_argument, &show_raw_insn, 1},
334 {"source", no_argument, NULL, 'S'},
335 {"special-syms", no_argument, &dump_special_syms, 1},
336 {"include", required_argument, NULL, 'I'},
337 {"dwarf", optional_argument, NULL, OPTION_DWARF},
338 {"stabs", no_argument, NULL, 'G'},
339 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
340 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
341 {"syms", no_argument, NULL, 't'},
342 {"target", required_argument, NULL, 'b'},
343 {"version", no_argument, NULL, 'V'},
344 {"wide", no_argument, NULL, 'w'},
345 {"prefix", required_argument, NULL, OPTION_PREFIX},
346 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
347 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
348 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
349 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
350 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
351 {0, no_argument, 0, 0}
355 nonfatal (const char *msg)
361 /* Returns TRUE if the specified section should be dumped. */
364 process_section_p (asection * section)
368 if (only_list == NULL)
371 for (only = only_list; only; only = only->next)
372 if (strcmp (only->name, section->name) == 0)
381 /* Add an entry to the 'only' list. */
384 add_only (char * name)
388 /* First check to make sure that we do not
389 already have an entry for this name. */
390 for (only = only_list; only; only = only->next)
391 if (strcmp (only->name, name) == 0)
394 only = xmalloc (sizeof * only);
397 only->next = only_list;
401 /* Release the memory used by the 'only' list.
402 PR 11225: Issue a warning message for unseen sections.
403 Only do this if none of the sections were seen. This is mainly to support
404 tools like the GAS testsuite where an object file is dumped with a list of
405 generic section names known to be present in a range of different file
409 free_only_list (void)
411 bfd_boolean at_least_one_seen = FALSE;
415 if (only_list == NULL)
418 for (only = only_list; only; only = only->next)
421 at_least_one_seen = TRUE;
425 for (only = only_list; only; only = next)
427 if (! at_least_one_seen)
429 non_fatal (_("section '%s' mentioned in a -j option, "
430 "but not found in any input file"),
441 dump_section_header (bfd *abfd, asection *section,
442 void *ignored ATTRIBUTE_UNUSED)
445 unsigned int opb = bfd_octets_per_byte (abfd);
447 /* Ignore linker created section. See elfNN_ia64_object_p in
449 if (section->flags & SEC_LINKER_CREATED)
452 /* PR 10413: Skip sections that we are ignoring. */
453 if (! process_section_p (section))
456 printf ("%3d %-13s %08lx ", section->index,
457 bfd_get_section_name (abfd, section),
458 (unsigned long) bfd_section_size (abfd, section) / opb);
459 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
461 bfd_printf_vma (abfd, section->lma);
462 printf (" %08lx 2**%u", (unsigned long) section->filepos,
463 bfd_get_section_alignment (abfd, section));
469 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
471 PF (SEC_HAS_CONTENTS, "CONTENTS");
472 PF (SEC_ALLOC, "ALLOC");
473 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
474 PF (SEC_LOAD, "LOAD");
475 PF (SEC_RELOC, "RELOC");
476 PF (SEC_READONLY, "READONLY");
477 PF (SEC_CODE, "CODE");
478 PF (SEC_DATA, "DATA");
480 PF (SEC_DEBUGGING, "DEBUGGING");
481 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
482 PF (SEC_EXCLUDE, "EXCLUDE");
483 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
484 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
486 PF (SEC_TIC54X_BLOCK, "BLOCK");
487 PF (SEC_TIC54X_CLINK, "CLINK");
489 PF (SEC_SMALL_DATA, "SMALL_DATA");
490 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
492 PF (SEC_COFF_SHARED, "SHARED");
493 PF (SEC_COFF_NOREAD, "NOREAD");
495 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
497 /* Note - sections can have both the READONLY and NOREAD attributes
498 set. In this case the NOREAD takes precedence, but we report both
499 since the user may need to know that both bits are set. */
500 PF (SEC_ELF_NOREAD, "NOREAD");
502 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
503 PF (SEC_GROUP, "GROUP");
504 if (bfd_get_arch (abfd) == bfd_arch_mep)
506 PF (SEC_MEP_VLIW, "VLIW");
509 if ((section->flags & SEC_LINK_ONCE) != 0)
512 struct coff_comdat_info *comdat;
514 switch (section->flags & SEC_LINK_DUPLICATES)
518 case SEC_LINK_DUPLICATES_DISCARD:
519 ls = "LINK_ONCE_DISCARD";
521 case SEC_LINK_DUPLICATES_ONE_ONLY:
522 ls = "LINK_ONCE_ONE_ONLY";
524 case SEC_LINK_DUPLICATES_SAME_SIZE:
525 ls = "LINK_ONCE_SAME_SIZE";
527 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
528 ls = "LINK_ONCE_SAME_CONTENTS";
531 printf ("%s%s", comma, ls);
533 comdat = bfd_coff_get_comdat_section (abfd, section);
535 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
545 dump_headers (bfd *abfd)
547 printf (_("Sections:\n"));
550 printf (_("Idx Name Size VMA LMA File off Algn"));
552 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
553 if (bfd_get_arch_size (abfd) == 32)
554 printf (_("Idx Name Size VMA LMA File off Algn"));
556 printf (_("Idx Name Size VMA LMA File off Algn"));
560 printf (_(" Flags"));
563 bfd_map_over_sections (abfd, dump_section_header, NULL);
567 slurp_symtab (bfd *abfd)
572 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
578 storage = bfd_get_symtab_upper_bound (abfd);
581 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
582 bfd_fatal (_("error message was"));
585 sy = (asymbol **) xmalloc (storage);
587 symcount = bfd_canonicalize_symtab (abfd, sy);
589 bfd_fatal (bfd_get_filename (abfd));
593 /* Read in the dynamic symbols. */
596 slurp_dynamic_symtab (bfd *abfd)
601 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
604 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
606 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
612 bfd_fatal (bfd_get_filename (abfd));
615 sy = (asymbol **) xmalloc (storage);
617 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
619 bfd_fatal (bfd_get_filename (abfd));
623 /* Filter out (in place) symbols that are useless for disassembly.
624 COUNT is the number of elements in SYMBOLS.
625 Return the number of useful symbols. */
628 remove_useless_symbols (asymbol **symbols, long count)
630 asymbol **in_ptr = symbols, **out_ptr = symbols;
634 asymbol *sym = *in_ptr++;
636 if (sym->name == NULL || sym->name[0] == '\0')
638 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
640 if (bfd_is_und_section (sym->section)
641 || bfd_is_com_section (sym->section))
646 return out_ptr - symbols;
649 /* Sort symbols into value order. */
652 compare_symbols (const void *ap, const void *bp)
654 const asymbol *a = * (const asymbol **) ap;
655 const asymbol *b = * (const asymbol **) bp;
665 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
667 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
670 if (a->section > b->section)
672 else if (a->section < b->section)
675 an = bfd_asymbol_name (a);
676 bn = bfd_asymbol_name (b);
680 /* The symbols gnu_compiled and gcc2_compiled convey no real
681 information, so put them after other symbols with the same value. */
682 af = (strstr (an, "gnu_compiled") != NULL
683 || strstr (an, "gcc2_compiled") != NULL);
684 bf = (strstr (bn, "gnu_compiled") != NULL
685 || strstr (bn, "gcc2_compiled") != NULL);
692 /* We use a heuristic for the file name, to try to sort it after
693 more useful symbols. It may not work on non Unix systems, but it
694 doesn't really matter; the only difference is precisely which
695 symbol names get printed. */
697 #define file_symbol(s, sn, snl) \
698 (((s)->flags & BSF_FILE) != 0 \
699 || ((sn)[(snl) - 2] == '.' \
700 && ((sn)[(snl) - 1] == 'o' \
701 || (sn)[(snl) - 1] == 'a')))
703 af = file_symbol (a, an, anl);
704 bf = file_symbol (b, bn, bnl);
711 /* Try to sort global symbols before local symbols before function
712 symbols before debugging symbols. */
717 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
719 if ((aflags & BSF_DEBUGGING) != 0)
724 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
726 if ((aflags & BSF_FUNCTION) != 0)
731 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
733 if ((aflags & BSF_LOCAL) != 0)
738 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
740 if ((aflags & BSF_GLOBAL) != 0)
746 /* Symbols that start with '.' might be section names, so sort them
747 after symbols that don't start with '.'. */
748 if (an[0] == '.' && bn[0] != '.')
750 if (an[0] != '.' && bn[0] == '.')
753 /* Finally, if we can't distinguish them in any other way, try to
754 get consistent results by sorting the symbols by name. */
755 return strcmp (an, bn);
758 /* Sort relocs into address order. */
761 compare_relocs (const void *ap, const void *bp)
763 const arelent *a = * (const arelent **) ap;
764 const arelent *b = * (const arelent **) bp;
766 if (a->address > b->address)
768 else if (a->address < b->address)
771 /* So that associated relocations tied to the same address show up
772 in the correct order, we don't do any further sorting. */
781 /* Print an address (VMA) to the output stream in INFO.
782 If SKIP_ZEROES is TRUE, omit leading zeroes. */
785 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
786 bfd_boolean skip_zeroes)
790 struct objdump_disasm_info *aux;
792 aux = (struct objdump_disasm_info *) inf->application_data;
793 bfd_sprintf_vma (aux->abfd, buf, vma);
798 for (p = buf; *p == '0'; ++p)
803 (*inf->fprintf_func) (inf->stream, "%s", p);
806 /* Print the name of a symbol. */
809 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
813 const char *name, *version_string = NULL;
814 bfd_boolean hidden = FALSE;
817 name = bfd_asymbol_name (sym);
818 if (do_demangle && name[0] != '\0')
820 /* Demangle the name. */
821 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
826 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
828 if (bfd_is_und_section (bfd_get_section (sym)))
833 (*inf->fprintf_func) (inf->stream, "%s", name);
834 if (version_string && *version_string != '\0')
835 (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
841 if (version_string && *version_string != '\0')
842 printf (hidden ? "@%s" : "@@%s", version_string);
849 /* Locate a symbol given a bfd and a section (from INFO->application_data),
850 and a VMA. If INFO->application_data->require_sec is TRUE, then always
851 require the symbol to be in the section. Returns NULL if there is no
852 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
853 of the symbol in sorted_syms. */
856 find_symbol_for_address (bfd_vma vma,
857 struct disassemble_info *inf,
860 /* @@ Would it speed things up to cache the last two symbols returned,
861 and maybe their address ranges? For many processors, only one memory
862 operand can be present at a time, so the 2-entry cache wouldn't be
863 constantly churned by code doing heavy memory accesses. */
865 /* Indices in `sorted_syms'. */
867 long max_count = sorted_symcount;
869 struct objdump_disasm_info *aux;
873 bfd_boolean want_section;
875 if (sorted_symcount < 1)
878 aux = (struct objdump_disasm_info *) inf->application_data;
881 opb = inf->octets_per_byte;
883 /* Perform a binary search looking for the closest symbol to the
884 required value. We are searching the range (min, max_count]. */
885 while (min + 1 < max_count)
889 thisplace = (max_count + min) / 2;
890 sym = sorted_syms[thisplace];
892 if (bfd_asymbol_value (sym) > vma)
893 max_count = thisplace;
894 else if (bfd_asymbol_value (sym) < vma)
903 /* The symbol we want is now in min, the low end of the range we
904 were searching. If there are several symbols with the same
905 value, we want the first one. */
908 && (bfd_asymbol_value (sorted_syms[thisplace])
909 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
912 /* Prefer a symbol in the current section if we have multple symbols
913 with the same value, as can occur with overlays or zero size
916 while (min < max_count
917 && (bfd_asymbol_value (sorted_syms[min])
918 == bfd_asymbol_value (sorted_syms[thisplace])))
920 if (sorted_syms[min]->section == sec
921 && inf->symbol_is_valid (sorted_syms[min], inf))
928 return sorted_syms[thisplace];
933 /* If the file is relocatable, and the symbol could be from this
934 section, prefer a symbol from this section over symbols from
935 others, even if the other symbol's value might be closer.
937 Note that this may be wrong for some symbol references if the
938 sections have overlapping memory ranges, but in that case there's
939 no way to tell what's desired without looking at the relocation
942 Also give the target a chance to reject symbols. */
943 want_section = (aux->require_sec
944 || ((abfd->flags & HAS_RELOC) != 0
945 && vma >= bfd_get_section_vma (abfd, sec)
946 && vma < (bfd_get_section_vma (abfd, sec)
947 + bfd_section_size (abfd, sec) / opb)));
948 if ((sorted_syms[thisplace]->section != sec && want_section)
949 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
952 long newplace = sorted_symcount;
954 for (i = min - 1; i >= 0; i--)
956 if ((sorted_syms[i]->section == sec || !want_section)
957 && inf->symbol_is_valid (sorted_syms[i], inf))
959 if (newplace == sorted_symcount)
962 if (bfd_asymbol_value (sorted_syms[i])
963 != bfd_asymbol_value (sorted_syms[newplace]))
966 /* Remember this symbol and keep searching until we reach
967 an earlier address. */
972 if (newplace != sorted_symcount)
973 thisplace = newplace;
976 /* We didn't find a good symbol with a smaller value.
977 Look for one with a larger value. */
978 for (i = thisplace + 1; i < sorted_symcount; i++)
980 if ((sorted_syms[i]->section == sec || !want_section)
981 && inf->symbol_is_valid (sorted_syms[i], inf))
989 if ((sorted_syms[thisplace]->section != sec && want_section)
990 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
991 /* There is no suitable symbol. */
998 return sorted_syms[thisplace];
1001 /* Print an address and the offset to the nearest symbol. */
1004 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
1005 bfd_vma vma, struct disassemble_info *inf,
1006 bfd_boolean skip_zeroes)
1008 objdump_print_value (vma, inf, skip_zeroes);
1014 (*inf->fprintf_func) (inf->stream, " <%s",
1015 bfd_get_section_name (abfd, sec));
1016 secaddr = bfd_get_section_vma (abfd, sec);
1019 (*inf->fprintf_func) (inf->stream, "-0x");
1020 objdump_print_value (secaddr - vma, inf, TRUE);
1022 else if (vma > secaddr)
1024 (*inf->fprintf_func) (inf->stream, "+0x");
1025 objdump_print_value (vma - secaddr, inf, TRUE);
1027 (*inf->fprintf_func) (inf->stream, ">");
1031 (*inf->fprintf_func) (inf->stream, " <");
1032 objdump_print_symname (abfd, inf, sym);
1033 if (bfd_asymbol_value (sym) > vma)
1035 (*inf->fprintf_func) (inf->stream, "-0x");
1036 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1038 else if (vma > bfd_asymbol_value (sym))
1040 (*inf->fprintf_func) (inf->stream, "+0x");
1041 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1043 (*inf->fprintf_func) (inf->stream, ">");
1046 if (display_file_offsets)
1047 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1048 (long int)(sec->filepos + (vma - sec->vma)));
1051 /* Print an address (VMA), symbolically if possible.
1052 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1055 objdump_print_addr (bfd_vma vma,
1056 struct disassemble_info *inf,
1057 bfd_boolean skip_zeroes)
1059 struct objdump_disasm_info *aux;
1060 asymbol *sym = NULL;
1061 bfd_boolean skip_find = FALSE;
1063 aux = (struct objdump_disasm_info *) inf->application_data;
1065 if (sorted_symcount < 1)
1067 (*inf->fprintf_func) (inf->stream, "0x");
1068 objdump_print_value (vma, inf, skip_zeroes);
1070 if (display_file_offsets)
1071 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1072 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1076 if (aux->reloc != NULL
1077 && aux->reloc->sym_ptr_ptr != NULL
1078 && * aux->reloc->sym_ptr_ptr != NULL)
1080 sym = * aux->reloc->sym_ptr_ptr;
1082 /* Adjust the vma to the reloc. */
1083 vma += bfd_asymbol_value (sym);
1085 if (bfd_is_und_section (bfd_get_section (sym)))
1090 sym = find_symbol_for_address (vma, inf, NULL);
1092 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1096 /* Print VMA to INFO. This function is passed to the disassembler
1100 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1102 objdump_print_addr (vma, inf, ! prefix_addresses);
1105 /* Determine if the given address has a symbol associated with it. */
1108 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1112 sym = find_symbol_for_address (vma, inf, NULL);
1114 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1117 /* Hold the last function name and the last line number we displayed
1118 in a disassembly. */
1120 static char *prev_functionname;
1121 static unsigned int prev_line;
1122 static unsigned int prev_discriminator;
1124 /* We keep a list of all files that we have seen when doing a
1125 disassembly with source, so that we know how much of the file to
1126 display. This can be important for inlined functions. */
1128 struct print_file_list
1130 struct print_file_list *next;
1131 const char *filename;
1132 const char *modname;
1135 const char **linemap;
1138 unsigned max_printed;
1142 static struct print_file_list *print_files;
1144 /* The number of preceding context lines to show when we start
1145 displaying a file for the first time. */
1147 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1149 /* Read a complete file into memory. */
1152 slurp_file (const char *fn, size_t *size)
1155 int ps = getpagesize ();
1160 int fd = open (fn, O_RDONLY | O_BINARY);
1164 if (fstat (fd, &st) < 0)
1171 msize = (*size + ps - 1) & ~(ps - 1);
1172 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1173 if (map != (char *) -1L)
1179 map = (const char *) malloc (*size);
1180 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1182 free ((void *) map);
1189 #define line_map_decrease 5
1191 /* Precompute array of lines for a mapped file. */
1193 static const char **
1194 index_file (const char *map, size_t size, unsigned int *maxline)
1196 const char *p, *lstart, *end;
1197 int chars_per_line = 45; /* First iteration will use 40. */
1198 unsigned int lineno;
1199 const char **linemap = NULL;
1200 unsigned long line_map_size = 0;
1206 for (p = map; p < end; p++)
1210 if (p + 1 < end && p[1] == '\r')
1213 else if (*p == '\r')
1215 if (p + 1 < end && p[1] == '\n')
1221 /* End of line found. */
1223 if (linemap == NULL || line_map_size < lineno + 1)
1225 unsigned long newsize;
1227 chars_per_line -= line_map_decrease;
1228 if (chars_per_line <= 1)
1230 line_map_size = size / chars_per_line + 1;
1231 if (line_map_size < lineno + 1)
1232 line_map_size = lineno + 1;
1233 newsize = line_map_size * sizeof (char *);
1234 linemap = (const char **) xrealloc (linemap, newsize);
1237 linemap[lineno++] = lstart;
1245 /* Tries to open MODNAME, and if successful adds a node to print_files
1246 linked list and returns that node. Returns NULL on failure. */
1248 static struct print_file_list *
1249 try_print_file_open (const char *origname, const char *modname)
1251 struct print_file_list *p;
1253 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1255 p->map = slurp_file (modname, &p->mapsize);
1262 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1265 p->filename = origname;
1266 p->modname = modname;
1267 p->next = print_files;
1273 /* If the source file, as described in the symtab, is not found
1274 try to locate it in one of the paths specified with -I
1275 If found, add location to print_files linked list. */
1277 static struct print_file_list *
1278 update_source_path (const char *filename)
1280 struct print_file_list *p;
1284 p = try_print_file_open (filename, filename);
1288 if (include_path_count == 0)
1291 /* Get the name of the file. */
1292 fname = lbasename (filename);
1294 /* If file exists under a new path, we need to add it to the list
1295 so that show_line knows about it. */
1296 for (i = 0; i < include_path_count; i++)
1298 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1300 p = try_print_file_open (filename, modname);
1310 /* Print a source file line. */
1313 print_line (struct print_file_list *p, unsigned int linenum)
1319 if (linenum >= p->maxline)
1321 l = p->linemap [linenum];
1322 /* Test fwrite return value to quiet glibc warning. */
1323 len = strcspn (l, "\n\r");
1324 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1328 /* Print a range of source code lines. */
1331 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1335 while (start <= end)
1337 print_line (p, start);
1342 /* Show the line number, or the source line, in a disassembly
1346 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1348 const char *filename;
1349 const char *functionname;
1350 unsigned int linenumber;
1351 unsigned int discriminator;
1355 if (! with_line_numbers && ! with_source_code)
1358 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1359 &filename, &functionname,
1360 &linenumber, &discriminator))
1363 if (filename != NULL && *filename == '\0')
1365 if (functionname != NULL && *functionname == '\0')
1366 functionname = NULL;
1369 && IS_ABSOLUTE_PATH (filename)
1373 const char *fname = filename;
1375 path = xmalloc (prefix_length + PATH_MAX + 1);
1378 memcpy (path, prefix, prefix_length);
1379 path_up = path + prefix_length;
1381 /* Build relocated filename, stripping off leading directories
1382 from the initial filename if requested. */
1383 if (prefix_strip > 0)
1388 /* Skip selected directory levels. */
1389 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1390 if (IS_DIR_SEPARATOR(*s))
1397 /* Update complete filename. */
1398 strncpy (path_up, fname, PATH_MAX);
1399 path_up[PATH_MAX] = '\0';
1407 if (with_line_numbers)
1409 if (functionname != NULL
1410 && (prev_functionname == NULL
1411 || strcmp (functionname, prev_functionname) != 0))
1412 printf ("%s():\n", functionname);
1413 if (linenumber > 0 && (linenumber != prev_line ||
1414 (discriminator != prev_discriminator)))
1416 if (discriminator > 0)
1417 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
1418 linenumber, discriminator);
1420 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1424 if (with_source_code
1428 struct print_file_list **pp, *p;
1431 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1432 if (filename_cmp ((*pp)->filename, filename) == 0)
1439 filename = xstrdup (filename);
1440 p = update_source_path (filename);
1443 if (p != NULL && linenumber != p->last_line)
1445 if (file_start_context && p->first)
1449 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1450 if (l >= linenumber)
1452 if (p->max_printed >= l)
1454 if (p->max_printed < linenumber)
1455 l = p->max_printed + 1;
1460 dump_lines (p, l, linenumber);
1461 if (p->max_printed < linenumber)
1462 p->max_printed = linenumber;
1463 p->last_line = linenumber;
1468 if (functionname != NULL
1469 && (prev_functionname == NULL
1470 || strcmp (functionname, prev_functionname) != 0))
1472 if (prev_functionname != NULL)
1473 free (prev_functionname);
1474 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1475 strcpy (prev_functionname, functionname);
1478 if (linenumber > 0 && linenumber != prev_line)
1479 prev_line = linenumber;
1481 if (discriminator != prev_discriminator)
1482 prev_discriminator = discriminator;
1488 /* Pseudo FILE object for strings. */
1496 /* sprintf to a "stream". */
1498 static int ATTRIBUTE_PRINTF_2
1499 objdump_sprintf (SFILE *f, const char *format, ...)
1506 size_t space = f->alloc - f->pos;
1508 va_start (args, format);
1509 n = vsnprintf (f->buffer + f->pos, space, format, args);
1515 f->alloc = (f->alloc + n) * 2;
1516 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1523 /* The number of zeroes we want to see before we start skipping them.
1524 The number is arbitrarily chosen. */
1526 #define DEFAULT_SKIP_ZEROES 8
1528 /* The number of zeroes to skip at the end of a section. If the
1529 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1530 SKIP_ZEROES, they will be disassembled. If there are fewer than
1531 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1532 attempt to avoid disassembling zeroes inserted by section
1535 #define DEFAULT_SKIP_ZEROES_AT_END 3
1537 /* Disassemble some data in memory between given values. */
1540 disassemble_bytes (struct disassemble_info * inf,
1541 disassembler_ftype disassemble_fn,
1544 bfd_vma start_offset,
1545 bfd_vma stop_offset,
1548 arelent ** relppend)
1550 struct objdump_disasm_info *aux;
1552 int octets_per_line;
1553 int skip_addr_chars;
1554 bfd_vma addr_offset;
1555 unsigned int opb = inf->octets_per_byte;
1556 unsigned int skip_zeroes = inf->skip_zeroes;
1557 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1561 aux = (struct objdump_disasm_info *) inf->application_data;
1565 sfile.buffer = (char *) xmalloc (sfile.alloc);
1569 octets_per_line = insn_width;
1571 octets_per_line = 4;
1573 octets_per_line = 16;
1575 /* Figure out how many characters to skip at the start of an
1576 address, to make the disassembly look nicer. We discard leading
1577 zeroes in chunks of 4, ensuring that there is always a leading
1579 skip_addr_chars = 0;
1580 if (! prefix_addresses)
1584 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1586 while (buf[skip_addr_chars] == '0')
1589 /* Don't discard zeros on overflow. */
1590 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1591 skip_addr_chars = 0;
1593 if (skip_addr_chars != 0)
1594 skip_addr_chars = (skip_addr_chars - 1) & -4;
1597 inf->insn_info_valid = 0;
1599 addr_offset = start_offset;
1600 while (addr_offset < stop_offset)
1603 bfd_boolean need_nl = FALSE;
1604 int previous_octets;
1606 /* Remember the length of the previous instruction. */
1607 previous_octets = octets;
1610 /* Make sure we don't use relocs from previous instructions. */
1613 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1615 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1618 if (! disassemble_zeroes
1619 && (inf->insn_info_valid == 0
1620 || inf->branch_delay_insns == 0)
1621 && (z - addr_offset * opb >= skip_zeroes
1622 || (z == stop_offset * opb &&
1623 z - addr_offset * opb < skip_zeroes_at_end)))
1625 /* If there are more nonzero octets to follow, we only skip
1626 zeroes in multiples of 4, to try to avoid running over
1627 the start of an instruction which happens to start with
1629 if (z != stop_offset * opb)
1630 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1632 octets = z - addr_offset * opb;
1634 /* If we are going to display more data, and we are displaying
1635 file offsets, then tell the user how many zeroes we skip
1636 and the file offset from where we resume dumping. */
1637 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1638 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1640 (unsigned long) (section->filepos
1641 + (addr_offset + (octets / opb))));
1651 if (with_line_numbers || with_source_code)
1652 show_line (aux->abfd, section, addr_offset);
1654 if (! prefix_addresses)
1658 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1659 for (s = buf + skip_addr_chars; *s == '0'; s++)
1663 printf ("%s:\t", buf + skip_addr_chars);
1667 aux->require_sec = TRUE;
1668 objdump_print_address (section->vma + addr_offset, inf);
1669 aux->require_sec = FALSE;
1676 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1677 inf->stream = &sfile;
1678 inf->bytes_per_line = 0;
1679 inf->bytes_per_chunk = 0;
1680 inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1682 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1684 if (inf->disassembler_needs_relocs
1685 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1686 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1687 && *relppp < relppend)
1689 bfd_signed_vma distance_to_rel;
1691 distance_to_rel = (**relppp)->address
1692 - (rel_offset + addr_offset);
1694 /* Check to see if the current reloc is associated with
1695 the instruction that we are about to disassemble. */
1696 if (distance_to_rel == 0
1697 /* FIXME: This is wrong. We are trying to catch
1698 relocs that are addressed part way through the
1699 current instruction, as might happen with a packed
1700 VLIW instruction. Unfortunately we do not know the
1701 length of the current instruction since we have not
1702 disassembled it yet. Instead we take a guess based
1703 upon the length of the previous instruction. The
1704 proper solution is to have a new target-specific
1705 disassembler function which just returns the length
1706 of an instruction at a given address without trying
1707 to display its disassembly. */
1708 || (distance_to_rel > 0
1709 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1711 inf->flags |= INSN_HAS_RELOC;
1712 aux->reloc = **relppp;
1716 if (! disassemble_all
1717 && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1718 == (SEC_CODE | SEC_HAS_CONTENTS))
1719 /* Set a stop_vma so that the disassembler will not read
1720 beyond the next symbol. We assume that symbols appear on
1721 the boundaries between instructions. We only do this when
1722 disassembling code of course, and when -D is in effect. */
1723 inf->stop_vma = section->vma + stop_offset;
1725 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1728 inf->fprintf_func = (fprintf_ftype) fprintf;
1729 inf->stream = stdout;
1730 if (insn_width == 0 && inf->bytes_per_line != 0)
1731 octets_per_line = inf->bytes_per_line;
1732 if (octets < (int) opb)
1735 printf ("%s\n", sfile.buffer);
1738 non_fatal (_("disassemble_fn returned length %d"),
1749 octets = octets_per_line;
1750 if (addr_offset + octets / opb > stop_offset)
1751 octets = (stop_offset - addr_offset) * opb;
1753 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1755 if (ISPRINT (data[j]))
1756 buf[j - addr_offset * opb] = data[j];
1758 buf[j - addr_offset * opb] = '.';
1760 buf[j - addr_offset * opb] = '\0';
1763 if (prefix_addresses
1765 : show_raw_insn >= 0)
1769 /* If ! prefix_addresses and ! wide_output, we print
1770 octets_per_line octets per line. */
1772 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1773 pb = octets_per_line;
1775 if (inf->bytes_per_chunk)
1776 bpc = inf->bytes_per_chunk;
1780 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1784 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1786 for (k = bpc - 1; k >= 0; k--)
1787 printf ("%02x", (unsigned) data[j + k]);
1792 for (k = 0; k < bpc; k++)
1793 printf ("%02x", (unsigned) data[j + k]);
1798 for (; pb < octets_per_line; pb += bpc)
1802 for (k = 0; k < bpc; k++)
1807 /* Separate raw data from instruction by extra space. */
1817 printf ("%s", sfile.buffer);
1819 if (prefix_addresses
1821 : show_raw_insn >= 0)
1829 j = addr_offset * opb + pb;
1831 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1832 for (s = buf + skip_addr_chars; *s == '0'; s++)
1836 printf ("%s:\t", buf + skip_addr_chars);
1838 pb += octets_per_line;
1841 for (; j < addr_offset * opb + pb; j += bpc)
1845 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1847 for (k = bpc - 1; k >= 0; k--)
1848 printf ("%02x", (unsigned) data[j + k]);
1853 for (k = 0; k < bpc; k++)
1854 printf ("%02x", (unsigned) data[j + k]);
1867 while ((*relppp) < relppend
1868 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1870 if (dump_reloc_info || dump_dynamic_reloc_info)
1881 objdump_print_value (section->vma - rel_offset + q->address,
1884 if (q->howto == NULL)
1885 printf (": *unknown*\t");
1886 else if (q->howto->name)
1887 printf (": %s\t", q->howto->name);
1889 printf (": %d\t", q->howto->type);
1891 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1892 printf ("*unknown*");
1895 const char *sym_name;
1897 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1898 if (sym_name != NULL && *sym_name != '\0')
1899 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1904 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1905 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1906 if (sym_name == NULL || *sym_name == '\0')
1907 sym_name = "*unknown*";
1908 printf ("%s", sym_name);
1914 bfd_signed_vma addend = q->addend;
1922 objdump_print_value (addend, inf, TRUE);
1934 addr_offset += octets / opb;
1937 free (sfile.buffer);
1941 disassemble_section (bfd *abfd, asection *section, void *inf)
1943 const struct elf_backend_data * bed;
1944 bfd_vma sign_adjust = 0;
1945 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
1946 struct objdump_disasm_info * paux;
1947 unsigned int opb = pinfo->octets_per_byte;
1948 bfd_byte * data = NULL;
1949 bfd_size_type datasize = 0;
1950 arelent ** rel_pp = NULL;
1951 arelent ** rel_ppstart = NULL;
1952 arelent ** rel_ppend;
1953 bfd_vma stop_offset;
1954 asymbol * sym = NULL;
1958 unsigned long addr_offset;
1960 /* Sections that do not contain machine
1961 code are not normally disassembled. */
1962 if (! disassemble_all
1963 && only_list == NULL
1964 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1965 != (SEC_CODE | SEC_HAS_CONTENTS)))
1968 if (! process_section_p (section))
1971 datasize = bfd_get_section_size (section);
1975 if (start_address == (bfd_vma) -1
1976 || start_address < section->vma)
1979 addr_offset = start_address - section->vma;
1981 if (stop_address == (bfd_vma) -1)
1982 stop_offset = datasize / opb;
1985 if (stop_address < section->vma)
1988 stop_offset = stop_address - section->vma;
1989 if (stop_offset > datasize / opb)
1990 stop_offset = datasize / opb;
1993 if (addr_offset >= stop_offset)
1996 /* Decide which set of relocs to use. Load them if necessary. */
1997 paux = (struct objdump_disasm_info *) pinfo->application_data;
1998 if (paux->dynrelbuf)
2000 rel_pp = paux->dynrelbuf;
2001 rel_count = paux->dynrelcount;
2002 /* Dynamic reloc addresses are absolute, non-dynamic are section
2003 relative. REL_OFFSET specifies the reloc address corresponding
2004 to the start of this section. */
2005 rel_offset = section->vma;
2013 if ((section->flags & SEC_RELOC) != 0
2014 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2018 relsize = bfd_get_reloc_upper_bound (abfd, section);
2020 bfd_fatal (bfd_get_filename (abfd));
2024 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2025 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2027 bfd_fatal (bfd_get_filename (abfd));
2029 /* Sort the relocs by address. */
2030 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2034 rel_ppend = rel_pp + rel_count;
2036 data = (bfd_byte *) xmalloc (datasize);
2038 bfd_get_section_contents (abfd, section, data, 0, datasize);
2040 paux->sec = section;
2041 pinfo->buffer = data;
2042 pinfo->buffer_vma = section->vma;
2043 pinfo->buffer_length = datasize;
2044 pinfo->section = section;
2046 /* Skip over the relocs belonging to addresses below the
2048 while (rel_pp < rel_ppend
2049 && (*rel_pp)->address < rel_offset + addr_offset)
2052 printf (_("\nDisassembly of section %s:\n"), section->name);
2054 /* Find the nearest symbol forwards from our current position. */
2055 paux->require_sec = TRUE;
2056 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2057 (struct disassemble_info *) inf,
2059 paux->require_sec = FALSE;
2061 /* PR 9774: If the target used signed addresses then we must make
2062 sure that we sign extend the value that we calculate for 'addr'
2063 in the loop below. */
2064 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2065 && (bed = get_elf_backend_data (abfd)) != NULL
2066 && bed->sign_extend_vma)
2067 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2069 /* Disassemble a block of instructions up to the address associated with
2070 the symbol we have just found. Then print the symbol and find the
2071 next symbol on. Repeat until we have disassembled the entire section
2072 or we have reached the end of the address range we are interested in. */
2073 while (addr_offset < stop_offset)
2077 bfd_vma nextstop_offset;
2080 addr = section->vma + addr_offset;
2081 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2083 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2088 (x < sorted_symcount
2089 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2093 pinfo->symbols = sorted_syms + place;
2094 pinfo->num_symbols = x - place;
2095 pinfo->symtab_pos = place;
2099 pinfo->symbols = NULL;
2100 pinfo->num_symbols = 0;
2101 pinfo->symtab_pos = -1;
2104 if (! prefix_addresses)
2106 pinfo->fprintf_func (pinfo->stream, "\n");
2107 objdump_print_addr_with_sym (abfd, section, sym, addr,
2109 pinfo->fprintf_func (pinfo->stream, ":\n");
2112 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2114 else if (sym == NULL)
2118 #define is_valid_next_sym(SYM) \
2119 ((SYM)->section == section \
2120 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2121 && pinfo->symbol_is_valid (SYM, pinfo))
2123 /* Search forward for the next appropriate symbol in
2124 SECTION. Note that all the symbols are sorted
2125 together into one big array, and that some sections
2126 may have overlapping addresses. */
2127 while (place < sorted_symcount
2128 && ! is_valid_next_sym (sorted_syms [place]))
2131 if (place >= sorted_symcount)
2134 nextsym = sorted_syms[place];
2137 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2138 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2139 else if (nextsym == NULL)
2140 nextstop_offset = stop_offset;
2142 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2144 if (nextstop_offset > stop_offset
2145 || nextstop_offset <= addr_offset)
2146 nextstop_offset = stop_offset;
2148 /* If a symbol is explicitly marked as being an object
2149 rather than a function, just dump the bytes without
2150 disassembling them. */
2153 || sym->section != section
2154 || bfd_asymbol_value (sym) > addr
2155 || ((sym->flags & BSF_OBJECT) == 0
2156 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2158 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2160 || (sym->flags & BSF_FUNCTION) != 0)
2165 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2166 addr_offset, nextstop_offset,
2167 rel_offset, &rel_pp, rel_ppend);
2169 addr_offset = nextstop_offset;
2175 if (rel_ppstart != NULL)
2179 /* Disassemble the contents of an object file. */
2182 disassemble_data (bfd *abfd)
2184 struct disassemble_info disasm_info;
2185 struct objdump_disasm_info aux;
2189 prev_functionname = NULL;
2191 prev_discriminator = 0;
2193 /* We make a copy of syms to sort. We don't want to sort syms
2194 because that will screw up the relocs. */
2195 sorted_symcount = symcount ? symcount : dynsymcount;
2196 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2197 * sizeof (asymbol *));
2198 memcpy (sorted_syms, symcount ? syms : dynsyms,
2199 sorted_symcount * sizeof (asymbol *));
2201 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2203 for (i = 0; i < synthcount; ++i)
2205 sorted_syms[sorted_symcount] = synthsyms + i;
2209 /* Sort the symbols into section and symbol order. */
2210 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2212 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2214 disasm_info.application_data = (void *) &aux;
2216 aux.require_sec = FALSE;
2217 aux.dynrelbuf = NULL;
2218 aux.dynrelcount = 0;
2221 disasm_info.print_address_func = objdump_print_address;
2222 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2224 if (machine != NULL)
2226 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2229 fatal (_("can't use supplied machine %s"), machine);
2231 abfd->arch_info = inf;
2234 if (endian != BFD_ENDIAN_UNKNOWN)
2236 struct bfd_target *xvec;
2238 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2239 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2240 xvec->byteorder = endian;
2244 /* Use libopcodes to locate a suitable disassembler. */
2245 aux.disassemble_fn = disassembler (abfd);
2246 if (!aux.disassemble_fn)
2248 non_fatal (_("can't disassemble for architecture %s\n"),
2249 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2254 disasm_info.flavour = bfd_get_flavour (abfd);
2255 disasm_info.arch = bfd_get_arch (abfd);
2256 disasm_info.mach = bfd_get_mach (abfd);
2257 disasm_info.disassembler_options = disassembler_options;
2258 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2259 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2260 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2261 disasm_info.disassembler_needs_relocs = FALSE;
2263 if (bfd_big_endian (abfd))
2264 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2265 else if (bfd_little_endian (abfd))
2266 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2268 /* ??? Aborting here seems too drastic. We could default to big or little
2270 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2272 /* Allow the target to customize the info structure. */
2273 disassemble_init_for_target (& disasm_info);
2275 /* Pre-load the dynamic relocs if we are going
2276 to be dumping them along with the disassembly. */
2277 if (dump_dynamic_reloc_info)
2279 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2282 bfd_fatal (bfd_get_filename (abfd));
2286 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2287 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2290 if (aux.dynrelcount < 0)
2291 bfd_fatal (bfd_get_filename (abfd));
2293 /* Sort the relocs by address. */
2294 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2298 disasm_info.symtab = sorted_syms;
2299 disasm_info.symtab_size = sorted_symcount;
2301 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2303 if (aux.dynrelbuf != NULL)
2304 free (aux.dynrelbuf);
2309 load_specific_debug_section (enum dwarf_section_display_enum debug,
2310 asection *sec, void *file)
2312 struct dwarf_section *section = &debug_displays [debug].section;
2313 bfd *abfd = (bfd *) file;
2316 /* If it is already loaded, do nothing. */
2317 if (section->start != NULL)
2320 section->reloc_info = NULL;
2321 section->num_relocs = 0;
2322 section->address = bfd_get_section_vma (abfd, sec);
2323 section->size = bfd_get_section_size (sec);
2324 section->start = NULL;
2325 section->user_data = sec;
2326 ret = bfd_get_full_section_contents (abfd, sec, §ion->start);
2330 free_debug_section (debug);
2331 printf (_("\nCan't get contents for section '%s'.\n"),
2336 if (is_relocatable && debug_displays [debug].relocate)
2338 bfd_cache_section_contents (sec, section->start);
2340 ret = bfd_simple_get_relocated_section_contents (abfd,
2347 free_debug_section (debug);
2348 printf (_("\nCan't get contents for section '%s'.\n"),
2355 reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2358 unsigned long reloc_count;
2361 relocs = (arelent **) xmalloc (reloc_size);
2363 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2364 if (reloc_count == 0)
2368 section->reloc_info = relocs;
2369 section->num_relocs = reloc_count;
2378 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2383 if (dsec == NULL || dsec->reloc_info == NULL)
2386 relocs = (arelent **) dsec->reloc_info;
2388 for (; (rp = * relocs) != NULL; ++ relocs)
2389 if (rp->address == offset)
2396 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2398 struct dwarf_section *section = &debug_displays [debug].section;
2399 bfd *abfd = (bfd *) file;
2402 /* If it is already loaded, do nothing. */
2403 if (section->start != NULL)
2406 /* Locate the debug section. */
2407 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2409 section->name = section->uncompressed_name;
2412 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2414 section->name = section->compressed_name;
2419 return load_specific_debug_section (debug, sec, file);
2423 free_debug_section (enum dwarf_section_display_enum debug)
2425 struct dwarf_section *section = &debug_displays [debug].section;
2427 if (section->start == NULL)
2430 /* PR 17512: file: 0f67f69d. */
2431 if (section->user_data != NULL)
2433 asection * sec = (asection *) section->user_data;
2435 /* If we are freeing contents that are also pointed to by the BFD
2436 library's section structure then make sure to update those pointers
2437 too. Otherwise, the next time we try to load data for this section
2438 we can end up using a stale pointer. */
2439 if (section->start == sec->contents)
2441 sec->contents = NULL;
2442 sec->flags &= ~ SEC_IN_MEMORY;
2443 sec->compress_status = COMPRESS_SECTION_NONE;
2447 free ((char *) section->start);
2448 section->start = NULL;
2449 section->address = 0;
2454 dump_dwarf_section (bfd *abfd, asection *section,
2455 void *arg ATTRIBUTE_UNUSED)
2457 const char *name = bfd_get_section_name (abfd, section);
2461 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2462 match = ".debug_info";
2466 for (i = 0; i < max; i++)
2467 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2468 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2469 && debug_displays [i].enabled != NULL
2470 && *debug_displays [i].enabled)
2472 struct dwarf_section *sec = &debug_displays [i].section;
2474 if (strcmp (sec->uncompressed_name, match) == 0)
2475 sec->name = sec->uncompressed_name;
2477 sec->name = sec->compressed_name;
2478 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2481 debug_displays [i].display (sec, abfd);
2483 if (i != info && i != abbrev)
2484 free_debug_section ((enum dwarf_section_display_enum) i);
2490 /* Dump the dwarf debugging information. */
2493 dump_dwarf (bfd *abfd)
2495 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2497 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2499 if (bfd_big_endian (abfd))
2500 byte_get = byte_get_big_endian;
2501 else if (bfd_little_endian (abfd))
2502 byte_get = byte_get_little_endian;
2504 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2506 warn (_("File %s does not contain any dwarf debug information\n"),
2507 bfd_get_filename (abfd));
2511 switch (bfd_get_arch (abfd))
2514 switch (bfd_get_mach (abfd))
2516 case bfd_mach_x86_64:
2517 case bfd_mach_x86_64_intel_syntax:
2518 case bfd_mach_x86_64_nacl:
2519 case bfd_mach_x64_32:
2520 case bfd_mach_x64_32_intel_syntax:
2521 case bfd_mach_x64_32_nacl:
2522 init_dwarf_regnames_x86_64 ();
2526 init_dwarf_regnames_i386 ();
2531 case bfd_arch_iamcu:
2532 init_dwarf_regnames_iamcu ();
2535 case bfd_arch_aarch64:
2536 init_dwarf_regnames_aarch64();
2540 init_dwarf_regnames_s390 ();
2547 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2549 free_debug_memory ();
2552 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2553 it. Return NULL on failure. */
2556 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2562 stabsect = bfd_get_section_by_name (abfd, sect_name);
2563 if (stabsect == NULL)
2565 printf (_("No %s section present\n\n"), sect_name);
2569 size = bfd_section_size (abfd, stabsect);
2570 contents = (char *) xmalloc (size);
2572 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2574 non_fatal (_("reading %s section of %s failed: %s"),
2575 sect_name, bfd_get_filename (abfd),
2576 bfd_errmsg (bfd_get_error ()));
2587 /* Stabs entries use a 12 byte format:
2588 4 byte string table index
2590 1 byte stab other field
2591 2 byte stab desc field
2593 FIXME: This will have to change for a 64 bit object format. */
2595 #define STRDXOFF (0)
2597 #define OTHEROFF (5)
2600 #define STABSIZE (12)
2602 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2603 using string table section STRSECT_NAME (in `strtab'). */
2606 print_section_stabs (bfd *abfd,
2607 const char *stabsect_name,
2608 unsigned *string_offset_ptr)
2611 unsigned file_string_table_offset = 0;
2612 unsigned next_file_string_table_offset = *string_offset_ptr;
2613 bfd_byte *stabp, *stabs_end;
2616 stabs_end = stabp + stab_size;
2618 printf (_("Contents of %s section:\n\n"), stabsect_name);
2619 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2621 /* Loop through all symbols and print them.
2623 We start the index at -1 because there is a dummy symbol on
2624 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2625 for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
2629 unsigned char type, other;
2630 unsigned short desc;
2633 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2634 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2635 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2636 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2637 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2639 printf ("\n%-6d ", i);
2640 /* Either print the stab name, or, if unnamed, print its number
2641 again (makes consistent formatting for tools like awk). */
2642 name = bfd_get_stab_name (type);
2644 printf ("%-6s", name);
2645 else if (type == N_UNDF)
2648 printf ("%-6d", type);
2649 printf (" %-6d %-6d ", other, desc);
2650 bfd_printf_vma (abfd, value);
2651 printf (" %-6lu", strx);
2653 /* Symbols with type == 0 (N_UNDF) specify the length of the
2654 string table associated with this file. We use that info
2655 to know how to relocate the *next* file's string table indices. */
2658 file_string_table_offset = next_file_string_table_offset;
2659 next_file_string_table_offset += value;
2663 bfd_size_type amt = strx + file_string_table_offset;
2665 /* Using the (possibly updated) string table offset, print the
2666 string (if any) associated with this symbol. */
2667 if (amt < stabstr_size)
2668 /* PR 17512: file: 079-79389-0.001:0.1. */
2669 printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
2675 *string_offset_ptr = next_file_string_table_offset;
2680 const char * section_name;
2681 const char * string_section_name;
2682 unsigned string_offset;
2687 find_stabs_section (bfd *abfd, asection *section, void *names)
2690 stab_section_names * sought = (stab_section_names *) names;
2692 /* Check for section names for which stabsect_name is a prefix, to
2693 handle .stab.N, etc. */
2694 len = strlen (sought->section_name);
2696 /* If the prefix matches, and the files section name ends with a
2697 nul or a digit, then we match. I.e., we want either an exact
2698 match or a section followed by a number. */
2699 if (strncmp (sought->section_name, section->name, len) == 0
2700 && (section->name[len] == 0
2701 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2704 strtab = read_section_stabs (abfd, sought->string_section_name,
2709 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2712 print_section_stabs (abfd, section->name, &sought->string_offset);
2718 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2720 stab_section_names s;
2722 s.section_name = stabsect_name;
2723 s.string_section_name = strsect_name;
2724 s.string_offset = 0;
2726 bfd_map_over_sections (abfd, find_stabs_section, & s);
2732 /* Dump the any sections containing stabs debugging information. */
2735 dump_stabs (bfd *abfd)
2737 dump_stabs_section (abfd, ".stab", ".stabstr");
2738 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2739 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2742 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2744 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2748 dump_bfd_header (bfd *abfd)
2752 printf (_("architecture: %s, "),
2753 bfd_printable_arch_mach (bfd_get_arch (abfd),
2754 bfd_get_mach (abfd)));
2755 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2757 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2758 PF (HAS_RELOC, "HAS_RELOC");
2759 PF (EXEC_P, "EXEC_P");
2760 PF (HAS_LINENO, "HAS_LINENO");
2761 PF (HAS_DEBUG, "HAS_DEBUG");
2762 PF (HAS_SYMS, "HAS_SYMS");
2763 PF (HAS_LOCALS, "HAS_LOCALS");
2764 PF (DYNAMIC, "DYNAMIC");
2765 PF (WP_TEXT, "WP_TEXT");
2766 PF (D_PAGED, "D_PAGED");
2767 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2768 printf (_("\nstart address 0x"));
2769 bfd_printf_vma (abfd, abfd->start_address);
2775 dump_bfd_private_header (bfd *abfd)
2777 bfd_print_private_bfd_data (abfd, stdout);
2781 dump_target_specific (bfd *abfd)
2783 const struct objdump_private_desc * const *desc;
2784 struct objdump_private_option *opt;
2787 /* Find the desc. */
2788 for (desc = objdump_private_vectors; *desc != NULL; desc++)
2789 if ((*desc)->filter (abfd))
2794 non_fatal (_("option -P/--private not supported by this file"));
2798 /* Clear all options. */
2799 for (opt = (*desc)->options; opt->name; opt++)
2800 opt->selected = FALSE;
2802 /* Decode options. */
2803 b = dump_private_options;
2806 e = strchr (b, ',');
2811 for (opt = (*desc)->options; opt->name; opt++)
2812 if (strcmp (opt->name, b) == 0)
2814 opt->selected = TRUE;
2817 if (opt->name == NULL)
2818 non_fatal (_("target specific dump '%s' not supported"), b);
2829 (*desc)->dump (abfd);
2832 /* Display a section in hexadecimal format with associated characters.
2833 Each line prefixed by the zero padded address. */
2836 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2839 bfd_size_type datasize;
2840 bfd_vma addr_offset;
2841 bfd_vma start_offset;
2842 bfd_vma stop_offset;
2843 unsigned int opb = bfd_octets_per_byte (abfd);
2844 /* Bytes per line. */
2845 const int onaline = 16;
2850 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2853 if (! process_section_p (section))
2856 if ((datasize = bfd_section_size (abfd, section)) == 0)
2859 /* Compute the address range to display. */
2860 if (start_address == (bfd_vma) -1
2861 || start_address < section->vma)
2864 start_offset = start_address - section->vma;
2866 if (stop_address == (bfd_vma) -1)
2867 stop_offset = datasize / opb;
2870 if (stop_address < section->vma)
2873 stop_offset = stop_address - section->vma;
2875 if (stop_offset > datasize / opb)
2876 stop_offset = datasize / opb;
2879 if (start_offset >= stop_offset)
2882 printf (_("Contents of section %s:"), section->name);
2883 if (display_file_offsets)
2884 printf (_(" (Starting at file offset: 0x%lx)"),
2885 (unsigned long) (section->filepos + start_offset));
2888 if (!bfd_get_full_section_contents (abfd, section, &data))
2890 non_fatal (_("Reading section %s failed because: %s"),
2891 section->name, bfd_errmsg (bfd_get_error ()));
2897 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2898 if (strlen (buf) >= sizeof (buf))
2902 while (buf[count] == '0' && buf[count+1] != '\0')
2904 count = strlen (buf) - count;
2908 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2909 if (strlen (buf) >= sizeof (buf))
2913 while (buf[count] == '0' && buf[count+1] != '\0')
2915 count = strlen (buf) - count;
2919 for (addr_offset = start_offset;
2920 addr_offset < stop_offset; addr_offset += onaline / opb)
2924 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2925 count = strlen (buf);
2926 if ((size_t) count >= sizeof (buf))
2930 while (count < width)
2935 fputs (buf + count - width, stdout);
2938 for (j = addr_offset * opb;
2939 j < addr_offset * opb + onaline; j++)
2941 if (j < stop_offset * opb)
2942 printf ("%02x", (unsigned) (data[j]));
2950 for (j = addr_offset * opb;
2951 j < addr_offset * opb + onaline; j++)
2953 if (j >= stop_offset * opb)
2956 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2963 /* Actually display the various requested regions. */
2966 dump_data (bfd *abfd)
2968 bfd_map_over_sections (abfd, dump_section, NULL);
2971 /* Should perhaps share code and display with nm? */
2974 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2983 max_count = dynsymcount;
2984 printf ("DYNAMIC SYMBOL TABLE:\n");
2989 max_count = symcount;
2990 printf ("SYMBOL TABLE:\n");
2994 printf (_("no symbols\n"));
2996 for (count = 0; count < max_count; count++)
3000 if (*current == NULL)
3001 printf (_("no information for symbol number %ld\n"), count);
3003 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3004 printf (_("could not determine the type of symbol number %ld\n"),
3007 else if (process_section_p ((* current)->section)
3008 && (dump_special_syms
3009 || !bfd_is_target_special_symbol (cur_bfd, *current)))
3011 const char *name = (*current)->name;
3013 if (do_demangle && name != NULL && *name != '\0')
3017 /* If we want to demangle the name, we demangle it
3018 here, and temporarily clobber it while calling
3019 bfd_print_symbol. FIXME: This is a gross hack. */
3020 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
3022 (*current)->name = alloc;
3023 bfd_print_symbol (cur_bfd, stdout, *current,
3024 bfd_print_symbol_all);
3027 (*current)->name = name;
3032 bfd_print_symbol (cur_bfd, stdout, *current,
3033 bfd_print_symbol_all);
3043 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3046 char *last_filename, *last_functionname;
3047 unsigned int last_line;
3048 unsigned int last_discriminator;
3050 /* Get column headers lined up reasonably. */
3058 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3059 width = strlen (buf) - 7;
3061 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3064 last_filename = NULL;
3065 last_functionname = NULL;
3067 last_discriminator = 0;
3069 for (p = relpp; relcount && *p != NULL; p++, relcount--)
3072 const char *filename, *functionname;
3073 unsigned int linenumber;
3074 unsigned int discriminator;
3075 const char *sym_name;
3076 const char *section_name;
3077 bfd_vma addend2 = 0;
3079 if (start_address != (bfd_vma) -1
3080 && q->address < start_address)
3082 if (stop_address != (bfd_vma) -1
3083 && q->address > stop_address)
3086 if (with_line_numbers
3088 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3089 &filename, &functionname,
3090 &linenumber, &discriminator))
3092 if (functionname != NULL
3093 && (last_functionname == NULL
3094 || strcmp (functionname, last_functionname) != 0))
3096 printf ("%s():\n", functionname);
3097 if (last_functionname != NULL)
3098 free (last_functionname);
3099 last_functionname = xstrdup (functionname);
3103 && (linenumber != last_line
3104 || (filename != NULL
3105 && last_filename != NULL
3106 && filename_cmp (filename, last_filename) != 0)
3107 || (discriminator != last_discriminator)))
3109 if (discriminator > 0)
3110 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
3112 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
3113 linenumber, discriminator);
3114 last_line = linenumber;
3115 last_discriminator = discriminator;
3116 if (last_filename != NULL)
3117 free (last_filename);
3118 if (filename == NULL)
3119 last_filename = NULL;
3121 last_filename = xstrdup (filename);
3125 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3127 sym_name = (*(q->sym_ptr_ptr))->name;
3128 section_name = (*(q->sym_ptr_ptr))->section->name;
3133 section_name = NULL;
3136 bfd_printf_vma (abfd, q->address);
3137 if (q->howto == NULL)
3138 printf (" *unknown* ");
3139 else if (q->howto->name)
3141 const char *name = q->howto->name;
3143 /* R_SPARC_OLO10 relocations contain two addends.
3144 But because 'arelent' lacks enough storage to
3145 store them both, the 64-bit ELF Sparc backend
3146 records this as two relocations. One R_SPARC_LO10
3147 and one R_SPARC_13, both pointing to the same
3148 address. This is merely so that we have some
3149 place to store both addend fields.
3151 Undo this transformation, otherwise the output
3152 will be confusing. */
3153 if (abfd->xvec->flavour == bfd_target_elf_flavour
3154 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3156 && !strcmp (q->howto->name, "R_SPARC_LO10"))
3158 arelent *q2 = *(p + 1);
3161 && q->address == q2->address
3162 && !strcmp (q2->howto->name, "R_SPARC_13"))
3164 name = "R_SPARC_OLO10";
3165 addend2 = q2->addend;
3169 printf (" %-16s ", name);
3172 printf (" %-16d ", q->howto->type);
3176 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3180 if (section_name == NULL)
3181 section_name = "*unknown*";
3182 printf ("[%s]", section_name);
3187 bfd_signed_vma addend = q->addend;
3195 bfd_printf_vma (abfd, addend);
3200 bfd_printf_vma (abfd, addend2);
3206 if (last_filename != NULL)
3207 free (last_filename);
3208 if (last_functionname != NULL)
3209 free (last_functionname);
3213 dump_relocs_in_section (bfd *abfd,
3215 void *dummy ATTRIBUTE_UNUSED)
3221 if ( bfd_is_abs_section (section)
3222 || bfd_is_und_section (section)
3223 || bfd_is_com_section (section)
3224 || (! process_section_p (section))
3225 || ((section->flags & SEC_RELOC) == 0))
3228 relsize = bfd_get_reloc_upper_bound (abfd, section);
3230 bfd_fatal (bfd_get_filename (abfd));
3232 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3236 printf (" (none)\n\n");
3240 relpp = (arelent **) xmalloc (relsize);
3241 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3246 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd));
3247 bfd_fatal (_("error message was"));
3249 else if (relcount == 0)
3250 printf (" (none)\n\n");
3254 dump_reloc_set (abfd, section, relpp, relcount);
3261 dump_relocs (bfd *abfd)
3263 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3267 dump_dynamic_relocs (bfd *abfd)
3273 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3275 bfd_fatal (bfd_get_filename (abfd));
3277 printf ("DYNAMIC RELOCATION RECORDS");
3280 printf (" (none)\n\n");
3283 relpp = (arelent **) xmalloc (relsize);
3284 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3287 bfd_fatal (bfd_get_filename (abfd));
3288 else if (relcount == 0)
3289 printf (" (none)\n\n");
3293 dump_reloc_set (abfd, NULL, relpp, relcount);
3300 /* Creates a table of paths, to search for source files. */
3303 add_include_path (const char *path)
3307 include_path_count++;
3308 include_paths = (const char **)
3309 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3310 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3311 if (path[1] == ':' && path[2] == 0)
3312 path = concat (path, ".", (const char *) 0);
3314 include_paths[include_path_count - 1] = path;
3318 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3322 if ((section->flags & SEC_DEBUGGING) == 0)
3324 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3325 section->vma += adjust_section_vma;
3327 section->lma += adjust_section_vma;
3331 /* Dump selected contents of ABFD. */
3334 dump_bfd (bfd *abfd)
3336 /* If we are adjusting section VMA's, change them all now. Changing
3337 the BFD information is a hack. However, we must do it, or
3338 bfd_find_nearest_line will not do the right thing. */
3339 if (adjust_section_vma != 0)
3341 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3342 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3345 if (! dump_debugging_tags && ! suppress_bfd_header)
3346 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
3349 print_arelt_descr (stdout, abfd, TRUE);
3350 if (dump_file_header)
3351 dump_bfd_header (abfd);
3352 if (dump_private_headers)
3353 dump_bfd_private_header (abfd);
3354 if (dump_private_options != NULL)
3355 dump_target_specific (abfd);
3356 if (! dump_debugging_tags && ! suppress_bfd_header)
3363 || dump_dwarf_section_info)
3364 syms = slurp_symtab (abfd);
3366 if (dump_section_headers)
3367 dump_headers (abfd);
3369 if (dump_dynamic_symtab || dump_dynamic_reloc_info
3370 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3371 dynsyms = slurp_dynamic_symtab (abfd);
3374 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3375 dynsymcount, dynsyms, &synthsyms);
3381 dump_symbols (abfd, FALSE);
3382 if (dump_dynamic_symtab)
3383 dump_symbols (abfd, TRUE);
3384 if (dump_dwarf_section_info)
3386 if (dump_stab_section_info)
3388 if (dump_reloc_info && ! disassemble)
3390 if (dump_dynamic_reloc_info && ! disassemble)
3391 dump_dynamic_relocs (abfd);
3392 if (dump_section_contents)
3395 disassemble_data (abfd);
3401 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3402 if (dhandle != NULL)
3404 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3406 dump_debugging_tags ? TRUE : FALSE))
3408 non_fatal (_("%s: printing debugging information failed"),
3409 bfd_get_filename (abfd));
3413 /* PR 6483: If there was no STABS or IEEE debug
3414 info in the file, try DWARF instead. */
3415 else if (! dump_dwarf_section_info)
3417 dwarf_select_sections_all ();
3446 display_object_bfd (bfd *abfd)
3450 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3456 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3458 nonfatal (bfd_get_filename (abfd));
3459 list_matching_formats (matching);
3464 if (bfd_get_error () != bfd_error_file_not_recognized)
3466 nonfatal (bfd_get_filename (abfd));
3470 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3476 nonfatal (bfd_get_filename (abfd));
3478 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3480 list_matching_formats (matching);
3486 display_any_bfd (bfd *file, int level)
3488 /* Decompress sections unless dumping the section contents. */
3489 if (!dump_section_contents)
3490 file->flags |= BFD_DECOMPRESS;
3492 /* If the file is an archive, process all of its elements. */
3493 if (bfd_check_format (file, bfd_archive))
3496 bfd *last_arfile = NULL;
3499 printf (_("In archive %s:\n"), bfd_get_filename (file));
3500 else if (level > 100)
3502 /* Prevent corrupted files from spinning us into an
3503 infinite loop. 100 is an arbitrary heuristic. */
3504 fatal (_("Archive nesting is too deep"));
3508 printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3512 bfd_set_error (bfd_error_no_error);
3514 arfile = bfd_openr_next_archived_file (file, arfile);
3517 if (bfd_get_error () != bfd_error_no_more_archived_files)
3518 nonfatal (bfd_get_filename (file));
3522 display_any_bfd (arfile, level + 1);
3524 if (last_arfile != NULL)
3526 bfd_close (last_arfile);
3527 /* PR 17512: file: ac585d01. */
3528 if (arfile == last_arfile)
3534 last_arfile = arfile;
3537 if (last_arfile != NULL)
3538 bfd_close (last_arfile);
3541 display_object_bfd (file);
3545 display_file (char *filename, char *target)
3549 if (get_file_size (filename) < 1)
3555 file = bfd_openr (filename, target);
3558 nonfatal (filename);
3562 display_any_bfd (file, 0);
3568 main (int argc, char **argv)
3571 char *target = default_target;
3572 bfd_boolean seenflag = FALSE;
3574 #if defined (HAVE_SETLOCALE)
3575 #if defined (HAVE_LC_MESSAGES)
3576 setlocale (LC_MESSAGES, "");
3578 setlocale (LC_CTYPE, "");
3581 bindtextdomain (PACKAGE, LOCALEDIR);
3582 textdomain (PACKAGE);
3584 program_name = *argv;
3585 xmalloc_set_program_name (program_name);
3586 bfd_set_error_program_name (program_name);
3588 START_PROGRESS (program_name, 0);
3590 expandargv (&argc, &argv);
3593 set_default_bfd_target ();
3595 while ((c = getopt_long (argc, argv,
3596 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3597 long_options, (int *) 0))
3603 break; /* We've been given a long option. */
3608 if (disassembler_options)
3609 /* Ignore potential memory leak for now. */
3610 disassembler_options = concat (disassembler_options, ",",
3611 optarg, (const char *) NULL);
3613 disassembler_options = optarg;
3619 display_file_offsets = TRUE;
3622 with_line_numbers = TRUE;
3631 enum demangling_styles style;
3633 style = cplus_demangle_name_to_style (optarg);
3634 if (style == unknown_demangling)
3635 fatal (_("unknown demangling style `%s'"),
3638 cplus_demangle_set_style (style);
3644 case OPTION_ADJUST_VMA:
3645 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3647 case OPTION_START_ADDRESS:
3648 start_address = parse_vma (optarg, "--start-address");
3649 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3650 fatal (_("error: the start address should be before the end address"));
3652 case OPTION_STOP_ADDRESS:
3653 stop_address = parse_vma (optarg, "--stop-address");
3654 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3655 fatal (_("error: the stop address should be after the start address"));
3659 prefix_length = strlen (prefix);
3660 /* Remove an unnecessary trailing '/' */
3661 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3664 case OPTION_PREFIX_STRIP:
3665 prefix_strip = atoi (optarg);
3666 if (prefix_strip < 0)
3667 fatal (_("error: prefix strip must be non-negative"));
3669 case OPTION_INSN_WIDTH:
3670 insn_width = strtoul (optarg, NULL, 0);
3671 if (insn_width <= 0)
3672 fatal (_("error: instruction width must be positive"));
3675 if (strcmp (optarg, "B") == 0)
3676 endian = BFD_ENDIAN_BIG;
3677 else if (strcmp (optarg, "L") == 0)
3678 endian = BFD_ENDIAN_LITTLE;
3681 nonfatal (_("unrecognized -E option"));
3686 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3687 endian = BFD_ENDIAN_BIG;
3688 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3689 endian = BFD_ENDIAN_LITTLE;
3692 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3699 dump_file_header = TRUE;
3703 formats_info = TRUE;
3707 add_include_path (optarg);
3710 dump_private_headers = TRUE;
3714 dump_private_options = optarg;
3718 dump_private_headers = TRUE;
3720 dump_reloc_info = TRUE;
3721 dump_file_header = TRUE;
3722 dump_ar_hdrs = TRUE;
3723 dump_section_headers = TRUE;
3731 dump_dynamic_symtab = TRUE;
3739 disassemble_zeroes = TRUE;
3743 disassemble_all = TRUE;
3748 with_source_code = TRUE;
3757 dump_debugging_tags = 1;
3762 dump_dwarf_section_info = TRUE;
3765 dwarf_select_sections_by_letters (optarg);
3767 dwarf_select_sections_all ();
3770 dump_dwarf_section_info = TRUE;
3773 dwarf_select_sections_by_names (optarg);
3775 dwarf_select_sections_all ();
3777 case OPTION_DWARF_DEPTH:
3780 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3783 case OPTION_DWARF_START:
3786 dwarf_start_die = strtoul (optarg, & cp, 0);
3787 suppress_bfd_header = 1;
3790 case OPTION_DWARF_CHECK:
3794 dump_stab_section_info = TRUE;
3798 dump_section_contents = TRUE;
3802 dump_reloc_info = TRUE;
3806 dump_dynamic_reloc_info = TRUE;
3810 dump_ar_hdrs = TRUE;
3814 dump_section_headers = TRUE;
3819 show_version = TRUE;
3825 /* No need to set seenflag or to break - usage() does not return. */
3832 print_version ("objdump");
3838 exit_status = display_info ();
3842 display_file ("a.out", target);
3844 for (; optind < argc;)
3845 display_file (argv[optind++], target);
3850 END_PROGRESS (program_name);