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
4 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. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #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 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 bfd_vma start_address = (bfd_vma) -1; /* --start-address */
108 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
109 static int dump_debugging; /* --debugging */
110 static int dump_debugging_tags; /* --debugging-tags */
111 static int dump_special_syms = 0; /* --special-syms */
112 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
113 static int file_start_context = 0; /* --file-start-context */
114 static bfd_boolean display_file_offsets;/* -F */
115 static const char *prefix; /* --prefix */
116 static int prefix_strip; /* --prefix-strip */
117 static size_t prefix_length;
119 /* Pointer to an array of section names provided by
120 one or more "-j secname" command line options. */
122 /* The total number of slots in the only[] array. */
123 static size_t only_size = 0;
124 /* The number of occupied slots in the only[] array. */
125 static size_t only_used = 0;
127 /* Variables for handling include file path table. */
128 static const char **include_paths;
129 static int include_path_count;
131 /* Extra info to pass to the section disassembler and address printing
133 struct objdump_disasm_info
137 bfd_boolean require_sec;
138 arelent ** dynrelbuf;
140 disassembler_ftype disassemble_fn;
144 /* Architecture to disassemble for, or default if NULL. */
145 static char *machine = NULL;
147 /* Target specific options to the disassembler. */
148 static char *disassembler_options = NULL;
150 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
151 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
153 /* The symbol table. */
154 static asymbol **syms;
156 /* Number of symbols in `syms'. */
157 static long symcount = 0;
159 /* The sorted symbol table. */
160 static asymbol **sorted_syms;
162 /* Number of symbols in `sorted_syms'. */
163 static long sorted_symcount = 0;
165 /* The dynamic symbol table. */
166 static asymbol **dynsyms;
168 /* The synthetic symbol table. */
169 static asymbol *synthsyms;
170 static long synthcount = 0;
172 /* Number of symbols in `dynsyms'. */
173 static long dynsymcount = 0;
175 static bfd_byte *stabs;
176 static bfd_size_type stab_size;
179 static bfd_size_type stabstr_size;
181 static bfd_boolean is_relocatable = FALSE;
184 usage (FILE *stream, int status)
186 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
187 fprintf (stream, _(" Display information from object <file(s)>.\n"));
188 fprintf (stream, _(" At least one of the following switches must be given:\n"));
189 fprintf (stream, _("\
190 -a, --archive-headers Display archive header information\n\
191 -f, --file-headers Display the contents of the overall file header\n\
192 -p, --private-headers Display object format specific file header contents\n\
193 -h, --[section-]headers Display the contents of the section headers\n\
194 -x, --all-headers Display the contents of all headers\n\
195 -d, --disassemble Display assembler contents of executable sections\n\
196 -D, --disassemble-all Display assembler contents of all sections\n\
197 -S, --source Intermix source code with disassembly\n\
198 -s, --full-contents Display the full contents of all sections requested\n\
199 -g, --debugging Display debug information in object file\n\
200 -e, --debugging-tags Display debug information using ctags style\n\
201 -G, --stabs Display (in raw form) any STABS info in the file\n\
202 -W[lLiaprmfFsoR] or\n\
203 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
204 Display DWARF info in the file\n\
205 -t, --syms Display the contents of the symbol table(s)\n\
206 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
207 -r, --reloc Display the relocation entries in the file\n\
208 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
209 @<file> Read options from <file>\n\
210 -v, --version Display this program's version number\n\
211 -i, --info List object formats and architectures supported\n\
212 -H, --help Display this information\n\
216 fprintf (stream, _("\n The following switches are optional:\n"));
217 fprintf (stream, _("\
218 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
219 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
220 -j, --section=NAME Only display information for section NAME\n\
221 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
222 -EB --endian=big Assume big endian format when disassembling\n\
223 -EL --endian=little Assume little endian format when disassembling\n\
224 --file-start-context Include context from start of file (with -S)\n\
225 -I, --include=DIR Add DIR to search list for source files\n\
226 -l, --line-numbers Include line numbers and filenames in output\n\
227 -F, --file-offsets Include file offsets when displaying information\n\
228 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
229 The STYLE, if specified, can be `auto', `gnu',\n\
230 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
232 -w, --wide Format output for more than 80 columns\n\
233 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
234 --start-address=ADDR Only process data whose address is >= ADDR\n\
235 --stop-address=ADDR Only process data whose address is <= ADDR\n\
236 --prefix-addresses Print complete address alongside disassembly\n\
237 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
238 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
239 --special-syms Include special symbols in symbol dumps\n\
240 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
241 --prefix-strip=LEVEL Strip initial directory names for -S\n\
243 list_supported_targets (program_name, stream);
244 list_supported_architectures (program_name, stream);
246 disassembler_usage (stream);
248 if (REPORT_BUGS_TO[0] && status == 0)
249 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
253 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
257 OPTION_START_ADDRESS,
265 static struct option long_options[]=
267 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
268 {"all-headers", no_argument, NULL, 'x'},
269 {"private-headers", no_argument, NULL, 'p'},
270 {"architecture", required_argument, NULL, 'm'},
271 {"archive-headers", no_argument, NULL, 'a'},
272 {"debugging", no_argument, NULL, 'g'},
273 {"debugging-tags", no_argument, NULL, 'e'},
274 {"demangle", optional_argument, NULL, 'C'},
275 {"disassemble", no_argument, NULL, 'd'},
276 {"disassemble-all", no_argument, NULL, 'D'},
277 {"disassembler-options", required_argument, NULL, 'M'},
278 {"disassemble-zeroes", no_argument, NULL, 'z'},
279 {"dynamic-reloc", no_argument, NULL, 'R'},
280 {"dynamic-syms", no_argument, NULL, 'T'},
281 {"endian", required_argument, NULL, OPTION_ENDIAN},
282 {"file-headers", no_argument, NULL, 'f'},
283 {"file-offsets", no_argument, NULL, 'F'},
284 {"file-start-context", no_argument, &file_start_context, 1},
285 {"full-contents", no_argument, NULL, 's'},
286 {"headers", no_argument, NULL, 'h'},
287 {"help", no_argument, NULL, 'H'},
288 {"info", no_argument, NULL, 'i'},
289 {"line-numbers", no_argument, NULL, 'l'},
290 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
291 {"prefix-addresses", no_argument, &prefix_addresses, 1},
292 {"reloc", no_argument, NULL, 'r'},
293 {"section", required_argument, NULL, 'j'},
294 {"section-headers", no_argument, NULL, 'h'},
295 {"show-raw-insn", no_argument, &show_raw_insn, 1},
296 {"source", no_argument, NULL, 'S'},
297 {"special-syms", no_argument, &dump_special_syms, 1},
298 {"include", required_argument, NULL, 'I'},
299 {"dwarf", optional_argument, NULL, OPTION_DWARF},
300 {"stabs", no_argument, NULL, 'G'},
301 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
302 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
303 {"syms", no_argument, NULL, 't'},
304 {"target", required_argument, NULL, 'b'},
305 {"version", no_argument, NULL, 'V'},
306 {"wide", no_argument, NULL, 'w'},
307 {"prefix", required_argument, NULL, OPTION_PREFIX},
308 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
309 {0, no_argument, 0, 0}
313 nonfatal (const char *msg)
320 dump_section_header (bfd *abfd, asection *section,
321 void *ignored ATTRIBUTE_UNUSED)
324 unsigned int opb = bfd_octets_per_byte (abfd);
326 /* Ignore linker created section. See elfNN_ia64_object_p in
328 if (section->flags & SEC_LINKER_CREATED)
331 printf ("%3d %-13s %08lx ", section->index,
332 bfd_get_section_name (abfd, section),
333 (unsigned long) bfd_section_size (abfd, section) / opb);
334 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
336 bfd_printf_vma (abfd, section->lma);
337 printf (" %08lx 2**%u", (unsigned long) section->filepos,
338 bfd_get_section_alignment (abfd, section));
344 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
346 PF (SEC_HAS_CONTENTS, "CONTENTS");
347 PF (SEC_ALLOC, "ALLOC");
348 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
349 PF (SEC_LOAD, "LOAD");
350 PF (SEC_RELOC, "RELOC");
351 PF (SEC_READONLY, "READONLY");
352 PF (SEC_CODE, "CODE");
353 PF (SEC_DATA, "DATA");
355 PF (SEC_DEBUGGING, "DEBUGGING");
356 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
357 PF (SEC_EXCLUDE, "EXCLUDE");
358 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
359 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
361 PF (SEC_TIC54X_BLOCK, "BLOCK");
362 PF (SEC_TIC54X_CLINK, "CLINK");
364 PF (SEC_SMALL_DATA, "SMALL_DATA");
365 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
366 PF (SEC_COFF_SHARED, "SHARED");
367 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
368 PF (SEC_GROUP, "GROUP");
370 if ((section->flags & SEC_LINK_ONCE) != 0)
373 struct coff_comdat_info *comdat;
375 switch (section->flags & SEC_LINK_DUPLICATES)
379 case SEC_LINK_DUPLICATES_DISCARD:
380 ls = "LINK_ONCE_DISCARD";
382 case SEC_LINK_DUPLICATES_ONE_ONLY:
383 ls = "LINK_ONCE_ONE_ONLY";
385 case SEC_LINK_DUPLICATES_SAME_SIZE:
386 ls = "LINK_ONCE_SAME_SIZE";
388 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
389 ls = "LINK_ONCE_SAME_CONTENTS";
392 printf ("%s%s", comma, ls);
394 comdat = bfd_coff_get_comdat_section (abfd, section);
396 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
406 dump_headers (bfd *abfd)
408 printf (_("Sections:\n"));
411 printf (_("Idx Name Size VMA LMA File off Algn"));
413 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
414 if (bfd_get_arch_size (abfd) == 32)
415 printf (_("Idx Name Size VMA LMA File off Algn"));
417 printf (_("Idx Name Size VMA LMA File off Algn"));
421 printf (_(" Flags"));
422 if (abfd->flags & HAS_LOAD_PAGE)
426 bfd_map_over_sections (abfd, dump_section_header, NULL);
430 slurp_symtab (bfd *abfd)
435 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
441 storage = bfd_get_symtab_upper_bound (abfd);
443 bfd_fatal (bfd_get_filename (abfd));
445 sy = xmalloc (storage);
447 symcount = bfd_canonicalize_symtab (abfd, sy);
449 bfd_fatal (bfd_get_filename (abfd));
453 /* Read in the dynamic symbols. */
456 slurp_dynamic_symtab (bfd *abfd)
461 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
464 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
466 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
471 bfd_fatal (bfd_get_filename (abfd));
474 sy = xmalloc (storage);
476 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
478 bfd_fatal (bfd_get_filename (abfd));
482 /* Filter out (in place) symbols that are useless for disassembly.
483 COUNT is the number of elements in SYMBOLS.
484 Return the number of useful symbols. */
487 remove_useless_symbols (asymbol **symbols, long count)
489 asymbol **in_ptr = symbols, **out_ptr = symbols;
493 asymbol *sym = *in_ptr++;
495 if (sym->name == NULL || sym->name[0] == '\0')
497 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
499 if (bfd_is_und_section (sym->section)
500 || bfd_is_com_section (sym->section))
505 return out_ptr - symbols;
508 /* Sort symbols into value order. */
511 compare_symbols (const void *ap, const void *bp)
513 const asymbol *a = * (const asymbol **) ap;
514 const asymbol *b = * (const asymbol **) bp;
524 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
526 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
529 if (a->section > b->section)
531 else if (a->section < b->section)
534 an = bfd_asymbol_name (a);
535 bn = bfd_asymbol_name (b);
539 /* The symbols gnu_compiled and gcc2_compiled convey no real
540 information, so put them after other symbols with the same value. */
541 af = (strstr (an, "gnu_compiled") != NULL
542 || strstr (an, "gcc2_compiled") != NULL);
543 bf = (strstr (bn, "gnu_compiled") != NULL
544 || strstr (bn, "gcc2_compiled") != NULL);
551 /* We use a heuristic for the file name, to try to sort it after
552 more useful symbols. It may not work on non Unix systems, but it
553 doesn't really matter; the only difference is precisely which
554 symbol names get printed. */
556 #define file_symbol(s, sn, snl) \
557 (((s)->flags & BSF_FILE) != 0 \
558 || ((sn)[(snl) - 2] == '.' \
559 && ((sn)[(snl) - 1] == 'o' \
560 || (sn)[(snl) - 1] == 'a')))
562 af = file_symbol (a, an, anl);
563 bf = file_symbol (b, bn, bnl);
570 /* Try to sort global symbols before local symbols before function
571 symbols before debugging symbols. */
576 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
578 if ((aflags & BSF_DEBUGGING) != 0)
583 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
585 if ((aflags & BSF_FUNCTION) != 0)
590 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
592 if ((aflags & BSF_LOCAL) != 0)
597 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
599 if ((aflags & BSF_GLOBAL) != 0)
605 /* Symbols that start with '.' might be section names, so sort them
606 after symbols that don't start with '.'. */
607 if (an[0] == '.' && bn[0] != '.')
609 if (an[0] != '.' && bn[0] == '.')
612 /* Finally, if we can't distinguish them in any other way, try to
613 get consistent results by sorting the symbols by name. */
614 return strcmp (an, bn);
617 /* Sort relocs into address order. */
620 compare_relocs (const void *ap, const void *bp)
622 const arelent *a = * (const arelent **) ap;
623 const arelent *b = * (const arelent **) bp;
625 if (a->address > b->address)
627 else if (a->address < b->address)
630 /* So that associated relocations tied to the same address show up
631 in the correct order, we don't do any further sorting. */
640 /* Print an address (VMA) to the output stream in INFO.
641 If SKIP_ZEROES is TRUE, omit leading zeroes. */
644 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
645 bfd_boolean skip_zeroes)
649 struct objdump_disasm_info *aux;
651 aux = (struct objdump_disasm_info *) info->application_data;
652 bfd_sprintf_vma (aux->abfd, buf, vma);
657 for (p = buf; *p == '0'; ++p)
662 (*info->fprintf_func) (info->stream, "%s", p);
665 /* Print the name of a symbol. */
668 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
675 name = bfd_asymbol_name (sym);
676 if (do_demangle && name[0] != '\0')
678 /* Demangle the name. */
679 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
685 (*info->fprintf_func) (info->stream, "%s", name);
693 /* Locate a symbol given a bfd and a section (from INFO->application_data),
694 and a VMA. If INFO->application_data->require_sec is TRUE, then always
695 require the symbol to be in the section. Returns NULL if there is no
696 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
697 of the symbol in sorted_syms. */
700 find_symbol_for_address (bfd_vma vma,
701 struct disassemble_info *info,
704 /* @@ Would it speed things up to cache the last two symbols returned,
705 and maybe their address ranges? For many processors, only one memory
706 operand can be present at a time, so the 2-entry cache wouldn't be
707 constantly churned by code doing heavy memory accesses. */
709 /* Indices in `sorted_syms'. */
711 long max = sorted_symcount;
713 struct objdump_disasm_info *aux;
717 bfd_boolean want_section;
719 if (sorted_symcount < 1)
722 aux = (struct objdump_disasm_info *) info->application_data;
725 opb = bfd_octets_per_byte (abfd);
727 /* Perform a binary search looking for the closest symbol to the
728 required value. We are searching the range (min, max]. */
729 while (min + 1 < max)
733 thisplace = (max + min) / 2;
734 sym = sorted_syms[thisplace];
736 if (bfd_asymbol_value (sym) > vma)
738 else if (bfd_asymbol_value (sym) < vma)
747 /* The symbol we want is now in min, the low end of the range we
748 were searching. If there are several symbols with the same
749 value, we want the first one. */
752 && (bfd_asymbol_value (sorted_syms[thisplace])
753 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
756 /* Prefer a symbol in the current section if we have multple symbols
757 with the same value, as can occur with overlays or zero size
761 && (bfd_asymbol_value (sorted_syms[min])
762 == bfd_asymbol_value (sorted_syms[thisplace])))
764 if (sorted_syms[min]->section == sec
765 && info->symbol_is_valid (sorted_syms[min], info))
772 return sorted_syms[thisplace];
777 /* If the file is relocatable, and the symbol could be from this
778 section, prefer a symbol from this section over symbols from
779 others, even if the other symbol's value might be closer.
781 Note that this may be wrong for some symbol references if the
782 sections have overlapping memory ranges, but in that case there's
783 no way to tell what's desired without looking at the relocation
786 Also give the target a chance to reject symbols. */
787 want_section = (aux->require_sec
788 || ((abfd->flags & HAS_RELOC) != 0
789 && vma >= bfd_get_section_vma (abfd, sec)
790 && vma < (bfd_get_section_vma (abfd, sec)
791 + bfd_section_size (abfd, sec) / opb)));
792 if ((sorted_syms[thisplace]->section != sec && want_section)
793 || !info->symbol_is_valid (sorted_syms[thisplace], info))
796 long newplace = sorted_symcount;
798 for (i = min - 1; i >= 0; i--)
800 if ((sorted_syms[i]->section == sec || !want_section)
801 && info->symbol_is_valid (sorted_syms[i], info))
803 if (newplace == sorted_symcount)
806 if (bfd_asymbol_value (sorted_syms[i])
807 != bfd_asymbol_value (sorted_syms[newplace]))
810 /* Remember this symbol and keep searching until we reach
811 an earlier address. */
816 if (newplace != sorted_symcount)
817 thisplace = newplace;
820 /* We didn't find a good symbol with a smaller value.
821 Look for one with a larger value. */
822 for (i = thisplace + 1; i < sorted_symcount; i++)
824 if ((sorted_syms[i]->section == sec || !want_section)
825 && info->symbol_is_valid (sorted_syms[i], info))
833 if ((sorted_syms[thisplace]->section != sec && want_section)
834 || !info->symbol_is_valid (sorted_syms[thisplace], info))
835 /* There is no suitable symbol. */
842 return sorted_syms[thisplace];
845 /* Print an address and the offset to the nearest symbol. */
848 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
849 bfd_vma vma, struct disassemble_info *info,
850 bfd_boolean skip_zeroes)
852 objdump_print_value (vma, info, skip_zeroes);
858 (*info->fprintf_func) (info->stream, " <%s",
859 bfd_get_section_name (abfd, sec));
860 secaddr = bfd_get_section_vma (abfd, sec);
863 (*info->fprintf_func) (info->stream, "-0x");
864 objdump_print_value (secaddr - vma, info, TRUE);
866 else if (vma > secaddr)
868 (*info->fprintf_func) (info->stream, "+0x");
869 objdump_print_value (vma - secaddr, info, TRUE);
871 (*info->fprintf_func) (info->stream, ">");
875 (*info->fprintf_func) (info->stream, " <");
876 objdump_print_symname (abfd, info, sym);
877 if (bfd_asymbol_value (sym) > vma)
879 (*info->fprintf_func) (info->stream, "-0x");
880 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
882 else if (vma > bfd_asymbol_value (sym))
884 (*info->fprintf_func) (info->stream, "+0x");
885 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
887 (*info->fprintf_func) (info->stream, ">");
890 if (display_file_offsets)
891 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
892 (long int)(sec->filepos + (vma - sec->vma)));
895 /* Print an address (VMA), symbolically if possible.
896 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
899 objdump_print_addr (bfd_vma vma,
900 struct disassemble_info *info,
901 bfd_boolean skip_zeroes)
903 struct objdump_disasm_info *aux;
905 bfd_boolean skip_find = FALSE;
907 aux = (struct objdump_disasm_info *) info->application_data;
909 if (sorted_symcount < 1)
911 (*info->fprintf_func) (info->stream, "0x");
912 objdump_print_value (vma, info, skip_zeroes);
914 if (display_file_offsets)
915 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
916 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
920 if (aux->reloc != NULL
921 && aux->reloc->sym_ptr_ptr != NULL
922 && * aux->reloc->sym_ptr_ptr != NULL)
924 sym = * aux->reloc->sym_ptr_ptr;
926 /* Adjust the vma to the reloc. */
927 vma += bfd_asymbol_value (sym);
929 if (bfd_is_und_section (bfd_get_section (sym)))
934 sym = find_symbol_for_address (vma, info, NULL);
936 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
940 /* Print VMA to INFO. This function is passed to the disassembler
944 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
946 objdump_print_addr (vma, info, ! prefix_addresses);
949 /* Determine if the given address has a symbol associated with it. */
952 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
956 sym = find_symbol_for_address (vma, info, NULL);
958 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
961 /* Hold the last function name and the last line number we displayed
964 static char *prev_functionname;
965 static unsigned int prev_line;
967 /* We keep a list of all files that we have seen when doing a
968 disassembly with source, so that we know how much of the file to
969 display. This can be important for inlined functions. */
971 struct print_file_list
973 struct print_file_list *next;
974 const char *filename;
978 const char **linemap;
984 static struct print_file_list *print_files;
986 /* The number of preceding context lines to show when we start
987 displaying a file for the first time. */
989 #define SHOW_PRECEDING_CONTEXT_LINES (5)
991 /* Read a complete file into memory. */
994 slurp_file (const char *fn, size_t *size)
997 int ps = getpagesize ();
1002 int fd = open (fn, O_RDONLY | O_BINARY);
1006 if (fstat (fd, &st) < 0)
1010 msize = (*size + ps - 1) & ~(ps - 1);
1011 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1012 if (map != (char *)-1L)
1018 map = malloc (*size);
1019 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1028 #define line_map_decrease 5
1030 /* Precompute array of lines for a mapped file. */
1032 static const char **
1033 index_file (const char *map, size_t size, unsigned int *maxline)
1035 const char *p, *lstart, *end;
1036 int chars_per_line = 45; /* First iteration will use 40. */
1037 unsigned int lineno;
1038 const char **linemap = NULL;
1039 unsigned long line_map_size = 0;
1045 for (p = map; p < end; p++)
1049 if (p + 1 < end && p[1] == '\r')
1052 else if (*p == '\r')
1054 if (p + 1 < end && p[1] == '\n')
1060 /* End of line found. */
1062 if (linemap == NULL || line_map_size < lineno + 1)
1064 unsigned long newsize;
1066 chars_per_line -= line_map_decrease;
1067 if (chars_per_line <= 1)
1069 line_map_size = size / chars_per_line + 1;
1070 if (line_map_size < lineno + 1)
1071 line_map_size = lineno + 1;
1072 newsize = line_map_size * sizeof (char *);
1073 linemap = xrealloc (linemap, newsize);
1076 linemap[lineno++] = lstart;
1084 /* Tries to open MODNAME, and if successful adds a node to print_files
1085 linked list and returns that node. Returns NULL on failure. */
1087 static struct print_file_list *
1088 try_print_file_open (const char *origname, const char *modname)
1090 struct print_file_list *p;
1092 p = xmalloc (sizeof (struct print_file_list));
1094 p->map = slurp_file (modname, &p->mapsize);
1101 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1103 p->filename = origname;
1104 p->modname = modname;
1105 p->next = print_files;
1111 /* If the the source file, as described in the symtab, is not found
1112 try to locate it in one of the paths specified with -I
1113 If found, add location to print_files linked list. */
1115 static struct print_file_list *
1116 update_source_path (const char *filename)
1118 struct print_file_list *p;
1122 if (filename == NULL)
1125 p = try_print_file_open (filename, filename);
1129 if (include_path_count == 0)
1132 /* Get the name of the file. */
1133 fname = strrchr (filename, '/');
1134 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1136 /* We could have a mixed forward/back slash case. */
1137 char *backslash = strrchr (filename, '\\');
1138 if (fname == NULL || (backslash != NULL && backslash > fname))
1140 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
1141 fname = filename + 1;
1149 /* If file exists under a new path, we need to add it to the list
1150 so that show_line knows about it. */
1151 for (i = 0; i < include_path_count; i++)
1153 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1155 p = try_print_file_open (filename, modname);
1165 /* Print a source file line. */
1168 print_line (struct print_file_list *p, unsigned int line)
1174 if (line >= p->maxline)
1176 l = p->linemap [line];
1177 /* Test fwrite return value to quiet glibc warning. */
1178 len = strcspn (l, "\n\r");
1179 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1183 /* Print a range of source code lines. */
1186 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1190 while (start <= end)
1192 print_line (p, start);
1197 /* Show the line number, or the source line, in a disassembly
1201 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1203 const char *filename;
1204 const char *functionname;
1208 if (! with_line_numbers && ! with_source_code)
1211 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1212 &functionname, &line))
1215 if (filename != NULL && *filename == '\0')
1217 if (functionname != NULL && *functionname == '\0')
1218 functionname = NULL;
1221 && IS_ABSOLUTE_PATH (filename)
1225 const char *fname = filename;
1226 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1229 memcpy (path, prefix, prefix_length);
1230 path_up = path + prefix_length;
1232 /* Build relocated filename, stripping off leading directories
1233 from the initial filename if requested. */
1234 if (prefix_strip > 0)
1239 /* Skip selected directory levels. */
1240 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1241 if (IS_DIR_SEPARATOR(*s))
1248 /* Update complete filename. */
1249 strncpy (path_up, fname, PATH_MAX);
1250 path_up[PATH_MAX] = '\0';
1258 if (with_line_numbers)
1260 if (functionname != NULL
1261 && (prev_functionname == NULL
1262 || strcmp (functionname, prev_functionname) != 0))
1263 printf ("%s():\n", functionname);
1264 if (line > 0 && line != prev_line)
1265 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1268 if (with_source_code
1272 struct print_file_list **pp, *p;
1275 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1276 if (strcmp ((*pp)->filename, filename) == 0)
1283 filename = xstrdup (filename);
1284 p = update_source_path (filename);
1287 if (p != NULL && line != p->last_line)
1289 if (file_start_context && p->first)
1293 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1296 if (p->last_line >= l && p->last_line <= line)
1297 l = p->last_line + 1;
1299 dump_lines (p, l, line);
1300 p->last_line = line;
1305 if (functionname != NULL
1306 && (prev_functionname == NULL
1307 || strcmp (functionname, prev_functionname) != 0))
1309 if (prev_functionname != NULL)
1310 free (prev_functionname);
1311 prev_functionname = xmalloc (strlen (functionname) + 1);
1312 strcpy (prev_functionname, functionname);
1315 if (line > 0 && line != prev_line)
1319 /* Pseudo FILE object for strings. */
1327 /* sprintf to a "stream". */
1329 static int ATTRIBUTE_PRINTF_2
1330 objdump_sprintf (SFILE *f, const char *format, ...)
1337 size_t space = f->alloc - f->pos;
1339 va_start (args, format);
1340 n = vsnprintf (f->buffer + f->pos, space, format, args);
1346 f->alloc = (f->alloc + n) * 2;
1347 f->buffer = xrealloc (f->buffer, f->alloc);
1354 /* Returns TRUE if the specified section should be dumped. */
1357 process_section_p (asection * section)
1364 for (i = 0; i < only_used; i++)
1365 if (strcmp (only [i], section->name) == 0)
1372 /* The number of zeroes we want to see before we start skipping them.
1373 The number is arbitrarily chosen. */
1375 #define DEFAULT_SKIP_ZEROES 8
1377 /* The number of zeroes to skip at the end of a section. If the
1378 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1379 SKIP_ZEROES, they will be disassembled. If there are fewer than
1380 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1381 attempt to avoid disassembling zeroes inserted by section
1384 #define DEFAULT_SKIP_ZEROES_AT_END 3
1386 /* Disassemble some data in memory between given values. */
1389 disassemble_bytes (struct disassemble_info * info,
1390 disassembler_ftype disassemble_fn,
1393 bfd_vma start_offset,
1394 bfd_vma stop_offset,
1397 arelent ** relppend)
1399 struct objdump_disasm_info *aux;
1401 int octets_per_line;
1402 bfd_boolean done_dot;
1403 int skip_addr_chars;
1404 bfd_vma addr_offset;
1405 unsigned int opb = info->octets_per_byte;
1406 unsigned int skip_zeroes = info->skip_zeroes;
1407 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1411 aux = (struct objdump_disasm_info *) info->application_data;
1415 sfile.buffer = xmalloc (sfile.alloc);
1419 octets_per_line = 4;
1421 octets_per_line = 16;
1423 /* Figure out how many characters to skip at the start of an
1424 address, to make the disassembly look nicer. We discard leading
1425 zeroes in chunks of 4, ensuring that there is always a leading
1427 skip_addr_chars = 0;
1428 if (! prefix_addresses)
1432 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1434 while (buf[skip_addr_chars] == '0')
1437 /* Don't discard zeros on overflow. */
1438 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1439 skip_addr_chars = 0;
1441 if (skip_addr_chars != 0)
1442 skip_addr_chars = (skip_addr_chars - 1) & -4;
1445 info->insn_info_valid = 0;
1448 addr_offset = start_offset;
1449 while (addr_offset < stop_offset)
1452 bfd_boolean need_nl = FALSE;
1453 int previous_octets;
1455 /* Remember the length of the previous instruction. */
1456 previous_octets = octets;
1459 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1461 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1464 if (! disassemble_zeroes
1465 && (info->insn_info_valid == 0
1466 || info->branch_delay_insns == 0)
1467 && (z - addr_offset * opb >= skip_zeroes
1468 || (z == stop_offset * opb &&
1469 z - addr_offset * opb < skip_zeroes_at_end)))
1471 /* If there are more nonzero octets to follow, we only skip
1472 zeroes in multiples of 4, to try to avoid running over
1473 the start of an instruction which happens to start with
1475 if (z != stop_offset * opb)
1476 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1478 octets = z - addr_offset * opb;
1480 /* If we are going to display more data, and we are displaying
1481 file offsets, then tell the user how many zeroes we skip
1482 and the file offset from where we resume dumping. */
1483 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1484 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1486 (unsigned long) (section->filepos
1487 + (addr_offset + (octets / opb))));
1499 if (with_line_numbers || with_source_code)
1500 show_line (aux->abfd, section, addr_offset);
1502 if (! prefix_addresses)
1506 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1507 for (s = buf + skip_addr_chars; *s == '0'; s++)
1511 printf ("%s:\t", buf + skip_addr_chars);
1515 aux->require_sec = TRUE;
1516 objdump_print_address (section->vma + addr_offset, info);
1517 aux->require_sec = FALSE;
1524 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1525 info->stream = &sfile;
1526 info->bytes_per_line = 0;
1527 info->bytes_per_chunk = 0;
1530 if (info->disassembler_needs_relocs
1531 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1532 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1533 && *relppp < relppend)
1535 bfd_signed_vma distance_to_rel;
1537 distance_to_rel = (**relppp)->address
1538 - (rel_offset + addr_offset);
1540 /* Check to see if the current reloc is associated with
1541 the instruction that we are about to disassemble. */
1542 if (distance_to_rel == 0
1543 /* FIXME: This is wrong. We are trying to catch
1544 relocs that are addressed part way through the
1545 current instruction, as might happen with a packed
1546 VLIW instruction. Unfortunately we do not know the
1547 length of the current instruction since we have not
1548 disassembled it yet. Instead we take a guess based
1549 upon the length of the previous instruction. The
1550 proper solution is to have a new target-specific
1551 disassembler function which just returns the length
1552 of an instruction at a given address without trying
1553 to display its disassembly. */
1554 || (distance_to_rel > 0
1555 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1557 info->flags = INSN_HAS_RELOC;
1558 aux->reloc = **relppp;
1564 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1565 info->fprintf_func = (fprintf_ftype) fprintf;
1566 info->stream = stdout;
1567 if (info->bytes_per_line != 0)
1568 octets_per_line = info->bytes_per_line;
1572 printf ("%s\n", sfile.buffer);
1580 octets = octets_per_line;
1581 if (addr_offset + octets / opb > stop_offset)
1582 octets = (stop_offset - addr_offset) * opb;
1584 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1586 if (ISPRINT (data[j]))
1587 buf[j - addr_offset * opb] = data[j];
1589 buf[j - addr_offset * opb] = '.';
1591 buf[j - addr_offset * opb] = '\0';
1594 if (prefix_addresses
1596 : show_raw_insn >= 0)
1600 /* If ! prefix_addresses and ! wide_output, we print
1601 octets_per_line octets per line. */
1603 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1604 pb = octets_per_line;
1606 if (info->bytes_per_chunk)
1607 bpc = info->bytes_per_chunk;
1611 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1615 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1617 for (k = bpc - 1; k >= 0; k--)
1618 printf ("%02x", (unsigned) data[j + k]);
1623 for (k = 0; k < bpc; k++)
1624 printf ("%02x", (unsigned) data[j + k]);
1629 for (; pb < octets_per_line; pb += bpc)
1633 for (k = 0; k < bpc; k++)
1638 /* Separate raw data from instruction by extra space. */
1648 printf ("%s", sfile.buffer);
1650 if (prefix_addresses
1652 : show_raw_insn >= 0)
1660 j = addr_offset * opb + pb;
1662 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1663 for (s = buf + skip_addr_chars; *s == '0'; s++)
1667 printf ("%s:\t", buf + skip_addr_chars);
1669 pb += octets_per_line;
1672 for (; j < addr_offset * opb + pb; j += bpc)
1676 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1678 for (k = bpc - 1; k >= 0; k--)
1679 printf ("%02x", (unsigned) data[j + k]);
1684 for (k = 0; k < bpc; k++)
1685 printf ("%02x", (unsigned) data[j + k]);
1698 while ((*relppp) < relppend
1699 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1701 if (dump_reloc_info || dump_dynamic_reloc_info)
1712 objdump_print_value (section->vma - rel_offset + q->address,
1715 if (q->howto == NULL)
1716 printf (": *unknown*\t");
1717 else if (q->howto->name)
1718 printf (": %s\t", q->howto->name);
1720 printf (": %d\t", q->howto->type);
1722 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1723 printf ("*unknown*");
1726 const char *sym_name;
1728 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1729 if (sym_name != NULL && *sym_name != '\0')
1730 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1735 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1736 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1737 if (sym_name == NULL || *sym_name == '\0')
1738 sym_name = "*unknown*";
1739 printf ("%s", sym_name);
1746 objdump_print_value (q->addend, info, TRUE);
1758 addr_offset += octets / opb;
1761 free (sfile.buffer);
1765 disassemble_section (bfd *abfd, asection *section, void *info)
1767 const struct elf_backend_data * bed;
1768 bfd_vma sign_adjust = 0;
1769 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1770 struct objdump_disasm_info * paux;
1771 unsigned int opb = pinfo->octets_per_byte;
1772 bfd_byte * data = NULL;
1773 bfd_size_type datasize = 0;
1774 arelent ** rel_pp = NULL;
1775 arelent ** rel_ppstart = NULL;
1776 arelent ** rel_ppend;
1777 unsigned long stop_offset;
1778 asymbol * sym = NULL;
1782 unsigned long addr_offset;
1784 /* Sections that do not contain machine
1785 code are not normally disassembled. */
1786 if (! disassemble_all
1788 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1789 != (SEC_CODE | SEC_HAS_CONTENTS)))
1792 if (! process_section_p (section))
1795 datasize = bfd_get_section_size (section);
1799 /* Decide which set of relocs to use. Load them if necessary. */
1800 paux = (struct objdump_disasm_info *) pinfo->application_data;
1801 if (paux->dynrelbuf)
1803 rel_pp = paux->dynrelbuf;
1804 rel_count = paux->dynrelcount;
1805 /* Dynamic reloc addresses are absolute, non-dynamic are section
1806 relative. REL_OFFSET specifies the reloc address corresponding
1807 to the start of this section. */
1808 rel_offset = section->vma;
1816 if ((section->flags & SEC_RELOC) != 0
1817 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1821 relsize = bfd_get_reloc_upper_bound (abfd, section);
1823 bfd_fatal (bfd_get_filename (abfd));
1827 rel_ppstart = rel_pp = xmalloc (relsize);
1828 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1830 bfd_fatal (bfd_get_filename (abfd));
1832 /* Sort the relocs by address. */
1833 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1837 rel_ppend = rel_pp + rel_count;
1839 data = xmalloc (datasize);
1841 bfd_get_section_contents (abfd, section, data, 0, datasize);
1843 paux->sec = section;
1844 pinfo->buffer = data;
1845 pinfo->buffer_vma = section->vma;
1846 pinfo->buffer_length = datasize;
1847 pinfo->section = section;
1849 if (start_address == (bfd_vma) -1
1850 || start_address < pinfo->buffer_vma)
1853 addr_offset = start_address - pinfo->buffer_vma;
1855 if (stop_address == (bfd_vma) -1)
1856 stop_offset = datasize / opb;
1859 if (stop_address < pinfo->buffer_vma)
1862 stop_offset = stop_address - pinfo->buffer_vma;
1863 if (stop_offset > pinfo->buffer_length / opb)
1864 stop_offset = pinfo->buffer_length / opb;
1867 /* Skip over the relocs belonging to addresses below the
1869 while (rel_pp < rel_ppend
1870 && (*rel_pp)->address < rel_offset + addr_offset)
1873 if (addr_offset < stop_offset)
1874 printf (_("\nDisassembly of section %s:\n"), section->name);
1876 /* Find the nearest symbol forwards from our current position. */
1877 paux->require_sec = TRUE;
1878 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1879 paux->require_sec = FALSE;
1881 /* PR 9774: If the target used signed 32-bit addresses then we must make
1882 sure that we sign extend the value that we calculate for 'addr' in the
1884 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1885 && (bed = get_elf_backend_data (abfd)) != NULL
1886 && bed->sign_extend_vma)
1887 sign_adjust = 0x80000000;
1889 /* Disassemble a block of instructions up to the address associated with
1890 the symbol we have just found. Then print the symbol and find the
1891 next symbol on. Repeat until we have disassembled the entire section
1892 or we have reached the end of the address range we are interested in. */
1893 while (addr_offset < stop_offset)
1897 unsigned long nextstop_offset;
1900 addr = section->vma + addr_offset;
1901 addr = (addr ^ sign_adjust) - sign_adjust;
1903 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1908 (x < sorted_symcount
1909 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1913 pinfo->symbols = sorted_syms + place;
1914 pinfo->num_symbols = x - place;
1915 pinfo->symtab_pos = place;
1919 pinfo->symbols = NULL;
1920 pinfo->num_symbols = 0;
1921 pinfo->symtab_pos = -1;
1924 if (! prefix_addresses)
1926 pinfo->fprintf_func (pinfo->stream, "\n");
1927 objdump_print_addr_with_sym (abfd, section, sym, addr,
1929 pinfo->fprintf_func (pinfo->stream, ":\n");
1932 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1934 else if (sym == NULL)
1938 #define is_valid_next_sym(SYM) \
1939 ((SYM)->section == section \
1940 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1941 && pinfo->symbol_is_valid (SYM, pinfo))
1943 /* Search forward for the next appropriate symbol in
1944 SECTION. Note that all the symbols are sorted
1945 together into one big array, and that some sections
1946 may have overlapping addresses. */
1947 while (place < sorted_symcount
1948 && ! is_valid_next_sym (sorted_syms [place]))
1951 if (place >= sorted_symcount)
1954 nextsym = sorted_syms[place];
1957 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1958 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1959 else if (nextsym == NULL)
1960 nextstop_offset = stop_offset;
1962 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1964 if (nextstop_offset > stop_offset)
1965 nextstop_offset = stop_offset;
1967 /* If a symbol is explicitly marked as being an object
1968 rather than a function, just dump the bytes without
1969 disassembling them. */
1972 || sym->section != section
1973 || bfd_asymbol_value (sym) > addr
1974 || ((sym->flags & BSF_OBJECT) == 0
1975 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1977 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1979 || (sym->flags & BSF_FUNCTION) != 0)
1984 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1985 addr_offset, nextstop_offset,
1986 rel_offset, &rel_pp, rel_ppend);
1988 addr_offset = nextstop_offset;
1994 if (rel_ppstart != NULL)
1998 /* Disassemble the contents of an object file. */
2001 disassemble_data (bfd *abfd)
2003 struct disassemble_info disasm_info;
2004 struct objdump_disasm_info aux;
2008 prev_functionname = NULL;
2011 /* We make a copy of syms to sort. We don't want to sort syms
2012 because that will screw up the relocs. */
2013 sorted_symcount = symcount ? symcount : dynsymcount;
2014 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
2015 memcpy (sorted_syms, symcount ? syms : dynsyms,
2016 sorted_symcount * sizeof (asymbol *));
2018 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2020 for (i = 0; i < synthcount; ++i)
2022 sorted_syms[sorted_symcount] = synthsyms + i;
2026 /* Sort the symbols into section and symbol order. */
2027 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2029 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2031 disasm_info.application_data = (void *) &aux;
2033 aux.require_sec = FALSE;
2034 aux.dynrelbuf = NULL;
2035 aux.dynrelcount = 0;
2038 disasm_info.print_address_func = objdump_print_address;
2039 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2041 if (machine != NULL)
2043 const bfd_arch_info_type *info = bfd_scan_arch (machine);
2046 fatal (_("Can't use supplied machine %s"), machine);
2048 abfd->arch_info = info;
2051 if (endian != BFD_ENDIAN_UNKNOWN)
2053 struct bfd_target *xvec;
2055 xvec = xmalloc (sizeof (struct bfd_target));
2056 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2057 xvec->byteorder = endian;
2061 /* Use libopcodes to locate a suitable disassembler. */
2062 aux.disassemble_fn = disassembler (abfd);
2063 if (!aux.disassemble_fn)
2065 non_fatal (_("Can't disassemble for architecture %s\n"),
2066 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2071 disasm_info.flavour = bfd_get_flavour (abfd);
2072 disasm_info.arch = bfd_get_arch (abfd);
2073 disasm_info.mach = bfd_get_mach (abfd);
2074 disasm_info.disassembler_options = disassembler_options;
2075 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2076 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2077 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2078 disasm_info.disassembler_needs_relocs = FALSE;
2080 if (bfd_big_endian (abfd))
2081 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2082 else if (bfd_little_endian (abfd))
2083 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2085 /* ??? Aborting here seems too drastic. We could default to big or little
2087 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2089 /* Allow the target to customize the info structure. */
2090 disassemble_init_for_target (& disasm_info);
2092 /* Pre-load the dynamic relocs if we are going
2093 to be dumping them along with the disassembly. */
2094 if (dump_dynamic_reloc_info)
2096 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2099 bfd_fatal (bfd_get_filename (abfd));
2103 aux.dynrelbuf = xmalloc (relsize);
2104 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2107 if (aux.dynrelcount < 0)
2108 bfd_fatal (bfd_get_filename (abfd));
2110 /* Sort the relocs by address. */
2111 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2115 disasm_info.symtab = sorted_syms;
2116 disasm_info.symtab_size = sorted_symcount;
2118 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2120 if (aux.dynrelbuf != NULL)
2121 free (aux.dynrelbuf);
2126 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2128 struct dwarf_section *section = &debug_displays [debug].section;
2132 int section_is_compressed;
2134 /* If it is already loaded, do nothing. */
2135 if (section->start != NULL)
2138 /* Locate the debug section. */
2139 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2141 section->name = section->uncompressed_name;
2144 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2146 section->name = section->compressed_name;
2150 section_is_compressed = section->name == section->compressed_name;
2152 section->address = 0;
2153 section->size = bfd_get_section_size (sec);
2154 section->start = xmalloc (section->size);
2156 if (is_relocatable && debug_displays [debug].relocate)
2157 ret = bfd_simple_get_relocated_section_contents (abfd,
2162 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2167 free_debug_section (debug);
2168 printf (_("\nCan't get contents for section '%s'.\n"),
2173 if (section_is_compressed)
2175 bfd_size_type size = section->size;
2176 if (! bfd_uncompress_section_contents (§ion->start, &size))
2178 free_debug_section (debug);
2179 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2182 section->size = size;
2189 free_debug_section (enum dwarf_section_display_enum debug)
2191 struct dwarf_section *section = &debug_displays [debug].section;
2193 if (section->start == NULL)
2196 free ((char *) section->start);
2197 section->start = NULL;
2198 section->address = 0;
2203 dump_dwarf_section (bfd *abfd, asection *section,
2204 void *arg ATTRIBUTE_UNUSED)
2206 const char *name = bfd_get_section_name (abfd, section);
2208 enum dwarf_section_display_enum i;
2210 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2211 match = ".debug_info";
2215 for (i = 0; i < max; i++)
2216 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2217 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2218 && debug_displays [i].enabled != NULL
2219 && *debug_displays [i].enabled)
2221 if (!debug_displays [i].eh_frame)
2223 struct dwarf_section *sec = &debug_displays [i].section;
2225 if (load_debug_section (i, abfd))
2227 debug_displays [i].display (sec, abfd);
2229 if (i != info && i != abbrev)
2230 free_debug_section (i);
2237 /* Dump the dwarf debugging information. */
2240 dump_dwarf (bfd *abfd)
2242 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2244 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2245 targets will return 64. */
2246 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2248 if (bfd_big_endian (abfd))
2249 byte_get = byte_get_big_endian;
2250 else if (bfd_little_endian (abfd))
2251 byte_get = byte_get_little_endian;
2255 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2257 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2258 init_dwarf_regnames (bed->elf_machine_code);
2261 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2263 free_debug_memory ();
2266 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2267 it. Return NULL on failure. */
2270 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2276 stabsect = bfd_get_section_by_name (abfd, sect_name);
2277 if (stabsect == NULL)
2279 printf (_("No %s section present\n\n"), sect_name);
2283 size = bfd_section_size (abfd, stabsect);
2284 contents = xmalloc (size);
2286 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2288 non_fatal (_("Reading %s section of %s failed: %s"),
2289 sect_name, bfd_get_filename (abfd),
2290 bfd_errmsg (bfd_get_error ()));
2301 /* Stabs entries use a 12 byte format:
2302 4 byte string table index
2304 1 byte stab other field
2305 2 byte stab desc field
2307 FIXME: This will have to change for a 64 bit object format. */
2309 #define STRDXOFF (0)
2311 #define OTHEROFF (5)
2314 #define STABSIZE (12)
2316 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2317 using string table section STRSECT_NAME (in `strtab'). */
2320 print_section_stabs (bfd *abfd,
2321 const char *stabsect_name,
2322 unsigned *string_offset_ptr)
2325 unsigned file_string_table_offset = 0;
2326 unsigned next_file_string_table_offset = *string_offset_ptr;
2327 bfd_byte *stabp, *stabs_end;
2330 stabs_end = stabp + stab_size;
2332 printf (_("Contents of %s section:\n\n"), stabsect_name);
2333 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2335 /* Loop through all symbols and print them.
2337 We start the index at -1 because there is a dummy symbol on
2338 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2339 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2343 unsigned char type, other;
2344 unsigned short desc;
2347 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2348 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2349 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2350 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2351 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2353 printf ("\n%-6d ", i);
2354 /* Either print the stab name, or, if unnamed, print its number
2355 again (makes consistent formatting for tools like awk). */
2356 name = bfd_get_stab_name (type);
2358 printf ("%-6s", name);
2359 else if (type == N_UNDF)
2362 printf ("%-6d", type);
2363 printf (" %-6d %-6d ", other, desc);
2364 bfd_printf_vma (abfd, value);
2365 printf (" %-6lu", strx);
2367 /* Symbols with type == 0 (N_UNDF) specify the length of the
2368 string table associated with this file. We use that info
2369 to know how to relocate the *next* file's string table indices. */
2372 file_string_table_offset = next_file_string_table_offset;
2373 next_file_string_table_offset += value;
2377 /* Using the (possibly updated) string table offset, print the
2378 string (if any) associated with this symbol. */
2379 if ((strx + file_string_table_offset) < stabstr_size)
2380 printf (" %s", &strtab[strx + file_string_table_offset]);
2386 *string_offset_ptr = next_file_string_table_offset;
2391 const char * section_name;
2392 const char * string_section_name;
2393 unsigned string_offset;
2398 find_stabs_section (bfd *abfd, asection *section, void *names)
2401 stab_section_names * sought = (stab_section_names *) names;
2403 /* Check for section names for which stabsect_name is a prefix, to
2404 handle .stab.N, etc. */
2405 len = strlen (sought->section_name);
2407 /* If the prefix matches, and the files section name ends with a
2408 nul or a digit, then we match. I.e., we want either an exact
2409 match or a section followed by a number. */
2410 if (strncmp (sought->section_name, section->name, len) == 0
2411 && (section->name[len] == 0
2412 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2415 strtab = read_section_stabs (abfd, sought->string_section_name,
2420 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2423 print_section_stabs (abfd, section->name, &sought->string_offset);
2429 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2431 stab_section_names s;
2433 s.section_name = stabsect_name;
2434 s.string_section_name = strsect_name;
2435 s.string_offset = 0;
2437 bfd_map_over_sections (abfd, find_stabs_section, & s);
2443 /* Dump the any sections containing stabs debugging information. */
2446 dump_stabs (bfd *abfd)
2448 dump_stabs_section (abfd, ".stab", ".stabstr");
2449 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2450 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2453 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2455 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2459 dump_bfd_header (bfd *abfd)
2463 printf (_("architecture: %s, "),
2464 bfd_printable_arch_mach (bfd_get_arch (abfd),
2465 bfd_get_mach (abfd)));
2466 printf (_("flags 0x%08x:\n"), abfd->flags);
2468 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2469 PF (HAS_RELOC, "HAS_RELOC");
2470 PF (EXEC_P, "EXEC_P");
2471 PF (HAS_LINENO, "HAS_LINENO");
2472 PF (HAS_DEBUG, "HAS_DEBUG");
2473 PF (HAS_SYMS, "HAS_SYMS");
2474 PF (HAS_LOCALS, "HAS_LOCALS");
2475 PF (DYNAMIC, "DYNAMIC");
2476 PF (WP_TEXT, "WP_TEXT");
2477 PF (D_PAGED, "D_PAGED");
2478 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2479 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2480 printf (_("\nstart address 0x"));
2481 bfd_printf_vma (abfd, abfd->start_address);
2487 dump_bfd_private_header (bfd *abfd)
2489 bfd_print_private_bfd_data (abfd, stdout);
2493 /* Display a section in hexadecimal format with associated characters.
2494 Each line prefixed by the zero padded address. */
2497 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2500 bfd_size_type datasize;
2501 bfd_size_type addr_offset;
2502 bfd_size_type start_offset;
2503 bfd_size_type stop_offset;
2504 unsigned int opb = bfd_octets_per_byte (abfd);
2505 /* Bytes per line. */
2506 const int onaline = 16;
2511 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2514 if (! process_section_p (section))
2517 if ((datasize = bfd_section_size (abfd, section)) == 0)
2520 /* Compute the address range to display. */
2521 if (start_address == (bfd_vma) -1
2522 || start_address < section->vma)
2525 start_offset = start_address - section->vma;
2527 if (stop_address == (bfd_vma) -1)
2528 stop_offset = datasize / opb;
2531 if (stop_address < section->vma)
2534 stop_offset = stop_address - section->vma;
2536 if (stop_offset > datasize / opb)
2537 stop_offset = datasize / opb;
2540 if (start_offset >= stop_offset)
2543 printf (_("Contents of section %s:"), section->name);
2544 if (display_file_offsets)
2545 printf (_(" (Starting at file offset: 0x%lx)"),
2546 (unsigned long) (section->filepos + start_offset));
2549 data = xmalloc (datasize);
2551 bfd_get_section_contents (abfd, section, data, 0, datasize);
2555 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2556 if (strlen (buf) >= sizeof (buf))
2560 while (buf[count] == '0' && buf[count+1] != '\0')
2562 count = strlen (buf) - count;
2566 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2567 if (strlen (buf) >= sizeof (buf))
2571 while (buf[count] == '0' && buf[count+1] != '\0')
2573 count = strlen (buf) - count;
2577 for (addr_offset = start_offset;
2578 addr_offset < stop_offset; addr_offset += onaline / opb)
2582 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2583 count = strlen (buf);
2584 if ((size_t) count >= sizeof (buf))
2588 while (count < width)
2593 fputs (buf + count - width, stdout);
2596 for (j = addr_offset * opb;
2597 j < addr_offset * opb + onaline; j++)
2599 if (j < stop_offset * opb)
2600 printf ("%02x", (unsigned) (data[j]));
2608 for (j = addr_offset * opb;
2609 j < addr_offset * opb + onaline; j++)
2611 if (j >= stop_offset * opb)
2614 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2621 /* Actually display the various requested regions. */
2624 dump_data (bfd *abfd)
2626 bfd_map_over_sections (abfd, dump_section, NULL);
2629 /* Should perhaps share code and display with nm? */
2632 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2642 printf ("DYNAMIC SYMBOL TABLE:\n");
2648 printf ("SYMBOL TABLE:\n");
2652 printf (_("no symbols\n"));
2654 for (count = 0; count < max; count++)
2658 if (*current == NULL)
2659 printf (_("no information for symbol number %ld\n"), count);
2661 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2662 printf (_("could not determine the type of symbol number %ld\n"),
2665 else if (process_section_p ((* current)->section)
2666 && (dump_special_syms
2667 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2669 const char *name = (*current)->name;
2671 if (do_demangle && name != NULL && *name != '\0')
2675 /* If we want to demangle the name, we demangle it
2676 here, and temporarily clobber it while calling
2677 bfd_print_symbol. FIXME: This is a gross hack. */
2678 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2680 (*current)->name = alloc;
2681 bfd_print_symbol (cur_bfd, stdout, *current,
2682 bfd_print_symbol_all);
2685 (*current)->name = name;
2690 bfd_print_symbol (cur_bfd, stdout, *current,
2691 bfd_print_symbol_all);
2701 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2704 char *last_filename, *last_functionname;
2705 unsigned int last_line;
2707 /* Get column headers lined up reasonably. */
2715 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2716 width = strlen (buf) - 7;
2718 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2721 last_filename = NULL;
2722 last_functionname = NULL;
2725 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2728 const char *filename, *functionname;
2730 const char *sym_name;
2731 const char *section_name;
2733 if (start_address != (bfd_vma) -1
2734 && q->address < start_address)
2736 if (stop_address != (bfd_vma) -1
2737 && q->address > stop_address)
2740 if (with_line_numbers
2742 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2743 &filename, &functionname, &line))
2745 if (functionname != NULL
2746 && (last_functionname == NULL
2747 || strcmp (functionname, last_functionname) != 0))
2749 printf ("%s():\n", functionname);
2750 if (last_functionname != NULL)
2751 free (last_functionname);
2752 last_functionname = xstrdup (functionname);
2756 && (line != last_line
2757 || (filename != NULL
2758 && last_filename != NULL
2759 && strcmp (filename, last_filename) != 0)))
2761 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2763 if (last_filename != NULL)
2764 free (last_filename);
2765 if (filename == NULL)
2766 last_filename = NULL;
2768 last_filename = xstrdup (filename);
2772 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2774 sym_name = (*(q->sym_ptr_ptr))->name;
2775 section_name = (*(q->sym_ptr_ptr))->section->name;
2780 section_name = NULL;
2783 bfd_printf_vma (abfd, q->address);
2784 if (q->howto == NULL)
2785 printf (" *unknown* ");
2786 else if (q->howto->name)
2787 printf (" %-16s ", q->howto->name);
2789 printf (" %-16d ", q->howto->type);
2793 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2797 if (section_name == NULL)
2798 section_name = "*unknown*";
2799 printf ("[%s]", section_name);
2805 bfd_printf_vma (abfd, q->addend);
2813 dump_relocs_in_section (bfd *abfd,
2815 void *dummy ATTRIBUTE_UNUSED)
2821 if ( bfd_is_abs_section (section)
2822 || bfd_is_und_section (section)
2823 || bfd_is_com_section (section)
2824 || (! process_section_p (section))
2825 || ((section->flags & SEC_RELOC) == 0))
2828 relsize = bfd_get_reloc_upper_bound (abfd, section);
2830 bfd_fatal (bfd_get_filename (abfd));
2832 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2836 printf (" (none)\n\n");
2840 relpp = xmalloc (relsize);
2841 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2844 bfd_fatal (bfd_get_filename (abfd));
2845 else if (relcount == 0)
2846 printf (" (none)\n\n");
2850 dump_reloc_set (abfd, section, relpp, relcount);
2857 dump_relocs (bfd *abfd)
2859 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2863 dump_dynamic_relocs (bfd *abfd)
2869 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2871 bfd_fatal (bfd_get_filename (abfd));
2873 printf ("DYNAMIC RELOCATION RECORDS");
2876 printf (" (none)\n\n");
2879 relpp = xmalloc (relsize);
2880 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2883 bfd_fatal (bfd_get_filename (abfd));
2884 else if (relcount == 0)
2885 printf (" (none)\n\n");
2889 dump_reloc_set (abfd, NULL, relpp, relcount);
2896 /* Creates a table of paths, to search for source files. */
2899 add_include_path (const char *path)
2903 include_path_count++;
2904 include_paths = xrealloc (include_paths,
2905 include_path_count * sizeof (*include_paths));
2906 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2907 if (path[1] == ':' && path[2] == 0)
2908 path = concat (path, ".", (const char *) 0);
2910 include_paths[include_path_count - 1] = path;
2914 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2918 if ((section->flags & SEC_DEBUGGING) == 0)
2920 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2921 section->vma += adjust_section_vma;
2923 section->lma += adjust_section_vma;
2927 /* Dump selected contents of ABFD. */
2930 dump_bfd (bfd *abfd)
2932 /* If we are adjusting section VMA's, change them all now. Changing
2933 the BFD information is a hack. However, we must do it, or
2934 bfd_find_nearest_line will not do the right thing. */
2935 if (adjust_section_vma != 0)
2937 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2938 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2941 if (! dump_debugging_tags)
2942 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2945 print_arelt_descr (stdout, abfd, TRUE);
2946 if (dump_file_header)
2947 dump_bfd_header (abfd);
2948 if (dump_private_headers)
2949 dump_bfd_private_header (abfd);
2950 if (! dump_debugging_tags)
2952 if (dump_section_headers)
2953 dump_headers (abfd);
2959 || dump_dwarf_section_info)
2960 syms = slurp_symtab (abfd);
2961 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2962 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2963 dynsyms = slurp_dynamic_symtab (abfd);
2966 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2967 dynsymcount, dynsyms, &synthsyms);
2973 dump_symbols (abfd, FALSE);
2974 if (dump_dynamic_symtab)
2975 dump_symbols (abfd, TRUE);
2976 if (dump_dwarf_section_info)
2978 if (dump_stab_section_info)
2980 if (dump_reloc_info && ! disassemble)
2982 if (dump_dynamic_reloc_info && ! disassemble)
2983 dump_dynamic_relocs (abfd);
2984 if (dump_section_contents)
2987 disassemble_data (abfd);
2993 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
2994 if (dhandle != NULL)
2996 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2998 dump_debugging_tags ? TRUE : FALSE))
3000 non_fatal (_("%s: printing debugging information failed"),
3001 bfd_get_filename (abfd));
3005 /* PR 6483: If there was no STABS or IEEE debug
3006 info in the file, try DWARF instead. */
3007 else if (! dump_dwarf_section_info)
3037 display_bfd (bfd *abfd)
3041 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3047 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3049 nonfatal (bfd_get_filename (abfd));
3050 list_matching_formats (matching);
3055 if (bfd_get_error () != bfd_error_file_not_recognized)
3057 nonfatal (bfd_get_filename (abfd));
3061 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3067 nonfatal (bfd_get_filename (abfd));
3069 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3071 list_matching_formats (matching);
3077 display_file (char *filename, char *target)
3082 if (get_file_size (filename) < 1)
3088 file = bfd_openr (filename, target);
3091 nonfatal (filename);
3095 /* If the file is an archive, process all of its elements. */
3096 if (bfd_check_format (file, bfd_archive))
3098 bfd *last_arfile = NULL;
3100 printf (_("In archive %s:\n"), bfd_get_filename (file));
3103 bfd_set_error (bfd_error_no_error);
3105 arfile = bfd_openr_next_archived_file (file, arfile);
3108 if (bfd_get_error () != bfd_error_no_more_archived_files)
3109 nonfatal (bfd_get_filename (file));
3113 display_bfd (arfile);
3115 if (last_arfile != NULL)
3116 bfd_close (last_arfile);
3117 last_arfile = arfile;
3120 if (last_arfile != NULL)
3121 bfd_close (last_arfile);
3130 main (int argc, char **argv)
3133 char *target = default_target;
3134 bfd_boolean seenflag = FALSE;
3136 #if defined (HAVE_SETLOCALE)
3137 #if defined (HAVE_LC_MESSAGES)
3138 setlocale (LC_MESSAGES, "");
3140 setlocale (LC_CTYPE, "");
3143 bindtextdomain (PACKAGE, LOCALEDIR);
3144 textdomain (PACKAGE);
3146 program_name = *argv;
3147 xmalloc_set_program_name (program_name);
3149 START_PROGRESS (program_name, 0);
3151 expandargv (&argc, &argv);
3154 set_default_bfd_target ();
3156 while ((c = getopt_long (argc, argv,
3157 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3158 long_options, (int *) 0))
3164 break; /* We've been given a long option. */
3169 if (disassembler_options)
3170 /* Ignore potential memory leak for now. */
3171 disassembler_options = concat (disassembler_options, ",",
3172 optarg, (const char *) NULL);
3174 disassembler_options = optarg;
3177 if (only_used == only_size)
3180 only = xrealloc (only, only_size * sizeof (char *));
3182 only [only_used++] = optarg;
3185 display_file_offsets = TRUE;
3188 with_line_numbers = TRUE;
3197 enum demangling_styles style;
3199 style = cplus_demangle_name_to_style (optarg);
3200 if (style == unknown_demangling)
3201 fatal (_("unknown demangling style `%s'"),
3204 cplus_demangle_set_style (style);
3210 case OPTION_ADJUST_VMA:
3211 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3213 case OPTION_START_ADDRESS:
3214 start_address = parse_vma (optarg, "--start-address");
3215 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3216 fatal (_("error: the start address should be before the end address"));
3218 case OPTION_STOP_ADDRESS:
3219 stop_address = parse_vma (optarg, "--stop-address");
3220 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3221 fatal (_("error: the stop address should be after the start address"));
3225 prefix_length = strlen (prefix);
3226 /* Remove an unnecessary trailing '/' */
3227 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3230 case OPTION_PREFIX_STRIP:
3231 prefix_strip = atoi (optarg);
3232 if (prefix_strip < 0)
3233 fatal (_("error: prefix strip must be non-negative"));
3236 if (strcmp (optarg, "B") == 0)
3237 endian = BFD_ENDIAN_BIG;
3238 else if (strcmp (optarg, "L") == 0)
3239 endian = BFD_ENDIAN_LITTLE;
3242 non_fatal (_("unrecognized -E option"));
3247 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3248 endian = BFD_ENDIAN_BIG;
3249 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3250 endian = BFD_ENDIAN_LITTLE;
3253 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3259 dump_file_header = TRUE;
3263 formats_info = TRUE;
3267 add_include_path (optarg);
3270 dump_private_headers = TRUE;
3274 dump_private_headers = TRUE;
3276 dump_reloc_info = TRUE;
3277 dump_file_header = TRUE;
3278 dump_ar_hdrs = TRUE;
3279 dump_section_headers = TRUE;
3287 dump_dynamic_symtab = TRUE;
3295 disassemble_zeroes = TRUE;
3299 disassemble_all = TRUE;
3304 with_source_code = TRUE;
3313 dump_debugging_tags = 1;
3318 dump_dwarf_section_info = TRUE;
3321 dwarf_select_sections_by_letters (optarg);
3323 dwarf_select_sections_all ();
3326 dump_dwarf_section_info = TRUE;
3329 dwarf_select_sections_by_names (optarg);
3331 dwarf_select_sections_all ();
3334 dump_stab_section_info = TRUE;
3338 dump_section_contents = TRUE;
3342 dump_reloc_info = TRUE;
3346 dump_dynamic_reloc_info = TRUE;
3350 dump_ar_hdrs = TRUE;
3354 dump_section_headers = TRUE;
3362 show_version = TRUE;
3372 print_version ("objdump");
3378 exit_status = display_info ();
3382 display_file ("a.out", target);
3384 for (; optind < argc;)
3385 display_file (argv[optind++], target);
3388 END_PROGRESS (program_name);