1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status = 0;
81 static char *default_target = NULL; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version = 0; /* Show the version number. */
86 static int dump_section_contents; /* -s */
87 static int dump_section_headers; /* -h */
88 static bfd_boolean dump_file_header; /* -f */
89 static int dump_symtab; /* -t */
90 static int dump_dynamic_symtab; /* -T */
91 static int dump_reloc_info; /* -r */
92 static int dump_dynamic_reloc_info; /* -R */
93 static int dump_ar_hdrs; /* -a */
94 static int dump_private_headers; /* -p */
95 static char *dump_private_options; /* -P */
96 static int prefix_addresses; /* --prefix-addresses */
97 static int with_line_numbers; /* -l */
98 static bfd_boolean with_source_code; /* -S */
99 static int show_raw_insn; /* --show-raw-insn */
100 static int dump_dwarf_section_info; /* --dwarf */
101 static int dump_stab_section_info; /* --stabs */
102 static int do_demangle; /* -C, --demangle */
103 static bfd_boolean disassemble; /* -d */
104 static bfd_boolean disassemble_all; /* -D */
105 static int disassemble_zeroes; /* --disassemble-zeroes */
106 static bfd_boolean formats_info; /* -i */
107 static int wide_output; /* -w */
108 static int insn_width; /* --insn-width */
109 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
110 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
111 static int dump_debugging; /* --debugging */
112 static int dump_debugging_tags; /* --debugging-tags */
113 static int suppress_bfd_header;
114 static int dump_special_syms = 0; /* --special-syms */
115 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
116 static int file_start_context = 0; /* --file-start-context */
117 static bfd_boolean display_file_offsets;/* -F */
118 static const char *prefix; /* --prefix */
119 static int prefix_strip; /* --prefix-strip */
120 static size_t prefix_length;
122 /* A structure to record the sections mentioned in -j switches. */
125 const char * name; /* The name of the section. */
126 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
127 struct only * next; /* Pointer to the next structure in the list. */
129 /* Pointer to an array of 'only' structures.
130 This pointer is NULL if the -j switch has not been used. */
131 static struct only * only_list = NULL;
133 /* Variables for handling include file path table. */
134 static const char **include_paths;
135 static int include_path_count;
137 /* Extra info to pass to the section disassembler and address printing
139 struct objdump_disasm_info
143 bfd_boolean require_sec;
144 arelent ** dynrelbuf;
146 disassembler_ftype disassemble_fn;
150 /* Architecture to disassemble for, or default if NULL. */
151 static char *machine = NULL;
153 /* Target specific options to the disassembler. */
154 static char *disassembler_options = NULL;
156 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
157 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
159 /* The symbol table. */
160 static asymbol **syms;
162 /* Number of symbols in `syms'. */
163 static long symcount = 0;
165 /* The sorted symbol table. */
166 static asymbol **sorted_syms;
168 /* Number of symbols in `sorted_syms'. */
169 static long sorted_symcount = 0;
171 /* The dynamic symbol table. */
172 static asymbol **dynsyms;
174 /* The synthetic symbol table. */
175 static asymbol *synthsyms;
176 static long synthcount = 0;
178 /* Number of symbols in `dynsyms'. */
179 static long dynsymcount = 0;
181 static bfd_byte *stabs;
182 static bfd_size_type stab_size;
185 static bfd_size_type stabstr_size;
187 static bfd_boolean is_relocatable = FALSE;
189 /* Handlers for -P/--private. */
190 static const struct objdump_private_desc * const objdump_private_vectors[] =
192 OBJDUMP_PRIVATE_VECTORS
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\
220 Display DWARF info in the file\n\
221 -t, --syms Display the contents of the symbol table(s)\n\
222 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
223 -r, --reloc Display the relocation entries in the file\n\
224 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
225 @<file> Read options from <file>\n\
226 -v, --version Display this program's version number\n\
227 -i, --info List object formats and architectures supported\n\
228 -H, --help Display this information\n\
232 const struct objdump_private_desc * const *desc;
234 fprintf (stream, _("\n The following switches are optional:\n"));
235 fprintf (stream, _("\
236 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
237 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
238 -j, --section=NAME Only display information for section NAME\n\
239 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
240 -EB --endian=big Assume big endian format when disassembling\n\
241 -EL --endian=little Assume little endian format when disassembling\n\
242 --file-start-context Include context from start of file (with -S)\n\
243 -I, --include=DIR Add DIR to search list for source files\n\
244 -l, --line-numbers Include line numbers and filenames in output\n\
245 -F, --file-offsets Include file offsets when displaying information\n\
246 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
247 The STYLE, if specified, can be `auto', `gnu',\n\
248 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
250 -w, --wide Format output for more than 80 columns\n\
251 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
252 --start-address=ADDR Only process data whose address is >= ADDR\n\
253 --stop-address=ADDR Only process data whose address is <= ADDR\n\
254 --prefix-addresses Print complete address alongside disassembly\n\
255 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
256 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
257 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
258 --special-syms Include special symbols in symbol dumps\n\
259 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
260 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
261 fprintf (stream, _("\
262 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
263 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
265 --dwarf-check Make additional dwarf internal consistency checks.\
267 list_supported_targets (program_name, stream);
268 list_supported_architectures (program_name, stream);
270 disassembler_usage (stream);
272 if (objdump_private_vectors[0] != NULL)
275 _("\nOptions supported for -P/--private switch:\n"));
276 for (desc = objdump_private_vectors; *desc != NULL; desc++)
277 (*desc)->help (stream);
280 if (REPORT_BUGS_TO[0] && status == 0)
281 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
285 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
289 OPTION_START_ADDRESS,
301 static struct option long_options[]=
303 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
304 {"all-headers", no_argument, NULL, 'x'},
305 {"private-headers", no_argument, NULL, 'p'},
306 {"private", required_argument, NULL, 'P'},
307 {"architecture", required_argument, NULL, 'm'},
308 {"archive-headers", no_argument, NULL, 'a'},
309 {"debugging", no_argument, NULL, 'g'},
310 {"debugging-tags", no_argument, NULL, 'e'},
311 {"demangle", optional_argument, NULL, 'C'},
312 {"disassemble", no_argument, NULL, 'd'},
313 {"disassemble-all", no_argument, NULL, 'D'},
314 {"disassembler-options", required_argument, NULL, 'M'},
315 {"disassemble-zeroes", no_argument, NULL, 'z'},
316 {"dynamic-reloc", no_argument, NULL, 'R'},
317 {"dynamic-syms", no_argument, NULL, 'T'},
318 {"endian", required_argument, NULL, OPTION_ENDIAN},
319 {"file-headers", no_argument, NULL, 'f'},
320 {"file-offsets", no_argument, NULL, 'F'},
321 {"file-start-context", no_argument, &file_start_context, 1},
322 {"full-contents", no_argument, NULL, 's'},
323 {"headers", no_argument, NULL, 'h'},
324 {"help", no_argument, NULL, 'H'},
325 {"info", no_argument, NULL, 'i'},
326 {"line-numbers", no_argument, NULL, 'l'},
327 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
328 {"prefix-addresses", no_argument, &prefix_addresses, 1},
329 {"reloc", no_argument, NULL, 'r'},
330 {"section", required_argument, NULL, 'j'},
331 {"section-headers", no_argument, NULL, 'h'},
332 {"show-raw-insn", no_argument, &show_raw_insn, 1},
333 {"source", no_argument, NULL, 'S'},
334 {"special-syms", no_argument, &dump_special_syms, 1},
335 {"include", required_argument, NULL, 'I'},
336 {"dwarf", optional_argument, NULL, OPTION_DWARF},
337 {"stabs", no_argument, NULL, 'G'},
338 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
339 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
340 {"syms", no_argument, NULL, 't'},
341 {"target", required_argument, NULL, 'b'},
342 {"version", no_argument, NULL, 'V'},
343 {"wide", no_argument, NULL, 'w'},
344 {"prefix", required_argument, NULL, OPTION_PREFIX},
345 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
346 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
347 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
348 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
349 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
350 {0, no_argument, 0, 0}
354 nonfatal (const char *msg)
360 /* Returns TRUE if the specified section should be dumped. */
363 process_section_p (asection * section)
367 if (only_list == NULL)
370 for (only = only_list; only; only = only->next)
371 if (strcmp (only->name, section->name) == 0)
380 /* Add an entry to the 'only' list. */
383 add_only (char * name)
387 /* First check to make sure that we do not
388 already have an entry for this name. */
389 for (only = only_list; only; only = only->next)
390 if (strcmp (only->name, name) == 0)
393 only = xmalloc (sizeof * only);
396 only->next = only_list;
400 /* Release the memory used by the 'only' list.
401 PR 11225: Issue a warning message for unseen sections.
402 Only do this if none of the sections were seen. This is mainly to support
403 tools like the GAS testsuite where an object file is dumped with a list of
404 generic section names known to be present in a range of different file
408 free_only_list (void)
410 bfd_boolean at_least_one_seen = FALSE;
414 if (only_list == NULL)
417 for (only = only_list; only; only = only->next)
420 at_least_one_seen = TRUE;
424 for (only = only_list; only; only = next)
426 if (! at_least_one_seen)
428 non_fatal (_("section '%s' mentioned in a -j option, "
429 "but not found in any input file"),
440 dump_section_header (bfd *abfd, asection *section,
441 void *ignored ATTRIBUTE_UNUSED)
444 unsigned int opb = bfd_octets_per_byte (abfd);
446 /* Ignore linker created section. See elfNN_ia64_object_p in
448 if (section->flags & SEC_LINKER_CREATED)
451 /* PR 10413: Skip sections that we are ignoring. */
452 if (! process_section_p (section))
455 printf ("%3d %-13s %08lx ", section->index,
456 bfd_get_section_name (abfd, section),
457 (unsigned long) bfd_section_size (abfd, section) / opb);
458 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
460 bfd_printf_vma (abfd, section->lma);
461 printf (" %08lx 2**%u", (unsigned long) section->filepos,
462 bfd_get_section_alignment (abfd, section));
468 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
470 PF (SEC_HAS_CONTENTS, "CONTENTS");
471 PF (SEC_ALLOC, "ALLOC");
472 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
473 PF (SEC_LOAD, "LOAD");
474 PF (SEC_RELOC, "RELOC");
475 PF (SEC_READONLY, "READONLY");
476 PF (SEC_CODE, "CODE");
477 PF (SEC_DATA, "DATA");
479 PF (SEC_DEBUGGING, "DEBUGGING");
480 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
481 PF (SEC_EXCLUDE, "EXCLUDE");
482 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
483 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
485 PF (SEC_TIC54X_BLOCK, "BLOCK");
486 PF (SEC_TIC54X_CLINK, "CLINK");
488 PF (SEC_SMALL_DATA, "SMALL_DATA");
489 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
490 PF (SEC_COFF_SHARED, "SHARED");
491 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
492 PF (SEC_GROUP, "GROUP");
494 if ((section->flags & SEC_LINK_ONCE) != 0)
497 struct coff_comdat_info *comdat;
499 switch (section->flags & SEC_LINK_DUPLICATES)
503 case SEC_LINK_DUPLICATES_DISCARD:
504 ls = "LINK_ONCE_DISCARD";
506 case SEC_LINK_DUPLICATES_ONE_ONLY:
507 ls = "LINK_ONCE_ONE_ONLY";
509 case SEC_LINK_DUPLICATES_SAME_SIZE:
510 ls = "LINK_ONCE_SAME_SIZE";
512 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
513 ls = "LINK_ONCE_SAME_CONTENTS";
516 printf ("%s%s", comma, ls);
518 comdat = bfd_coff_get_comdat_section (abfd, section);
520 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
530 dump_headers (bfd *abfd)
532 printf (_("Sections:\n"));
535 printf (_("Idx Name Size VMA LMA File off Algn"));
537 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
538 if (bfd_get_arch_size (abfd) == 32)
539 printf (_("Idx Name Size VMA LMA File off Algn"));
541 printf (_("Idx Name Size VMA LMA File off Algn"));
545 printf (_(" Flags"));
548 bfd_map_over_sections (abfd, dump_section_header, NULL);
552 slurp_symtab (bfd *abfd)
557 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
563 storage = bfd_get_symtab_upper_bound (abfd);
565 bfd_fatal (bfd_get_filename (abfd));
567 sy = (asymbol **) xmalloc (storage);
569 symcount = bfd_canonicalize_symtab (abfd, sy);
571 bfd_fatal (bfd_get_filename (abfd));
575 /* Read in the dynamic symbols. */
578 slurp_dynamic_symtab (bfd *abfd)
583 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
586 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
588 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
594 bfd_fatal (bfd_get_filename (abfd));
597 sy = (asymbol **) xmalloc (storage);
599 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
601 bfd_fatal (bfd_get_filename (abfd));
605 /* Filter out (in place) symbols that are useless for disassembly.
606 COUNT is the number of elements in SYMBOLS.
607 Return the number of useful symbols. */
610 remove_useless_symbols (asymbol **symbols, long count)
612 asymbol **in_ptr = symbols, **out_ptr = symbols;
616 asymbol *sym = *in_ptr++;
618 if (sym->name == NULL || sym->name[0] == '\0')
620 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
622 if (bfd_is_und_section (sym->section)
623 || bfd_is_com_section (sym->section))
628 return out_ptr - symbols;
631 /* Sort symbols into value order. */
634 compare_symbols (const void *ap, const void *bp)
636 const asymbol *a = * (const asymbol **) ap;
637 const asymbol *b = * (const asymbol **) bp;
647 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
649 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
652 if (a->section > b->section)
654 else if (a->section < b->section)
657 an = bfd_asymbol_name (a);
658 bn = bfd_asymbol_name (b);
662 /* The symbols gnu_compiled and gcc2_compiled convey no real
663 information, so put them after other symbols with the same value. */
664 af = (strstr (an, "gnu_compiled") != NULL
665 || strstr (an, "gcc2_compiled") != NULL);
666 bf = (strstr (bn, "gnu_compiled") != NULL
667 || strstr (bn, "gcc2_compiled") != NULL);
674 /* We use a heuristic for the file name, to try to sort it after
675 more useful symbols. It may not work on non Unix systems, but it
676 doesn't really matter; the only difference is precisely which
677 symbol names get printed. */
679 #define file_symbol(s, sn, snl) \
680 (((s)->flags & BSF_FILE) != 0 \
681 || ((sn)[(snl) - 2] == '.' \
682 && ((sn)[(snl) - 1] == 'o' \
683 || (sn)[(snl) - 1] == 'a')))
685 af = file_symbol (a, an, anl);
686 bf = file_symbol (b, bn, bnl);
693 /* Try to sort global symbols before local symbols before function
694 symbols before debugging symbols. */
699 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
701 if ((aflags & BSF_DEBUGGING) != 0)
706 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
708 if ((aflags & BSF_FUNCTION) != 0)
713 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
715 if ((aflags & BSF_LOCAL) != 0)
720 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
722 if ((aflags & BSF_GLOBAL) != 0)
728 /* Symbols that start with '.' might be section names, so sort them
729 after symbols that don't start with '.'. */
730 if (an[0] == '.' && bn[0] != '.')
732 if (an[0] != '.' && bn[0] == '.')
735 /* Finally, if we can't distinguish them in any other way, try to
736 get consistent results by sorting the symbols by name. */
737 return strcmp (an, bn);
740 /* Sort relocs into address order. */
743 compare_relocs (const void *ap, const void *bp)
745 const arelent *a = * (const arelent **) ap;
746 const arelent *b = * (const arelent **) bp;
748 if (a->address > b->address)
750 else if (a->address < b->address)
753 /* So that associated relocations tied to the same address show up
754 in the correct order, we don't do any further sorting. */
763 /* Print an address (VMA) to the output stream in INFO.
764 If SKIP_ZEROES is TRUE, omit leading zeroes. */
767 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
768 bfd_boolean skip_zeroes)
772 struct objdump_disasm_info *aux;
774 aux = (struct objdump_disasm_info *) inf->application_data;
775 bfd_sprintf_vma (aux->abfd, buf, vma);
780 for (p = buf; *p == '0'; ++p)
785 (*inf->fprintf_func) (inf->stream, "%s", p);
788 /* Print the name of a symbol. */
791 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
798 name = bfd_asymbol_name (sym);
799 if (do_demangle && name[0] != '\0')
801 /* Demangle the name. */
802 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
808 (*inf->fprintf_func) (inf->stream, "%s", name);
816 /* Locate a symbol given a bfd and a section (from INFO->application_data),
817 and a VMA. If INFO->application_data->require_sec is TRUE, then always
818 require the symbol to be in the section. Returns NULL if there is no
819 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
820 of the symbol in sorted_syms. */
823 find_symbol_for_address (bfd_vma vma,
824 struct disassemble_info *inf,
827 /* @@ Would it speed things up to cache the last two symbols returned,
828 and maybe their address ranges? For many processors, only one memory
829 operand can be present at a time, so the 2-entry cache wouldn't be
830 constantly churned by code doing heavy memory accesses. */
832 /* Indices in `sorted_syms'. */
834 long max_count = sorted_symcount;
836 struct objdump_disasm_info *aux;
840 bfd_boolean want_section;
842 if (sorted_symcount < 1)
845 aux = (struct objdump_disasm_info *) inf->application_data;
848 opb = inf->octets_per_byte;
850 /* Perform a binary search looking for the closest symbol to the
851 required value. We are searching the range (min, max_count]. */
852 while (min + 1 < max_count)
856 thisplace = (max_count + min) / 2;
857 sym = sorted_syms[thisplace];
859 if (bfd_asymbol_value (sym) > vma)
860 max_count = thisplace;
861 else if (bfd_asymbol_value (sym) < vma)
870 /* The symbol we want is now in min, the low end of the range we
871 were searching. If there are several symbols with the same
872 value, we want the first one. */
875 && (bfd_asymbol_value (sorted_syms[thisplace])
876 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
879 /* Prefer a symbol in the current section if we have multple symbols
880 with the same value, as can occur with overlays or zero size
883 while (min < max_count
884 && (bfd_asymbol_value (sorted_syms[min])
885 == bfd_asymbol_value (sorted_syms[thisplace])))
887 if (sorted_syms[min]->section == sec
888 && inf->symbol_is_valid (sorted_syms[min], inf))
895 return sorted_syms[thisplace];
900 /* If the file is relocatable, and the symbol could be from this
901 section, prefer a symbol from this section over symbols from
902 others, even if the other symbol's value might be closer.
904 Note that this may be wrong for some symbol references if the
905 sections have overlapping memory ranges, but in that case there's
906 no way to tell what's desired without looking at the relocation
909 Also give the target a chance to reject symbols. */
910 want_section = (aux->require_sec
911 || ((abfd->flags & HAS_RELOC) != 0
912 && vma >= bfd_get_section_vma (abfd, sec)
913 && vma < (bfd_get_section_vma (abfd, sec)
914 + bfd_section_size (abfd, sec) / opb)));
915 if ((sorted_syms[thisplace]->section != sec && want_section)
916 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
919 long newplace = sorted_symcount;
921 for (i = min - 1; i >= 0; i--)
923 if ((sorted_syms[i]->section == sec || !want_section)
924 && inf->symbol_is_valid (sorted_syms[i], inf))
926 if (newplace == sorted_symcount)
929 if (bfd_asymbol_value (sorted_syms[i])
930 != bfd_asymbol_value (sorted_syms[newplace]))
933 /* Remember this symbol and keep searching until we reach
934 an earlier address. */
939 if (newplace != sorted_symcount)
940 thisplace = newplace;
943 /* We didn't find a good symbol with a smaller value.
944 Look for one with a larger value. */
945 for (i = thisplace + 1; i < sorted_symcount; i++)
947 if ((sorted_syms[i]->section == sec || !want_section)
948 && inf->symbol_is_valid (sorted_syms[i], inf))
956 if ((sorted_syms[thisplace]->section != sec && want_section)
957 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
958 /* There is no suitable symbol. */
965 return sorted_syms[thisplace];
968 /* Print an address and the offset to the nearest symbol. */
971 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
972 bfd_vma vma, struct disassemble_info *inf,
973 bfd_boolean skip_zeroes)
975 objdump_print_value (vma, inf, skip_zeroes);
981 (*inf->fprintf_func) (inf->stream, " <%s",
982 bfd_get_section_name (abfd, sec));
983 secaddr = bfd_get_section_vma (abfd, sec);
986 (*inf->fprintf_func) (inf->stream, "-0x");
987 objdump_print_value (secaddr - vma, inf, TRUE);
989 else if (vma > secaddr)
991 (*inf->fprintf_func) (inf->stream, "+0x");
992 objdump_print_value (vma - secaddr, inf, TRUE);
994 (*inf->fprintf_func) (inf->stream, ">");
998 (*inf->fprintf_func) (inf->stream, " <");
999 objdump_print_symname (abfd, inf, sym);
1000 if (bfd_asymbol_value (sym) > vma)
1002 (*inf->fprintf_func) (inf->stream, "-0x");
1003 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1005 else if (vma > bfd_asymbol_value (sym))
1007 (*inf->fprintf_func) (inf->stream, "+0x");
1008 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1010 (*inf->fprintf_func) (inf->stream, ">");
1013 if (display_file_offsets)
1014 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1015 (long int)(sec->filepos + (vma - sec->vma)));
1018 /* Print an address (VMA), symbolically if possible.
1019 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1022 objdump_print_addr (bfd_vma vma,
1023 struct disassemble_info *inf,
1024 bfd_boolean skip_zeroes)
1026 struct objdump_disasm_info *aux;
1027 asymbol *sym = NULL;
1028 bfd_boolean skip_find = FALSE;
1030 aux = (struct objdump_disasm_info *) inf->application_data;
1032 if (sorted_symcount < 1)
1034 (*inf->fprintf_func) (inf->stream, "0x");
1035 objdump_print_value (vma, inf, skip_zeroes);
1037 if (display_file_offsets)
1038 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1039 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1043 if (aux->reloc != NULL
1044 && aux->reloc->sym_ptr_ptr != NULL
1045 && * aux->reloc->sym_ptr_ptr != NULL)
1047 sym = * aux->reloc->sym_ptr_ptr;
1049 /* Adjust the vma to the reloc. */
1050 vma += bfd_asymbol_value (sym);
1052 if (bfd_is_und_section (bfd_get_section (sym)))
1057 sym = find_symbol_for_address (vma, inf, NULL);
1059 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1063 /* Print VMA to INFO. This function is passed to the disassembler
1067 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1069 objdump_print_addr (vma, inf, ! prefix_addresses);
1072 /* Determine if the given address has a symbol associated with it. */
1075 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1079 sym = find_symbol_for_address (vma, inf, NULL);
1081 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1084 /* Hold the last function name and the last line number we displayed
1085 in a disassembly. */
1087 static char *prev_functionname;
1088 static unsigned int prev_line;
1090 /* We keep a list of all files that we have seen when doing a
1091 disassembly with source, so that we know how much of the file to
1092 display. This can be important for inlined functions. */
1094 struct print_file_list
1096 struct print_file_list *next;
1097 const char *filename;
1098 const char *modname;
1101 const char **linemap;
1107 static struct print_file_list *print_files;
1109 /* The number of preceding context lines to show when we start
1110 displaying a file for the first time. */
1112 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1114 /* Read a complete file into memory. */
1117 slurp_file (const char *fn, size_t *size)
1120 int ps = getpagesize ();
1125 int fd = open (fn, O_RDONLY | O_BINARY);
1129 if (fstat (fd, &st) < 0)
1136 msize = (*size + ps - 1) & ~(ps - 1);
1137 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1138 if (map != (char *) -1L)
1144 map = (const char *) malloc (*size);
1145 if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1147 free ((void *) map);
1154 #define line_map_decrease 5
1156 /* Precompute array of lines for a mapped file. */
1158 static const char **
1159 index_file (const char *map, size_t size, unsigned int *maxline)
1161 const char *p, *lstart, *end;
1162 int chars_per_line = 45; /* First iteration will use 40. */
1163 unsigned int lineno;
1164 const char **linemap = NULL;
1165 unsigned long line_map_size = 0;
1171 for (p = map; p < end; p++)
1175 if (p + 1 < end && p[1] == '\r')
1178 else if (*p == '\r')
1180 if (p + 1 < end && p[1] == '\n')
1186 /* End of line found. */
1188 if (linemap == NULL || line_map_size < lineno + 1)
1190 unsigned long newsize;
1192 chars_per_line -= line_map_decrease;
1193 if (chars_per_line <= 1)
1195 line_map_size = size / chars_per_line + 1;
1196 if (line_map_size < lineno + 1)
1197 line_map_size = lineno + 1;
1198 newsize = line_map_size * sizeof (char *);
1199 linemap = (const char **) xrealloc (linemap, newsize);
1202 linemap[lineno++] = lstart;
1210 /* Tries to open MODNAME, and if successful adds a node to print_files
1211 linked list and returns that node. Returns NULL on failure. */
1213 static struct print_file_list *
1214 try_print_file_open (const char *origname, const char *modname)
1216 struct print_file_list *p;
1218 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1220 p->map = slurp_file (modname, &p->mapsize);
1227 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1229 p->filename = origname;
1230 p->modname = modname;
1231 p->next = print_files;
1237 /* If the the source file, as described in the symtab, is not found
1238 try to locate it in one of the paths specified with -I
1239 If found, add location to print_files linked list. */
1241 static struct print_file_list *
1242 update_source_path (const char *filename)
1244 struct print_file_list *p;
1248 p = try_print_file_open (filename, filename);
1252 if (include_path_count == 0)
1255 /* Get the name of the file. */
1256 fname = lbasename (filename);
1258 /* If file exists under a new path, we need to add it to the list
1259 so that show_line knows about it. */
1260 for (i = 0; i < include_path_count; i++)
1262 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1264 p = try_print_file_open (filename, modname);
1274 /* Print a source file line. */
1277 print_line (struct print_file_list *p, unsigned int linenum)
1283 if (linenum >= p->maxline)
1285 l = p->linemap [linenum];
1286 /* Test fwrite return value to quiet glibc warning. */
1287 len = strcspn (l, "\n\r");
1288 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1292 /* Print a range of source code lines. */
1295 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1299 while (start <= end)
1301 print_line (p, start);
1306 /* Show the line number, or the source line, in a disassembly
1310 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1312 const char *filename;
1313 const char *functionname;
1314 unsigned int linenumber;
1317 if (! with_line_numbers && ! with_source_code)
1320 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1321 &functionname, &linenumber))
1324 if (filename != NULL && *filename == '\0')
1326 if (functionname != NULL && *functionname == '\0')
1327 functionname = NULL;
1330 && IS_ABSOLUTE_PATH (filename)
1334 const char *fname = filename;
1335 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1338 memcpy (path, prefix, prefix_length);
1339 path_up = path + prefix_length;
1341 /* Build relocated filename, stripping off leading directories
1342 from the initial filename if requested. */
1343 if (prefix_strip > 0)
1348 /* Skip selected directory levels. */
1349 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1350 if (IS_DIR_SEPARATOR(*s))
1357 /* Update complete filename. */
1358 strncpy (path_up, fname, PATH_MAX);
1359 path_up[PATH_MAX] = '\0';
1367 if (with_line_numbers)
1369 if (functionname != NULL
1370 && (prev_functionname == NULL
1371 || strcmp (functionname, prev_functionname) != 0))
1372 printf ("%s():\n", functionname);
1373 if (linenumber > 0 && linenumber != prev_line)
1374 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1377 if (with_source_code
1381 struct print_file_list **pp, *p;
1384 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1385 if (filename_cmp ((*pp)->filename, filename) == 0)
1392 filename = xstrdup (filename);
1393 p = update_source_path (filename);
1396 if (p != NULL && linenumber != p->last_line)
1398 if (file_start_context && p->first)
1402 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1403 if (l >= linenumber)
1405 if (p->last_line >= l && p->last_line <= linenumber)
1406 l = p->last_line + 1;
1408 dump_lines (p, l, linenumber);
1409 p->last_line = linenumber;
1414 if (functionname != NULL
1415 && (prev_functionname == NULL
1416 || strcmp (functionname, prev_functionname) != 0))
1418 if (prev_functionname != NULL)
1419 free (prev_functionname);
1420 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1421 strcpy (prev_functionname, functionname);
1424 if (linenumber > 0 && linenumber != prev_line)
1425 prev_line = linenumber;
1428 /* Pseudo FILE object for strings. */
1436 /* sprintf to a "stream". */
1438 static int ATTRIBUTE_PRINTF_2
1439 objdump_sprintf (SFILE *f, const char *format, ...)
1446 size_t space = f->alloc - f->pos;
1448 va_start (args, format);
1449 n = vsnprintf (f->buffer + f->pos, space, format, args);
1455 f->alloc = (f->alloc + n) * 2;
1456 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1463 /* The number of zeroes we want to see before we start skipping them.
1464 The number is arbitrarily chosen. */
1466 #define DEFAULT_SKIP_ZEROES 8
1468 /* The number of zeroes to skip at the end of a section. If the
1469 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1470 SKIP_ZEROES, they will be disassembled. If there are fewer than
1471 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1472 attempt to avoid disassembling zeroes inserted by section
1475 #define DEFAULT_SKIP_ZEROES_AT_END 3
1477 /* Disassemble some data in memory between given values. */
1480 disassemble_bytes (struct disassemble_info * inf,
1481 disassembler_ftype disassemble_fn,
1484 bfd_vma start_offset,
1485 bfd_vma stop_offset,
1488 arelent ** relppend)
1490 struct objdump_disasm_info *aux;
1492 int octets_per_line;
1493 int skip_addr_chars;
1494 bfd_vma addr_offset;
1495 unsigned int opb = inf->octets_per_byte;
1496 unsigned int skip_zeroes = inf->skip_zeroes;
1497 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1501 aux = (struct objdump_disasm_info *) inf->application_data;
1505 sfile.buffer = (char *) xmalloc (sfile.alloc);
1509 octets_per_line = insn_width;
1511 octets_per_line = 4;
1513 octets_per_line = 16;
1515 /* Figure out how many characters to skip at the start of an
1516 address, to make the disassembly look nicer. We discard leading
1517 zeroes in chunks of 4, ensuring that there is always a leading
1519 skip_addr_chars = 0;
1520 if (! prefix_addresses)
1524 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1526 while (buf[skip_addr_chars] == '0')
1529 /* Don't discard zeros on overflow. */
1530 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1531 skip_addr_chars = 0;
1533 if (skip_addr_chars != 0)
1534 skip_addr_chars = (skip_addr_chars - 1) & -4;
1537 inf->insn_info_valid = 0;
1539 addr_offset = start_offset;
1540 while (addr_offset < stop_offset)
1543 bfd_boolean need_nl = FALSE;
1544 int previous_octets;
1546 /* Remember the length of the previous instruction. */
1547 previous_octets = octets;
1550 /* Make sure we don't use relocs from previous instructions. */
1553 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1555 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1558 if (! disassemble_zeroes
1559 && (inf->insn_info_valid == 0
1560 || inf->branch_delay_insns == 0)
1561 && (z - addr_offset * opb >= skip_zeroes
1562 || (z == stop_offset * opb &&
1563 z - addr_offset * opb < skip_zeroes_at_end)))
1565 /* If there are more nonzero octets to follow, we only skip
1566 zeroes in multiples of 4, to try to avoid running over
1567 the start of an instruction which happens to start with
1569 if (z != stop_offset * opb)
1570 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1572 octets = z - addr_offset * opb;
1574 /* If we are going to display more data, and we are displaying
1575 file offsets, then tell the user how many zeroes we skip
1576 and the file offset from where we resume dumping. */
1577 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1578 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1580 (unsigned long) (section->filepos
1581 + (addr_offset + (octets / opb))));
1591 if (with_line_numbers || with_source_code)
1592 show_line (aux->abfd, section, addr_offset);
1594 if (! prefix_addresses)
1598 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1599 for (s = buf + skip_addr_chars; *s == '0'; s++)
1603 printf ("%s:\t", buf + skip_addr_chars);
1607 aux->require_sec = TRUE;
1608 objdump_print_address (section->vma + addr_offset, inf);
1609 aux->require_sec = FALSE;
1616 inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1617 inf->stream = &sfile;
1618 inf->bytes_per_line = 0;
1619 inf->bytes_per_chunk = 0;
1620 inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1622 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1624 if (inf->disassembler_needs_relocs
1625 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1626 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1627 && *relppp < relppend)
1629 bfd_signed_vma distance_to_rel;
1631 distance_to_rel = (**relppp)->address
1632 - (rel_offset + addr_offset);
1634 /* Check to see if the current reloc is associated with
1635 the instruction that we are about to disassemble. */
1636 if (distance_to_rel == 0
1637 /* FIXME: This is wrong. We are trying to catch
1638 relocs that are addressed part way through the
1639 current instruction, as might happen with a packed
1640 VLIW instruction. Unfortunately we do not know the
1641 length of the current instruction since we have not
1642 disassembled it yet. Instead we take a guess based
1643 upon the length of the previous instruction. The
1644 proper solution is to have a new target-specific
1645 disassembler function which just returns the length
1646 of an instruction at a given address without trying
1647 to display its disassembly. */
1648 || (distance_to_rel > 0
1649 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1651 inf->flags |= INSN_HAS_RELOC;
1652 aux->reloc = **relppp;
1656 octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1657 inf->fprintf_func = (fprintf_ftype) fprintf;
1658 inf->stream = stdout;
1659 if (insn_width == 0 && inf->bytes_per_line != 0)
1660 octets_per_line = inf->bytes_per_line;
1661 if (octets < (int) opb)
1664 printf ("%s\n", sfile.buffer);
1667 non_fatal (_("disassemble_fn returned length %d"),
1678 octets = octets_per_line;
1679 if (addr_offset + octets / opb > stop_offset)
1680 octets = (stop_offset - addr_offset) * opb;
1682 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1684 if (ISPRINT (data[j]))
1685 buf[j - addr_offset * opb] = data[j];
1687 buf[j - addr_offset * opb] = '.';
1689 buf[j - addr_offset * opb] = '\0';
1692 if (prefix_addresses
1694 : show_raw_insn >= 0)
1698 /* If ! prefix_addresses and ! wide_output, we print
1699 octets_per_line octets per line. */
1701 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1702 pb = octets_per_line;
1704 if (inf->bytes_per_chunk)
1705 bpc = inf->bytes_per_chunk;
1709 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1713 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1715 for (k = bpc - 1; k >= 0; k--)
1716 printf ("%02x", (unsigned) data[j + k]);
1721 for (k = 0; k < bpc; k++)
1722 printf ("%02x", (unsigned) data[j + k]);
1727 for (; pb < octets_per_line; pb += bpc)
1731 for (k = 0; k < bpc; k++)
1736 /* Separate raw data from instruction by extra space. */
1746 printf ("%s", sfile.buffer);
1748 if (prefix_addresses
1750 : show_raw_insn >= 0)
1758 j = addr_offset * opb + pb;
1760 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1761 for (s = buf + skip_addr_chars; *s == '0'; s++)
1765 printf ("%s:\t", buf + skip_addr_chars);
1767 pb += octets_per_line;
1770 for (; j < addr_offset * opb + pb; j += bpc)
1774 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1776 for (k = bpc - 1; k >= 0; k--)
1777 printf ("%02x", (unsigned) data[j + k]);
1782 for (k = 0; k < bpc; k++)
1783 printf ("%02x", (unsigned) data[j + k]);
1796 while ((*relppp) < relppend
1797 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1799 if (dump_reloc_info || dump_dynamic_reloc_info)
1810 objdump_print_value (section->vma - rel_offset + q->address,
1813 if (q->howto == NULL)
1814 printf (": *unknown*\t");
1815 else if (q->howto->name)
1816 printf (": %s\t", q->howto->name);
1818 printf (": %d\t", q->howto->type);
1820 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1821 printf ("*unknown*");
1824 const char *sym_name;
1826 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1827 if (sym_name != NULL && *sym_name != '\0')
1828 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1833 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1834 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1835 if (sym_name == NULL || *sym_name == '\0')
1836 sym_name = "*unknown*";
1837 printf ("%s", sym_name);
1844 objdump_print_value (q->addend, inf, TRUE);
1856 addr_offset += octets / opb;
1859 free (sfile.buffer);
1863 disassemble_section (bfd *abfd, asection *section, void *inf)
1865 const struct elf_backend_data * bed;
1866 bfd_vma sign_adjust = 0;
1867 struct disassemble_info * pinfo = (struct disassemble_info *) inf;
1868 struct objdump_disasm_info * paux;
1869 unsigned int opb = pinfo->octets_per_byte;
1870 bfd_byte * data = NULL;
1871 bfd_size_type datasize = 0;
1872 arelent ** rel_pp = NULL;
1873 arelent ** rel_ppstart = NULL;
1874 arelent ** rel_ppend;
1875 unsigned long stop_offset;
1876 asymbol * sym = NULL;
1880 unsigned long addr_offset;
1882 /* Sections that do not contain machine
1883 code are not normally disassembled. */
1884 if (! disassemble_all
1885 && only_list == NULL
1886 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1887 != (SEC_CODE | SEC_HAS_CONTENTS)))
1890 if (! process_section_p (section))
1893 datasize = bfd_get_section_size (section);
1897 /* Decide which set of relocs to use. Load them if necessary. */
1898 paux = (struct objdump_disasm_info *) pinfo->application_data;
1899 if (paux->dynrelbuf)
1901 rel_pp = paux->dynrelbuf;
1902 rel_count = paux->dynrelcount;
1903 /* Dynamic reloc addresses are absolute, non-dynamic are section
1904 relative. REL_OFFSET specifies the reloc address corresponding
1905 to the start of this section. */
1906 rel_offset = section->vma;
1914 if ((section->flags & SEC_RELOC) != 0
1915 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1919 relsize = bfd_get_reloc_upper_bound (abfd, section);
1921 bfd_fatal (bfd_get_filename (abfd));
1925 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1926 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1928 bfd_fatal (bfd_get_filename (abfd));
1930 /* Sort the relocs by address. */
1931 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1935 rel_ppend = rel_pp + rel_count;
1937 data = (bfd_byte *) xmalloc (datasize);
1939 bfd_get_section_contents (abfd, section, data, 0, datasize);
1941 paux->sec = section;
1942 pinfo->buffer = data;
1943 pinfo->buffer_vma = section->vma;
1944 pinfo->buffer_length = datasize;
1945 pinfo->section = section;
1947 if (start_address == (bfd_vma) -1
1948 || start_address < pinfo->buffer_vma)
1951 addr_offset = start_address - pinfo->buffer_vma;
1953 if (stop_address == (bfd_vma) -1)
1954 stop_offset = datasize / opb;
1957 if (stop_address < pinfo->buffer_vma)
1960 stop_offset = stop_address - pinfo->buffer_vma;
1961 if (stop_offset > pinfo->buffer_length / opb)
1962 stop_offset = pinfo->buffer_length / opb;
1965 /* Skip over the relocs belonging to addresses below the
1967 while (rel_pp < rel_ppend
1968 && (*rel_pp)->address < rel_offset + addr_offset)
1971 if (addr_offset < stop_offset)
1972 printf (_("\nDisassembly of section %s:\n"), section->name);
1974 /* Find the nearest symbol forwards from our current position. */
1975 paux->require_sec = TRUE;
1976 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
1977 (struct disassemble_info *) inf,
1979 paux->require_sec = FALSE;
1981 /* PR 9774: If the target used signed addresses then we must make
1982 sure that we sign extend the value that we calculate for 'addr'
1983 in the loop below. */
1984 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1985 && (bed = get_elf_backend_data (abfd)) != NULL
1986 && bed->sign_extend_vma)
1987 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1989 /* Disassemble a block of instructions up to the address associated with
1990 the symbol we have just found. Then print the symbol and find the
1991 next symbol on. Repeat until we have disassembled the entire section
1992 or we have reached the end of the address range we are interested in. */
1993 while (addr_offset < stop_offset)
1997 unsigned long nextstop_offset;
2000 addr = section->vma + addr_offset;
2001 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2003 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2008 (x < sorted_symcount
2009 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2013 pinfo->symbols = sorted_syms + place;
2014 pinfo->num_symbols = x - place;
2015 pinfo->symtab_pos = place;
2019 pinfo->symbols = NULL;
2020 pinfo->num_symbols = 0;
2021 pinfo->symtab_pos = -1;
2024 if (! prefix_addresses)
2026 pinfo->fprintf_func (pinfo->stream, "\n");
2027 objdump_print_addr_with_sym (abfd, section, sym, addr,
2029 pinfo->fprintf_func (pinfo->stream, ":\n");
2032 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2034 else if (sym == NULL)
2038 #define is_valid_next_sym(SYM) \
2039 ((SYM)->section == section \
2040 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2041 && pinfo->symbol_is_valid (SYM, pinfo))
2043 /* Search forward for the next appropriate symbol in
2044 SECTION. Note that all the symbols are sorted
2045 together into one big array, and that some sections
2046 may have overlapping addresses. */
2047 while (place < sorted_symcount
2048 && ! is_valid_next_sym (sorted_syms [place]))
2051 if (place >= sorted_symcount)
2054 nextsym = sorted_syms[place];
2057 if (sym != NULL && bfd_asymbol_value (sym) > addr)
2058 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2059 else if (nextsym == NULL)
2060 nextstop_offset = stop_offset;
2062 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2064 if (nextstop_offset > stop_offset
2065 || nextstop_offset <= addr_offset)
2066 nextstop_offset = stop_offset;
2068 /* If a symbol is explicitly marked as being an object
2069 rather than a function, just dump the bytes without
2070 disassembling them. */
2073 || sym->section != section
2074 || bfd_asymbol_value (sym) > addr
2075 || ((sym->flags & BSF_OBJECT) == 0
2076 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2078 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2080 || (sym->flags & BSF_FUNCTION) != 0)
2085 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2086 addr_offset, nextstop_offset,
2087 rel_offset, &rel_pp, rel_ppend);
2089 addr_offset = nextstop_offset;
2095 if (rel_ppstart != NULL)
2099 /* Disassemble the contents of an object file. */
2102 disassemble_data (bfd *abfd)
2104 struct disassemble_info disasm_info;
2105 struct objdump_disasm_info aux;
2109 prev_functionname = NULL;
2112 /* We make a copy of syms to sort. We don't want to sort syms
2113 because that will screw up the relocs. */
2114 sorted_symcount = symcount ? symcount : dynsymcount;
2115 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2116 * sizeof (asymbol *));
2117 memcpy (sorted_syms, symcount ? syms : dynsyms,
2118 sorted_symcount * sizeof (asymbol *));
2120 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2122 for (i = 0; i < synthcount; ++i)
2124 sorted_syms[sorted_symcount] = synthsyms + i;
2128 /* Sort the symbols into section and symbol order. */
2129 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2131 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2133 disasm_info.application_data = (void *) &aux;
2135 aux.require_sec = FALSE;
2136 aux.dynrelbuf = NULL;
2137 aux.dynrelcount = 0;
2140 disasm_info.print_address_func = objdump_print_address;
2141 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2143 if (machine != NULL)
2145 const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2148 fatal (_("can't use supplied machine %s"), machine);
2150 abfd->arch_info = inf;
2153 if (endian != BFD_ENDIAN_UNKNOWN)
2155 struct bfd_target *xvec;
2157 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2158 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2159 xvec->byteorder = endian;
2163 /* Use libopcodes to locate a suitable disassembler. */
2164 aux.disassemble_fn = disassembler (abfd);
2165 if (!aux.disassemble_fn)
2167 non_fatal (_("can't disassemble for architecture %s\n"),
2168 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2173 disasm_info.flavour = bfd_get_flavour (abfd);
2174 disasm_info.arch = bfd_get_arch (abfd);
2175 disasm_info.mach = bfd_get_mach (abfd);
2176 disasm_info.disassembler_options = disassembler_options;
2177 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2178 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2179 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2180 disasm_info.disassembler_needs_relocs = FALSE;
2182 if (bfd_big_endian (abfd))
2183 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2184 else if (bfd_little_endian (abfd))
2185 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2187 /* ??? Aborting here seems too drastic. We could default to big or little
2189 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2191 /* Allow the target to customize the info structure. */
2192 disassemble_init_for_target (& disasm_info);
2194 /* Pre-load the dynamic relocs if we are going
2195 to be dumping them along with the disassembly. */
2196 if (dump_dynamic_reloc_info)
2198 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2201 bfd_fatal (bfd_get_filename (abfd));
2205 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2206 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2209 if (aux.dynrelcount < 0)
2210 bfd_fatal (bfd_get_filename (abfd));
2212 /* Sort the relocs by address. */
2213 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2217 disasm_info.symtab = sorted_syms;
2218 disasm_info.symtab_size = sorted_symcount;
2220 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2222 if (aux.dynrelbuf != NULL)
2223 free (aux.dynrelbuf);
2228 load_specific_debug_section (enum dwarf_section_display_enum debug,
2229 asection *sec, void *file)
2231 struct dwarf_section *section = &debug_displays [debug].section;
2232 bfd *abfd = (bfd *) file;
2235 /* If it is already loaded, do nothing. */
2236 if (section->start != NULL)
2239 section->address = 0;
2240 section->size = bfd_get_section_size (sec);
2241 section->start = NULL;
2242 ret = bfd_get_full_section_contents (abfd, sec, §ion->start);
2246 free_debug_section (debug);
2247 printf (_("\nCan't get contents for section '%s'.\n"),
2252 if (is_relocatable && debug_displays [debug].relocate)
2254 /* We want to relocate the data we've already read (and
2255 decompressed), so we store a pointer to the data in
2256 the bfd_section, and tell it that the contents are
2257 already in memory. */
2258 sec->contents = section->start;
2259 sec->flags |= SEC_IN_MEMORY;
2260 sec->size = section->size;
2262 ret = bfd_simple_get_relocated_section_contents (abfd,
2269 free_debug_section (debug);
2270 printf (_("\nCan't get contents for section '%s'.\n"),
2280 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2282 struct dwarf_section *section = &debug_displays [debug].section;
2283 bfd *abfd = (bfd *) file;
2286 /* If it is already loaded, do nothing. */
2287 if (section->start != NULL)
2290 /* Locate the debug section. */
2291 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2293 section->name = section->uncompressed_name;
2296 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2298 section->name = section->compressed_name;
2303 return load_specific_debug_section (debug, sec, file);
2307 free_debug_section (enum dwarf_section_display_enum debug)
2309 struct dwarf_section *section = &debug_displays [debug].section;
2311 if (section->start == NULL)
2314 free ((char *) section->start);
2315 section->start = NULL;
2316 section->address = 0;
2321 dump_dwarf_section (bfd *abfd, asection *section,
2322 void *arg ATTRIBUTE_UNUSED)
2324 const char *name = bfd_get_section_name (abfd, section);
2328 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2329 match = ".debug_info";
2333 for (i = 0; i < max; i++)
2334 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2335 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2336 && debug_displays [i].enabled != NULL
2337 && *debug_displays [i].enabled)
2339 struct dwarf_section *sec = &debug_displays [i].section;
2341 if (strcmp (sec->uncompressed_name, match) == 0)
2342 sec->name = sec->uncompressed_name;
2344 sec->name = sec->compressed_name;
2345 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2348 debug_displays [i].display (sec, abfd);
2350 if (i != info && i != abbrev)
2351 free_debug_section ((enum dwarf_section_display_enum) i);
2357 /* Dump the dwarf debugging information. */
2360 dump_dwarf (bfd *abfd)
2362 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2364 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2366 if (bfd_big_endian (abfd))
2367 byte_get = byte_get_big_endian;
2368 else if (bfd_little_endian (abfd))
2369 byte_get = byte_get_little_endian;
2373 switch (bfd_get_arch (abfd))
2376 switch (bfd_get_mach (abfd))
2378 case bfd_mach_x86_64:
2379 case bfd_mach_x86_64_intel_syntax:
2380 init_dwarf_regnames_x86_64 ();
2384 init_dwarf_regnames_i386 ();
2393 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2395 free_debug_memory ();
2398 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2399 it. Return NULL on failure. */
2402 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2408 stabsect = bfd_get_section_by_name (abfd, sect_name);
2409 if (stabsect == NULL)
2411 printf (_("No %s section present\n\n"), sect_name);
2415 size = bfd_section_size (abfd, stabsect);
2416 contents = (char *) xmalloc (size);
2418 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2420 non_fatal (_("reading %s section of %s failed: %s"),
2421 sect_name, bfd_get_filename (abfd),
2422 bfd_errmsg (bfd_get_error ()));
2433 /* Stabs entries use a 12 byte format:
2434 4 byte string table index
2436 1 byte stab other field
2437 2 byte stab desc field
2439 FIXME: This will have to change for a 64 bit object format. */
2441 #define STRDXOFF (0)
2443 #define OTHEROFF (5)
2446 #define STABSIZE (12)
2448 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2449 using string table section STRSECT_NAME (in `strtab'). */
2452 print_section_stabs (bfd *abfd,
2453 const char *stabsect_name,
2454 unsigned *string_offset_ptr)
2457 unsigned file_string_table_offset = 0;
2458 unsigned next_file_string_table_offset = *string_offset_ptr;
2459 bfd_byte *stabp, *stabs_end;
2462 stabs_end = stabp + stab_size;
2464 printf (_("Contents of %s section:\n\n"), stabsect_name);
2465 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2467 /* Loop through all symbols and print them.
2469 We start the index at -1 because there is a dummy symbol on
2470 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2471 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2475 unsigned char type, other;
2476 unsigned short desc;
2479 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2480 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2481 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2482 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2483 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2485 printf ("\n%-6d ", i);
2486 /* Either print the stab name, or, if unnamed, print its number
2487 again (makes consistent formatting for tools like awk). */
2488 name = bfd_get_stab_name (type);
2490 printf ("%-6s", name);
2491 else if (type == N_UNDF)
2494 printf ("%-6d", type);
2495 printf (" %-6d %-6d ", other, desc);
2496 bfd_printf_vma (abfd, value);
2497 printf (" %-6lu", strx);
2499 /* Symbols with type == 0 (N_UNDF) specify the length of the
2500 string table associated with this file. We use that info
2501 to know how to relocate the *next* file's string table indices. */
2504 file_string_table_offset = next_file_string_table_offset;
2505 next_file_string_table_offset += value;
2509 /* Using the (possibly updated) string table offset, print the
2510 string (if any) associated with this symbol. */
2511 if ((strx + file_string_table_offset) < stabstr_size)
2512 printf (" %s", &strtab[strx + file_string_table_offset]);
2518 *string_offset_ptr = next_file_string_table_offset;
2523 const char * section_name;
2524 const char * string_section_name;
2525 unsigned string_offset;
2530 find_stabs_section (bfd *abfd, asection *section, void *names)
2533 stab_section_names * sought = (stab_section_names *) names;
2535 /* Check for section names for which stabsect_name is a prefix, to
2536 handle .stab.N, etc. */
2537 len = strlen (sought->section_name);
2539 /* If the prefix matches, and the files section name ends with a
2540 nul or a digit, then we match. I.e., we want either an exact
2541 match or a section followed by a number. */
2542 if (strncmp (sought->section_name, section->name, len) == 0
2543 && (section->name[len] == 0
2544 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2547 strtab = read_section_stabs (abfd, sought->string_section_name,
2552 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2555 print_section_stabs (abfd, section->name, &sought->string_offset);
2561 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2563 stab_section_names s;
2565 s.section_name = stabsect_name;
2566 s.string_section_name = strsect_name;
2567 s.string_offset = 0;
2569 bfd_map_over_sections (abfd, find_stabs_section, & s);
2575 /* Dump the any sections containing stabs debugging information. */
2578 dump_stabs (bfd *abfd)
2580 dump_stabs_section (abfd, ".stab", ".stabstr");
2581 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2582 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2585 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2587 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2591 dump_bfd_header (bfd *abfd)
2595 printf (_("architecture: %s, "),
2596 bfd_printable_arch_mach (bfd_get_arch (abfd),
2597 bfd_get_mach (abfd)));
2598 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2600 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2601 PF (HAS_RELOC, "HAS_RELOC");
2602 PF (EXEC_P, "EXEC_P");
2603 PF (HAS_LINENO, "HAS_LINENO");
2604 PF (HAS_DEBUG, "HAS_DEBUG");
2605 PF (HAS_SYMS, "HAS_SYMS");
2606 PF (HAS_LOCALS, "HAS_LOCALS");
2607 PF (DYNAMIC, "DYNAMIC");
2608 PF (WP_TEXT, "WP_TEXT");
2609 PF (D_PAGED, "D_PAGED");
2610 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2611 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2612 printf (_("\nstart address 0x"));
2613 bfd_printf_vma (abfd, abfd->start_address);
2619 dump_bfd_private_header (bfd *abfd)
2621 bfd_print_private_bfd_data (abfd, stdout);
2625 dump_target_specific (bfd *abfd)
2627 const struct objdump_private_desc * const *desc;
2628 struct objdump_private_option *opt;
2631 /* Find the desc. */
2632 for (desc = objdump_private_vectors; *desc != NULL; desc++)
2633 if ((*desc)->filter (abfd))
2638 non_fatal (_("option -P/--private not supported by this file"));
2642 /* Clear all options. */
2643 for (opt = (*desc)->options; opt->name; opt++)
2644 opt->selected = FALSE;
2646 /* Decode options. */
2647 b = dump_private_options;
2650 e = strchr (b, ',');
2655 for (opt = (*desc)->options; opt->name; opt++)
2656 if (strcmp (opt->name, b) == 0)
2658 opt->selected = TRUE;
2661 if (opt->name == NULL)
2662 non_fatal (_("target specific dump '%s' not supported"), b);
2673 (*desc)->dump (abfd);
2676 /* Display a section in hexadecimal format with associated characters.
2677 Each line prefixed by the zero padded address. */
2680 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2683 bfd_size_type datasize;
2684 bfd_size_type addr_offset;
2685 bfd_size_type start_offset;
2686 bfd_size_type stop_offset;
2687 unsigned int opb = bfd_octets_per_byte (abfd);
2688 /* Bytes per line. */
2689 const int onaline = 16;
2694 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2697 if (! process_section_p (section))
2700 if ((datasize = bfd_section_size (abfd, section)) == 0)
2703 /* Compute the address range to display. */
2704 if (start_address == (bfd_vma) -1
2705 || start_address < section->vma)
2708 start_offset = start_address - section->vma;
2710 if (stop_address == (bfd_vma) -1)
2711 stop_offset = datasize / opb;
2714 if (stop_address < section->vma)
2717 stop_offset = stop_address - section->vma;
2719 if (stop_offset > datasize / opb)
2720 stop_offset = datasize / opb;
2723 if (start_offset >= stop_offset)
2726 printf (_("Contents of section %s:"), section->name);
2727 if (display_file_offsets)
2728 printf (_(" (Starting at file offset: 0x%lx)"),
2729 (unsigned long) (section->filepos + start_offset));
2732 if (!bfd_get_full_section_contents (abfd, section, &data))
2734 non_fatal (_("Reading section failed"));
2740 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2741 if (strlen (buf) >= sizeof (buf))
2745 while (buf[count] == '0' && buf[count+1] != '\0')
2747 count = strlen (buf) - count;
2751 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2752 if (strlen (buf) >= sizeof (buf))
2756 while (buf[count] == '0' && buf[count+1] != '\0')
2758 count = strlen (buf) - count;
2762 for (addr_offset = start_offset;
2763 addr_offset < stop_offset; addr_offset += onaline / opb)
2767 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2768 count = strlen (buf);
2769 if ((size_t) count >= sizeof (buf))
2773 while (count < width)
2778 fputs (buf + count - width, stdout);
2781 for (j = addr_offset * opb;
2782 j < addr_offset * opb + onaline; j++)
2784 if (j < stop_offset * opb)
2785 printf ("%02x", (unsigned) (data[j]));
2793 for (j = addr_offset * opb;
2794 j < addr_offset * opb + onaline; j++)
2796 if (j >= stop_offset * opb)
2799 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2806 /* Actually display the various requested regions. */
2809 dump_data (bfd *abfd)
2811 bfd_map_over_sections (abfd, dump_section, NULL);
2814 /* Should perhaps share code and display with nm? */
2817 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2826 max_count = dynsymcount;
2827 printf ("DYNAMIC SYMBOL TABLE:\n");
2832 max_count = symcount;
2833 printf ("SYMBOL TABLE:\n");
2837 printf (_("no symbols\n"));
2839 for (count = 0; count < max_count; count++)
2843 if (*current == NULL)
2844 printf (_("no information for symbol number %ld\n"), count);
2846 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2847 printf (_("could not determine the type of symbol number %ld\n"),
2850 else if (process_section_p ((* current)->section)
2851 && (dump_special_syms
2852 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2854 const char *name = (*current)->name;
2856 if (do_demangle && name != NULL && *name != '\0')
2860 /* If we want to demangle the name, we demangle it
2861 here, and temporarily clobber it while calling
2862 bfd_print_symbol. FIXME: This is a gross hack. */
2863 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2865 (*current)->name = alloc;
2866 bfd_print_symbol (cur_bfd, stdout, *current,
2867 bfd_print_symbol_all);
2870 (*current)->name = name;
2875 bfd_print_symbol (cur_bfd, stdout, *current,
2876 bfd_print_symbol_all);
2886 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2889 char *last_filename, *last_functionname;
2890 unsigned int last_line;
2892 /* Get column headers lined up reasonably. */
2900 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2901 width = strlen (buf) - 7;
2903 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2906 last_filename = NULL;
2907 last_functionname = NULL;
2910 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2913 const char *filename, *functionname;
2914 unsigned int linenumber;
2915 const char *sym_name;
2916 const char *section_name;
2917 bfd_vma addend2 = 0;
2919 if (start_address != (bfd_vma) -1
2920 && q->address < start_address)
2922 if (stop_address != (bfd_vma) -1
2923 && q->address > stop_address)
2926 if (with_line_numbers
2928 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2929 &filename, &functionname, &linenumber))
2931 if (functionname != NULL
2932 && (last_functionname == NULL
2933 || strcmp (functionname, last_functionname) != 0))
2935 printf ("%s():\n", functionname);
2936 if (last_functionname != NULL)
2937 free (last_functionname);
2938 last_functionname = xstrdup (functionname);
2942 && (linenumber != last_line
2943 || (filename != NULL
2944 && last_filename != NULL
2945 && filename_cmp (filename, last_filename) != 0)))
2947 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2948 last_line = linenumber;
2949 if (last_filename != NULL)
2950 free (last_filename);
2951 if (filename == NULL)
2952 last_filename = NULL;
2954 last_filename = xstrdup (filename);
2958 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2960 sym_name = (*(q->sym_ptr_ptr))->name;
2961 section_name = (*(q->sym_ptr_ptr))->section->name;
2966 section_name = NULL;
2969 bfd_printf_vma (abfd, q->address);
2970 if (q->howto == NULL)
2971 printf (" *unknown* ");
2972 else if (q->howto->name)
2974 const char *name = q->howto->name;
2976 /* R_SPARC_OLO10 relocations contain two addends.
2977 But because 'arelent' lacks enough storage to
2978 store them both, the 64-bit ELF Sparc backend
2979 records this as two relocations. One R_SPARC_LO10
2980 and one R_SPARC_13, both pointing to the same
2981 address. This is merely so that we have some
2982 place to store both addend fields.
2984 Undo this transformation, otherwise the output
2985 will be confusing. */
2986 if (abfd->xvec->flavour == bfd_target_elf_flavour
2987 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
2989 && !strcmp (q->howto->name, "R_SPARC_LO10"))
2991 arelent *q2 = *(p + 1);
2994 && q->address == q2->address
2995 && !strcmp (q2->howto->name, "R_SPARC_13"))
2997 name = "R_SPARC_OLO10";
2998 addend2 = q2->addend;
3002 printf (" %-16s ", name);
3005 printf (" %-16d ", q->howto->type);
3009 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3013 if (section_name == NULL)
3014 section_name = "*unknown*";
3015 printf ("[%s]", section_name);
3021 bfd_printf_vma (abfd, q->addend);
3026 bfd_printf_vma (abfd, addend2);
3032 if (last_filename != NULL)
3033 free (last_filename);
3034 if (last_functionname != NULL)
3035 free (last_functionname);
3039 dump_relocs_in_section (bfd *abfd,
3041 void *dummy ATTRIBUTE_UNUSED)
3047 if ( bfd_is_abs_section (section)
3048 || bfd_is_und_section (section)
3049 || bfd_is_com_section (section)
3050 || (! process_section_p (section))
3051 || ((section->flags & SEC_RELOC) == 0))
3054 relsize = bfd_get_reloc_upper_bound (abfd, section);
3056 bfd_fatal (bfd_get_filename (abfd));
3058 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3062 printf (" (none)\n\n");
3066 relpp = (arelent **) xmalloc (relsize);
3067 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3070 bfd_fatal (bfd_get_filename (abfd));
3071 else if (relcount == 0)
3072 printf (" (none)\n\n");
3076 dump_reloc_set (abfd, section, relpp, relcount);
3083 dump_relocs (bfd *abfd)
3085 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3089 dump_dynamic_relocs (bfd *abfd)
3095 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3097 bfd_fatal (bfd_get_filename (abfd));
3099 printf ("DYNAMIC RELOCATION RECORDS");
3102 printf (" (none)\n\n");
3105 relpp = (arelent **) xmalloc (relsize);
3106 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3109 bfd_fatal (bfd_get_filename (abfd));
3110 else if (relcount == 0)
3111 printf (" (none)\n\n");
3115 dump_reloc_set (abfd, NULL, relpp, relcount);
3122 /* Creates a table of paths, to search for source files. */
3125 add_include_path (const char *path)
3129 include_path_count++;
3130 include_paths = (const char **)
3131 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3132 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3133 if (path[1] == ':' && path[2] == 0)
3134 path = concat (path, ".", (const char *) 0);
3136 include_paths[include_path_count - 1] = path;
3140 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3144 if ((section->flags & SEC_DEBUGGING) == 0)
3146 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3147 section->vma += adjust_section_vma;
3149 section->lma += adjust_section_vma;
3153 /* Dump selected contents of ABFD. */
3156 dump_bfd (bfd *abfd)
3158 /* If we are adjusting section VMA's, change them all now. Changing
3159 the BFD information is a hack. However, we must do it, or
3160 bfd_find_nearest_line will not do the right thing. */
3161 if (adjust_section_vma != 0)
3163 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3164 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3167 if (! dump_debugging_tags && ! suppress_bfd_header)
3168 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
3171 print_arelt_descr (stdout, abfd, TRUE);
3172 if (dump_file_header)
3173 dump_bfd_header (abfd);
3174 if (dump_private_headers)
3175 dump_bfd_private_header (abfd);
3176 if (dump_private_options != NULL)
3177 dump_target_specific (abfd);
3178 if (! dump_debugging_tags && ! suppress_bfd_header)
3180 if (dump_section_headers)
3181 dump_headers (abfd);
3187 || dump_dwarf_section_info)
3188 syms = slurp_symtab (abfd);
3189 if (dump_dynamic_symtab || dump_dynamic_reloc_info
3190 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3191 dynsyms = slurp_dynamic_symtab (abfd);
3194 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3195 dynsymcount, dynsyms, &synthsyms);
3201 dump_symbols (abfd, FALSE);
3202 if (dump_dynamic_symtab)
3203 dump_symbols (abfd, TRUE);
3204 if (dump_dwarf_section_info)
3206 if (dump_stab_section_info)
3208 if (dump_reloc_info && ! disassemble)
3210 if (dump_dynamic_reloc_info && ! disassemble)
3211 dump_dynamic_relocs (abfd);
3212 if (dump_section_contents)
3215 disassemble_data (abfd);
3221 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3222 if (dhandle != NULL)
3224 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3226 dump_debugging_tags ? TRUE : FALSE))
3228 non_fatal (_("%s: printing debugging information failed"),
3229 bfd_get_filename (abfd));
3233 /* PR 6483: If there was no STABS or IEEE debug
3234 info in the file, try DWARF instead. */
3235 else if (! dump_dwarf_section_info)
3237 dwarf_select_sections_all ();
3266 display_object_bfd (bfd *abfd)
3270 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3276 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3278 nonfatal (bfd_get_filename (abfd));
3279 list_matching_formats (matching);
3284 if (bfd_get_error () != bfd_error_file_not_recognized)
3286 nonfatal (bfd_get_filename (abfd));
3290 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3296 nonfatal (bfd_get_filename (abfd));
3298 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3300 list_matching_formats (matching);
3306 display_any_bfd (bfd *file, int level)
3308 /* Decompress sections unless dumping the section contents. */
3309 if (!dump_section_contents)
3310 file->flags |= BFD_DECOMPRESS;
3312 /* If the file is an archive, process all of its elements. */
3313 if (bfd_check_format (file, bfd_archive))
3316 bfd *last_arfile = NULL;
3319 printf (_("In archive %s:\n"), bfd_get_filename (file));
3321 printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3325 bfd_set_error (bfd_error_no_error);
3327 arfile = bfd_openr_next_archived_file (file, arfile);
3330 if (bfd_get_error () != bfd_error_no_more_archived_files)
3331 nonfatal (bfd_get_filename (file));
3335 display_any_bfd (arfile, level + 1);
3337 if (last_arfile != NULL)
3338 bfd_close (last_arfile);
3339 last_arfile = arfile;
3342 if (last_arfile != NULL)
3343 bfd_close (last_arfile);
3346 display_object_bfd (file);
3350 display_file (char *filename, char *target)
3354 if (get_file_size (filename) < 1)
3360 file = bfd_openr (filename, target);
3363 nonfatal (filename);
3367 display_any_bfd (file, 0);
3373 main (int argc, char **argv)
3376 char *target = default_target;
3377 bfd_boolean seenflag = FALSE;
3379 #if defined (HAVE_SETLOCALE)
3380 #if defined (HAVE_LC_MESSAGES)
3381 setlocale (LC_MESSAGES, "");
3383 setlocale (LC_CTYPE, "");
3386 bindtextdomain (PACKAGE, LOCALEDIR);
3387 textdomain (PACKAGE);
3389 program_name = *argv;
3390 xmalloc_set_program_name (program_name);
3392 START_PROGRESS (program_name, 0);
3394 expandargv (&argc, &argv);
3397 set_default_bfd_target ();
3399 while ((c = getopt_long (argc, argv,
3400 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3401 long_options, (int *) 0))
3407 break; /* We've been given a long option. */
3412 if (disassembler_options)
3413 /* Ignore potential memory leak for now. */
3414 disassembler_options = concat (disassembler_options, ",",
3415 optarg, (const char *) NULL);
3417 disassembler_options = optarg;
3423 display_file_offsets = TRUE;
3426 with_line_numbers = TRUE;
3435 enum demangling_styles style;
3437 style = cplus_demangle_name_to_style (optarg);
3438 if (style == unknown_demangling)
3439 fatal (_("unknown demangling style `%s'"),
3442 cplus_demangle_set_style (style);
3448 case OPTION_ADJUST_VMA:
3449 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3451 case OPTION_START_ADDRESS:
3452 start_address = parse_vma (optarg, "--start-address");
3453 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3454 fatal (_("error: the start address should be before the end address"));
3456 case OPTION_STOP_ADDRESS:
3457 stop_address = parse_vma (optarg, "--stop-address");
3458 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3459 fatal (_("error: the stop address should be after the start address"));
3463 prefix_length = strlen (prefix);
3464 /* Remove an unnecessary trailing '/' */
3465 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3468 case OPTION_PREFIX_STRIP:
3469 prefix_strip = atoi (optarg);
3470 if (prefix_strip < 0)
3471 fatal (_("error: prefix strip must be non-negative"));
3473 case OPTION_INSN_WIDTH:
3474 insn_width = strtoul (optarg, NULL, 0);
3475 if (insn_width <= 0)
3476 fatal (_("error: instruction width must be positive"));
3479 if (strcmp (optarg, "B") == 0)
3480 endian = BFD_ENDIAN_BIG;
3481 else if (strcmp (optarg, "L") == 0)
3482 endian = BFD_ENDIAN_LITTLE;
3485 nonfatal (_("unrecognized -E option"));
3490 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3491 endian = BFD_ENDIAN_BIG;
3492 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3493 endian = BFD_ENDIAN_LITTLE;
3496 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3503 dump_file_header = TRUE;
3507 formats_info = TRUE;
3511 add_include_path (optarg);
3514 dump_private_headers = TRUE;
3518 dump_private_options = optarg;
3522 dump_private_headers = TRUE;
3524 dump_reloc_info = TRUE;
3525 dump_file_header = TRUE;
3526 dump_ar_hdrs = TRUE;
3527 dump_section_headers = TRUE;
3535 dump_dynamic_symtab = TRUE;
3543 disassemble_zeroes = TRUE;
3547 disassemble_all = TRUE;
3552 with_source_code = TRUE;
3561 dump_debugging_tags = 1;
3566 dump_dwarf_section_info = TRUE;
3569 dwarf_select_sections_by_letters (optarg);
3571 dwarf_select_sections_all ();
3574 dump_dwarf_section_info = TRUE;
3577 dwarf_select_sections_by_names (optarg);
3579 dwarf_select_sections_all ();
3581 case OPTION_DWARF_DEPTH:
3584 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3587 case OPTION_DWARF_START:
3590 dwarf_start_die = strtoul (optarg, & cp, 0);
3591 suppress_bfd_header = 1;
3594 case OPTION_DWARF_CHECK:
3598 dump_stab_section_info = TRUE;
3602 dump_section_contents = TRUE;
3606 dump_reloc_info = TRUE;
3610 dump_dynamic_reloc_info = TRUE;
3614 dump_ar_hdrs = TRUE;
3618 dump_section_headers = TRUE;
3626 show_version = TRUE;
3636 print_version ("objdump");
3642 exit_status = display_info ();
3646 display_file ("a.out", target);
3648 for (; optind < argc;)
3649 display_file (argv[optind++], target);
3654 END_PROGRESS (program_name);