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 int insn_width; /* --insn-width */
108 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
109 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
110 static int dump_debugging; /* --debugging */
111 static int dump_debugging_tags; /* --debugging-tags */
112 static int dump_special_syms = 0; /* --special-syms */
113 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
114 static int file_start_context = 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets;/* -F */
116 static const char *prefix; /* --prefix */
117 static int prefix_strip; /* --prefix-strip */
118 static size_t prefix_length;
120 /* Pointer to an array of section names provided by
121 one or more "-j secname" command line options. */
123 /* The total number of slots in the only[] array. */
124 static size_t only_size = 0;
125 /* The number of occupied slots in the only[] array. */
126 static size_t only_used = 0;
128 /* Variables for handling include file path table. */
129 static const char **include_paths;
130 static int include_path_count;
132 /* Extra info to pass to the section disassembler and address printing
134 struct objdump_disasm_info
138 bfd_boolean require_sec;
139 arelent ** dynrelbuf;
141 disassembler_ftype disassemble_fn;
145 /* Architecture to disassemble for, or default if NULL. */
146 static char *machine = NULL;
148 /* Target specific options to the disassembler. */
149 static char *disassembler_options = NULL;
151 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
152 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
154 /* The symbol table. */
155 static asymbol **syms;
157 /* Number of symbols in `syms'. */
158 static long symcount = 0;
160 /* The sorted symbol table. */
161 static asymbol **sorted_syms;
163 /* Number of symbols in `sorted_syms'. */
164 static long sorted_symcount = 0;
166 /* The dynamic symbol table. */
167 static asymbol **dynsyms;
169 /* The synthetic symbol table. */
170 static asymbol *synthsyms;
171 static long synthcount = 0;
173 /* Number of symbols in `dynsyms'. */
174 static long dynsymcount = 0;
176 static bfd_byte *stabs;
177 static bfd_size_type stab_size;
180 static bfd_size_type stabstr_size;
182 static bfd_boolean is_relocatable = FALSE;
185 usage (FILE *stream, int status)
187 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
188 fprintf (stream, _(" Display information from object <file(s)>.\n"));
189 fprintf (stream, _(" At least one of the following switches must be given:\n"));
190 fprintf (stream, _("\
191 -a, --archive-headers Display archive header information\n\
192 -f, --file-headers Display the contents of the overall file header\n\
193 -p, --private-headers Display object format specific file header contents\n\
194 -h, --[section-]headers Display the contents of the section headers\n\
195 -x, --all-headers Display the contents of all headers\n\
196 -d, --disassemble Display assembler contents of executable sections\n\
197 -D, --disassemble-all Display assembler contents of all sections\n\
198 -S, --source Intermix source code with disassembly\n\
199 -s, --full-contents Display the full contents of all sections requested\n\
200 -g, --debugging Display debug information in object file\n\
201 -e, --debugging-tags Display debug information using ctags style\n\
202 -G, --stabs Display (in raw form) any STABS info in the file\n\
203 -W[lLiaprmfFsoR] or\n\
204 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
205 Display DWARF info in the file\n\
206 -t, --syms Display the contents of the symbol table(s)\n\
207 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
208 -r, --reloc Display the relocation entries in the file\n\
209 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
210 @<file> Read options from <file>\n\
211 -v, --version Display this program's version number\n\
212 -i, --info List object formats and architectures supported\n\
213 -H, --help Display this information\n\
217 fprintf (stream, _("\n The following switches are optional:\n"));
218 fprintf (stream, _("\
219 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
220 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
221 -j, --section=NAME Only display information for section NAME\n\
222 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
223 -EB --endian=big Assume big endian format when disassembling\n\
224 -EL --endian=little Assume little endian format when disassembling\n\
225 --file-start-context Include context from start of file (with -S)\n\
226 -I, --include=DIR Add DIR to search list for source files\n\
227 -l, --line-numbers Include line numbers and filenames in output\n\
228 -F, --file-offsets Include file offsets when displaying information\n\
229 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
230 The STYLE, if specified, can be `auto', `gnu',\n\
231 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
233 -w, --wide Format output for more than 80 columns\n\
234 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
235 --start-address=ADDR Only process data whose address is >= ADDR\n\
236 --stop-address=ADDR Only process data whose address is <= ADDR\n\
237 --prefix-addresses Print complete address alongside disassembly\n\
238 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
239 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
240 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
241 --special-syms Include special symbols in symbol dumps\n\
242 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
243 --prefix-strip=LEVEL Strip initial directory names for -S\n\
245 list_supported_targets (program_name, stream);
246 list_supported_architectures (program_name, stream);
248 disassembler_usage (stream);
250 if (REPORT_BUGS_TO[0] && status == 0)
251 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
255 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
259 OPTION_START_ADDRESS,
268 static struct option long_options[]=
270 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
271 {"all-headers", no_argument, NULL, 'x'},
272 {"private-headers", no_argument, NULL, 'p'},
273 {"architecture", required_argument, NULL, 'm'},
274 {"archive-headers", no_argument, NULL, 'a'},
275 {"debugging", no_argument, NULL, 'g'},
276 {"debugging-tags", no_argument, NULL, 'e'},
277 {"demangle", optional_argument, NULL, 'C'},
278 {"disassemble", no_argument, NULL, 'd'},
279 {"disassemble-all", no_argument, NULL, 'D'},
280 {"disassembler-options", required_argument, NULL, 'M'},
281 {"disassemble-zeroes", no_argument, NULL, 'z'},
282 {"dynamic-reloc", no_argument, NULL, 'R'},
283 {"dynamic-syms", no_argument, NULL, 'T'},
284 {"endian", required_argument, NULL, OPTION_ENDIAN},
285 {"file-headers", no_argument, NULL, 'f'},
286 {"file-offsets", no_argument, NULL, 'F'},
287 {"file-start-context", no_argument, &file_start_context, 1},
288 {"full-contents", no_argument, NULL, 's'},
289 {"headers", no_argument, NULL, 'h'},
290 {"help", no_argument, NULL, 'H'},
291 {"info", no_argument, NULL, 'i'},
292 {"line-numbers", no_argument, NULL, 'l'},
293 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
294 {"prefix-addresses", no_argument, &prefix_addresses, 1},
295 {"reloc", no_argument, NULL, 'r'},
296 {"section", required_argument, NULL, 'j'},
297 {"section-headers", no_argument, NULL, 'h'},
298 {"show-raw-insn", no_argument, &show_raw_insn, 1},
299 {"source", no_argument, NULL, 'S'},
300 {"special-syms", no_argument, &dump_special_syms, 1},
301 {"include", required_argument, NULL, 'I'},
302 {"dwarf", optional_argument, NULL, OPTION_DWARF},
303 {"stabs", no_argument, NULL, 'G'},
304 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
305 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
306 {"syms", no_argument, NULL, 't'},
307 {"target", required_argument, NULL, 'b'},
308 {"version", no_argument, NULL, 'V'},
309 {"wide", no_argument, NULL, 'w'},
310 {"prefix", required_argument, NULL, OPTION_PREFIX},
311 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
312 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
313 {0, no_argument, 0, 0}
317 nonfatal (const char *msg)
323 /* Returns TRUE if the specified section should be dumped. */
326 process_section_p (asection * section)
333 for (i = 0; i < only_used; i++)
334 if (strcmp (only [i], section->name) == 0)
341 dump_section_header (bfd *abfd, asection *section,
342 void *ignored ATTRIBUTE_UNUSED)
345 unsigned int opb = bfd_octets_per_byte (abfd);
347 /* Ignore linker created section. See elfNN_ia64_object_p in
349 if (section->flags & SEC_LINKER_CREATED)
352 /* PR 10413: Skip sections that we are ignoring. */
353 if (! process_section_p (section))
356 printf ("%3d %-13s %08lx ", section->index,
357 bfd_get_section_name (abfd, section),
358 (unsigned long) bfd_section_size (abfd, section) / opb);
359 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
361 bfd_printf_vma (abfd, section->lma);
362 printf (" %08lx 2**%u", (unsigned long) section->filepos,
363 bfd_get_section_alignment (abfd, section));
369 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
371 PF (SEC_HAS_CONTENTS, "CONTENTS");
372 PF (SEC_ALLOC, "ALLOC");
373 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
374 PF (SEC_LOAD, "LOAD");
375 PF (SEC_RELOC, "RELOC");
376 PF (SEC_READONLY, "READONLY");
377 PF (SEC_CODE, "CODE");
378 PF (SEC_DATA, "DATA");
380 PF (SEC_DEBUGGING, "DEBUGGING");
381 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
382 PF (SEC_EXCLUDE, "EXCLUDE");
383 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
384 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
386 PF (SEC_TIC54X_BLOCK, "BLOCK");
387 PF (SEC_TIC54X_CLINK, "CLINK");
389 PF (SEC_SMALL_DATA, "SMALL_DATA");
390 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
391 PF (SEC_COFF_SHARED, "SHARED");
392 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
393 PF (SEC_GROUP, "GROUP");
395 if ((section->flags & SEC_LINK_ONCE) != 0)
398 struct coff_comdat_info *comdat;
400 switch (section->flags & SEC_LINK_DUPLICATES)
404 case SEC_LINK_DUPLICATES_DISCARD:
405 ls = "LINK_ONCE_DISCARD";
407 case SEC_LINK_DUPLICATES_ONE_ONLY:
408 ls = "LINK_ONCE_ONE_ONLY";
410 case SEC_LINK_DUPLICATES_SAME_SIZE:
411 ls = "LINK_ONCE_SAME_SIZE";
413 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
414 ls = "LINK_ONCE_SAME_CONTENTS";
417 printf ("%s%s", comma, ls);
419 comdat = bfd_coff_get_comdat_section (abfd, section);
421 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
431 dump_headers (bfd *abfd)
433 printf (_("Sections:\n"));
436 printf (_("Idx Name Size VMA LMA File off Algn"));
438 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
439 if (bfd_get_arch_size (abfd) == 32)
440 printf (_("Idx Name Size VMA LMA File off Algn"));
442 printf (_("Idx Name Size VMA LMA File off Algn"));
446 printf (_(" Flags"));
447 if (abfd->flags & HAS_LOAD_PAGE)
451 bfd_map_over_sections (abfd, dump_section_header, NULL);
455 slurp_symtab (bfd *abfd)
460 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
466 storage = bfd_get_symtab_upper_bound (abfd);
468 bfd_fatal (bfd_get_filename (abfd));
470 sy = (asymbol **) xmalloc (storage);
472 symcount = bfd_canonicalize_symtab (abfd, sy);
474 bfd_fatal (bfd_get_filename (abfd));
478 /* Read in the dynamic symbols. */
481 slurp_dynamic_symtab (bfd *abfd)
486 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
489 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
491 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
496 bfd_fatal (bfd_get_filename (abfd));
499 sy = (asymbol **) xmalloc (storage);
501 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
503 bfd_fatal (bfd_get_filename (abfd));
507 /* Filter out (in place) symbols that are useless for disassembly.
508 COUNT is the number of elements in SYMBOLS.
509 Return the number of useful symbols. */
512 remove_useless_symbols (asymbol **symbols, long count)
514 asymbol **in_ptr = symbols, **out_ptr = symbols;
518 asymbol *sym = *in_ptr++;
520 if (sym->name == NULL || sym->name[0] == '\0')
522 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
524 if (bfd_is_und_section (sym->section)
525 || bfd_is_com_section (sym->section))
530 return out_ptr - symbols;
533 /* Sort symbols into value order. */
536 compare_symbols (const void *ap, const void *bp)
538 const asymbol *a = * (const asymbol **) ap;
539 const asymbol *b = * (const asymbol **) bp;
549 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
551 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
554 if (a->section > b->section)
556 else if (a->section < b->section)
559 an = bfd_asymbol_name (a);
560 bn = bfd_asymbol_name (b);
564 /* The symbols gnu_compiled and gcc2_compiled convey no real
565 information, so put them after other symbols with the same value. */
566 af = (strstr (an, "gnu_compiled") != NULL
567 || strstr (an, "gcc2_compiled") != NULL);
568 bf = (strstr (bn, "gnu_compiled") != NULL
569 || strstr (bn, "gcc2_compiled") != NULL);
576 /* We use a heuristic for the file name, to try to sort it after
577 more useful symbols. It may not work on non Unix systems, but it
578 doesn't really matter; the only difference is precisely which
579 symbol names get printed. */
581 #define file_symbol(s, sn, snl) \
582 (((s)->flags & BSF_FILE) != 0 \
583 || ((sn)[(snl) - 2] == '.' \
584 && ((sn)[(snl) - 1] == 'o' \
585 || (sn)[(snl) - 1] == 'a')))
587 af = file_symbol (a, an, anl);
588 bf = file_symbol (b, bn, bnl);
595 /* Try to sort global symbols before local symbols before function
596 symbols before debugging symbols. */
601 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
603 if ((aflags & BSF_DEBUGGING) != 0)
608 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
610 if ((aflags & BSF_FUNCTION) != 0)
615 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
617 if ((aflags & BSF_LOCAL) != 0)
622 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
624 if ((aflags & BSF_GLOBAL) != 0)
630 /* Symbols that start with '.' might be section names, so sort them
631 after symbols that don't start with '.'. */
632 if (an[0] == '.' && bn[0] != '.')
634 if (an[0] != '.' && bn[0] == '.')
637 /* Finally, if we can't distinguish them in any other way, try to
638 get consistent results by sorting the symbols by name. */
639 return strcmp (an, bn);
642 /* Sort relocs into address order. */
645 compare_relocs (const void *ap, const void *bp)
647 const arelent *a = * (const arelent **) ap;
648 const arelent *b = * (const arelent **) bp;
650 if (a->address > b->address)
652 else if (a->address < b->address)
655 /* So that associated relocations tied to the same address show up
656 in the correct order, we don't do any further sorting. */
665 /* Print an address (VMA) to the output stream in INFO.
666 If SKIP_ZEROES is TRUE, omit leading zeroes. */
669 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
670 bfd_boolean skip_zeroes)
674 struct objdump_disasm_info *aux;
676 aux = (struct objdump_disasm_info *) info->application_data;
677 bfd_sprintf_vma (aux->abfd, buf, vma);
682 for (p = buf; *p == '0'; ++p)
687 (*info->fprintf_func) (info->stream, "%s", p);
690 /* Print the name of a symbol. */
693 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
700 name = bfd_asymbol_name (sym);
701 if (do_demangle && name[0] != '\0')
703 /* Demangle the name. */
704 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
710 (*info->fprintf_func) (info->stream, "%s", name);
718 /* Locate a symbol given a bfd and a section (from INFO->application_data),
719 and a VMA. If INFO->application_data->require_sec is TRUE, then always
720 require the symbol to be in the section. Returns NULL if there is no
721 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
722 of the symbol in sorted_syms. */
725 find_symbol_for_address (bfd_vma vma,
726 struct disassemble_info *info,
729 /* @@ Would it speed things up to cache the last two symbols returned,
730 and maybe their address ranges? For many processors, only one memory
731 operand can be present at a time, so the 2-entry cache wouldn't be
732 constantly churned by code doing heavy memory accesses. */
734 /* Indices in `sorted_syms'. */
736 long max = sorted_symcount;
738 struct objdump_disasm_info *aux;
742 bfd_boolean want_section;
744 if (sorted_symcount < 1)
747 aux = (struct objdump_disasm_info *) info->application_data;
750 opb = info->octets_per_byte;
752 /* Perform a binary search looking for the closest symbol to the
753 required value. We are searching the range (min, max]. */
754 while (min + 1 < max)
758 thisplace = (max + min) / 2;
759 sym = sorted_syms[thisplace];
761 if (bfd_asymbol_value (sym) > vma)
763 else if (bfd_asymbol_value (sym) < vma)
772 /* The symbol we want is now in min, the low end of the range we
773 were searching. If there are several symbols with the same
774 value, we want the first one. */
777 && (bfd_asymbol_value (sorted_syms[thisplace])
778 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
781 /* Prefer a symbol in the current section if we have multple symbols
782 with the same value, as can occur with overlays or zero size
786 && (bfd_asymbol_value (sorted_syms[min])
787 == bfd_asymbol_value (sorted_syms[thisplace])))
789 if (sorted_syms[min]->section == sec
790 && info->symbol_is_valid (sorted_syms[min], info))
797 return sorted_syms[thisplace];
802 /* If the file is relocatable, and the symbol could be from this
803 section, prefer a symbol from this section over symbols from
804 others, even if the other symbol's value might be closer.
806 Note that this may be wrong for some symbol references if the
807 sections have overlapping memory ranges, but in that case there's
808 no way to tell what's desired without looking at the relocation
811 Also give the target a chance to reject symbols. */
812 want_section = (aux->require_sec
813 || ((abfd->flags & HAS_RELOC) != 0
814 && vma >= bfd_get_section_vma (abfd, sec)
815 && vma < (bfd_get_section_vma (abfd, sec)
816 + bfd_section_size (abfd, sec) / opb)));
817 if ((sorted_syms[thisplace]->section != sec && want_section)
818 || !info->symbol_is_valid (sorted_syms[thisplace], info))
821 long newplace = sorted_symcount;
823 for (i = min - 1; i >= 0; i--)
825 if ((sorted_syms[i]->section == sec || !want_section)
826 && info->symbol_is_valid (sorted_syms[i], info))
828 if (newplace == sorted_symcount)
831 if (bfd_asymbol_value (sorted_syms[i])
832 != bfd_asymbol_value (sorted_syms[newplace]))
835 /* Remember this symbol and keep searching until we reach
836 an earlier address. */
841 if (newplace != sorted_symcount)
842 thisplace = newplace;
845 /* We didn't find a good symbol with a smaller value.
846 Look for one with a larger value. */
847 for (i = thisplace + 1; i < sorted_symcount; i++)
849 if ((sorted_syms[i]->section == sec || !want_section)
850 && info->symbol_is_valid (sorted_syms[i], info))
858 if ((sorted_syms[thisplace]->section != sec && want_section)
859 || !info->symbol_is_valid (sorted_syms[thisplace], info))
860 /* There is no suitable symbol. */
867 return sorted_syms[thisplace];
870 /* Print an address and the offset to the nearest symbol. */
873 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
874 bfd_vma vma, struct disassemble_info *info,
875 bfd_boolean skip_zeroes)
877 objdump_print_value (vma, info, skip_zeroes);
883 (*info->fprintf_func) (info->stream, " <%s",
884 bfd_get_section_name (abfd, sec));
885 secaddr = bfd_get_section_vma (abfd, sec);
888 (*info->fprintf_func) (info->stream, "-0x");
889 objdump_print_value (secaddr - vma, info, TRUE);
891 else if (vma > secaddr)
893 (*info->fprintf_func) (info->stream, "+0x");
894 objdump_print_value (vma - secaddr, info, TRUE);
896 (*info->fprintf_func) (info->stream, ">");
900 (*info->fprintf_func) (info->stream, " <");
901 objdump_print_symname (abfd, info, sym);
902 if (bfd_asymbol_value (sym) > vma)
904 (*info->fprintf_func) (info->stream, "-0x");
905 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
907 else if (vma > bfd_asymbol_value (sym))
909 (*info->fprintf_func) (info->stream, "+0x");
910 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
912 (*info->fprintf_func) (info->stream, ">");
915 if (display_file_offsets)
916 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
917 (long int)(sec->filepos + (vma - sec->vma)));
920 /* Print an address (VMA), symbolically if possible.
921 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
924 objdump_print_addr (bfd_vma vma,
925 struct disassemble_info *info,
926 bfd_boolean skip_zeroes)
928 struct objdump_disasm_info *aux;
930 bfd_boolean skip_find = FALSE;
932 aux = (struct objdump_disasm_info *) info->application_data;
934 if (sorted_symcount < 1)
936 (*info->fprintf_func) (info->stream, "0x");
937 objdump_print_value (vma, info, skip_zeroes);
939 if (display_file_offsets)
940 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
941 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
945 if (aux->reloc != NULL
946 && aux->reloc->sym_ptr_ptr != NULL
947 && * aux->reloc->sym_ptr_ptr != NULL)
949 sym = * aux->reloc->sym_ptr_ptr;
951 /* Adjust the vma to the reloc. */
952 vma += bfd_asymbol_value (sym);
954 if (bfd_is_und_section (bfd_get_section (sym)))
959 sym = find_symbol_for_address (vma, info, NULL);
961 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
965 /* Print VMA to INFO. This function is passed to the disassembler
969 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
971 objdump_print_addr (vma, info, ! prefix_addresses);
974 /* Determine if the given address has a symbol associated with it. */
977 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
981 sym = find_symbol_for_address (vma, info, NULL);
983 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
986 /* Hold the last function name and the last line number we displayed
989 static char *prev_functionname;
990 static unsigned int prev_line;
992 /* We keep a list of all files that we have seen when doing a
993 disassembly with source, so that we know how much of the file to
994 display. This can be important for inlined functions. */
996 struct print_file_list
998 struct print_file_list *next;
999 const char *filename;
1000 const char *modname;
1003 const char **linemap;
1009 static struct print_file_list *print_files;
1011 /* The number of preceding context lines to show when we start
1012 displaying a file for the first time. */
1014 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1016 /* Read a complete file into memory. */
1019 slurp_file (const char *fn, size_t *size)
1022 int ps = getpagesize ();
1027 int fd = open (fn, O_RDONLY | O_BINARY);
1031 if (fstat (fd, &st) < 0)
1035 msize = (*size + ps - 1) & ~(ps - 1);
1036 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1037 if (map != (char *)-1L)
1043 map = (const char *) malloc (*size);
1044 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1053 #define line_map_decrease 5
1055 /* Precompute array of lines for a mapped file. */
1057 static const char **
1058 index_file (const char *map, size_t size, unsigned int *maxline)
1060 const char *p, *lstart, *end;
1061 int chars_per_line = 45; /* First iteration will use 40. */
1062 unsigned int lineno;
1063 const char **linemap = NULL;
1064 unsigned long line_map_size = 0;
1070 for (p = map; p < end; p++)
1074 if (p + 1 < end && p[1] == '\r')
1077 else if (*p == '\r')
1079 if (p + 1 < end && p[1] == '\n')
1085 /* End of line found. */
1087 if (linemap == NULL || line_map_size < lineno + 1)
1089 unsigned long newsize;
1091 chars_per_line -= line_map_decrease;
1092 if (chars_per_line <= 1)
1094 line_map_size = size / chars_per_line + 1;
1095 if (line_map_size < lineno + 1)
1096 line_map_size = lineno + 1;
1097 newsize = line_map_size * sizeof (char *);
1098 linemap = (const char **) xrealloc (linemap, newsize);
1101 linemap[lineno++] = lstart;
1109 /* Tries to open MODNAME, and if successful adds a node to print_files
1110 linked list and returns that node. Returns NULL on failure. */
1112 static struct print_file_list *
1113 try_print_file_open (const char *origname, const char *modname)
1115 struct print_file_list *p;
1117 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1119 p->map = slurp_file (modname, &p->mapsize);
1126 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1128 p->filename = origname;
1129 p->modname = modname;
1130 p->next = print_files;
1136 /* If the the source file, as described in the symtab, is not found
1137 try to locate it in one of the paths specified with -I
1138 If found, add location to print_files linked list. */
1140 static struct print_file_list *
1141 update_source_path (const char *filename)
1143 struct print_file_list *p;
1147 if (filename == NULL)
1150 p = try_print_file_open (filename, filename);
1154 if (include_path_count == 0)
1157 /* Get the name of the file. */
1158 fname = strrchr (filename, '/');
1159 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1161 /* We could have a mixed forward/back slash case. */
1162 char *backslash = strrchr (filename, '\\');
1163 if (fname == NULL || (backslash != NULL && backslash > fname))
1165 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
1166 fname = filename + 1;
1174 /* If file exists under a new path, we need to add it to the list
1175 so that show_line knows about it. */
1176 for (i = 0; i < include_path_count; i++)
1178 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1180 p = try_print_file_open (filename, modname);
1190 /* Print a source file line. */
1193 print_line (struct print_file_list *p, unsigned int line)
1199 if (line >= p->maxline)
1201 l = p->linemap [line];
1202 /* Test fwrite return value to quiet glibc warning. */
1203 len = strcspn (l, "\n\r");
1204 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1208 /* Print a range of source code lines. */
1211 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1215 while (start <= end)
1217 print_line (p, start);
1222 /* Show the line number, or the source line, in a disassembly
1226 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1228 const char *filename;
1229 const char *functionname;
1233 if (! with_line_numbers && ! with_source_code)
1236 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1237 &functionname, &line))
1240 if (filename != NULL && *filename == '\0')
1242 if (functionname != NULL && *functionname == '\0')
1243 functionname = NULL;
1246 && IS_ABSOLUTE_PATH (filename)
1250 const char *fname = filename;
1251 char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1254 memcpy (path, prefix, prefix_length);
1255 path_up = path + prefix_length;
1257 /* Build relocated filename, stripping off leading directories
1258 from the initial filename if requested. */
1259 if (prefix_strip > 0)
1264 /* Skip selected directory levels. */
1265 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1266 if (IS_DIR_SEPARATOR(*s))
1273 /* Update complete filename. */
1274 strncpy (path_up, fname, PATH_MAX);
1275 path_up[PATH_MAX] = '\0';
1283 if (with_line_numbers)
1285 if (functionname != NULL
1286 && (prev_functionname == NULL
1287 || strcmp (functionname, prev_functionname) != 0))
1288 printf ("%s():\n", functionname);
1289 if (line > 0 && line != prev_line)
1290 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1293 if (with_source_code
1297 struct print_file_list **pp, *p;
1300 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1301 if (strcmp ((*pp)->filename, filename) == 0)
1308 filename = xstrdup (filename);
1309 p = update_source_path (filename);
1312 if (p != NULL && line != p->last_line)
1314 if (file_start_context && p->first)
1318 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1321 if (p->last_line >= l && p->last_line <= line)
1322 l = p->last_line + 1;
1324 dump_lines (p, l, line);
1325 p->last_line = line;
1330 if (functionname != NULL
1331 && (prev_functionname == NULL
1332 || strcmp (functionname, prev_functionname) != 0))
1334 if (prev_functionname != NULL)
1335 free (prev_functionname);
1336 prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1337 strcpy (prev_functionname, functionname);
1340 if (line > 0 && line != prev_line)
1344 /* Pseudo FILE object for strings. */
1352 /* sprintf to a "stream". */
1354 static int ATTRIBUTE_PRINTF_2
1355 objdump_sprintf (SFILE *f, const char *format, ...)
1362 size_t space = f->alloc - f->pos;
1364 va_start (args, format);
1365 n = vsnprintf (f->buffer + f->pos, space, format, args);
1371 f->alloc = (f->alloc + n) * 2;
1372 f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1379 /* The number of zeroes we want to see before we start skipping them.
1380 The number is arbitrarily chosen. */
1382 #define DEFAULT_SKIP_ZEROES 8
1384 /* The number of zeroes to skip at the end of a section. If the
1385 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1386 SKIP_ZEROES, they will be disassembled. If there are fewer than
1387 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1388 attempt to avoid disassembling zeroes inserted by section
1391 #define DEFAULT_SKIP_ZEROES_AT_END 3
1393 /* Disassemble some data in memory between given values. */
1396 disassemble_bytes (struct disassemble_info * info,
1397 disassembler_ftype disassemble_fn,
1400 bfd_vma start_offset,
1401 bfd_vma stop_offset,
1404 arelent ** relppend)
1406 struct objdump_disasm_info *aux;
1408 int octets_per_line;
1409 bfd_boolean done_dot;
1410 int skip_addr_chars;
1411 bfd_vma addr_offset;
1412 unsigned int opb = info->octets_per_byte;
1413 unsigned int skip_zeroes = info->skip_zeroes;
1414 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1418 aux = (struct objdump_disasm_info *) info->application_data;
1422 sfile.buffer = (char *) xmalloc (sfile.alloc);
1426 octets_per_line = insn_width;
1428 octets_per_line = 4;
1430 octets_per_line = 16;
1432 /* Figure out how many characters to skip at the start of an
1433 address, to make the disassembly look nicer. We discard leading
1434 zeroes in chunks of 4, ensuring that there is always a leading
1436 skip_addr_chars = 0;
1437 if (! prefix_addresses)
1441 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1443 while (buf[skip_addr_chars] == '0')
1446 /* Don't discard zeros on overflow. */
1447 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1448 skip_addr_chars = 0;
1450 if (skip_addr_chars != 0)
1451 skip_addr_chars = (skip_addr_chars - 1) & -4;
1454 info->insn_info_valid = 0;
1457 addr_offset = start_offset;
1458 while (addr_offset < stop_offset)
1461 bfd_boolean need_nl = FALSE;
1462 int previous_octets;
1464 /* Remember the length of the previous instruction. */
1465 previous_octets = octets;
1468 /* Make sure we don't use relocs from previous instructions. */
1471 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1473 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1476 if (! disassemble_zeroes
1477 && (info->insn_info_valid == 0
1478 || info->branch_delay_insns == 0)
1479 && (z - addr_offset * opb >= skip_zeroes
1480 || (z == stop_offset * opb &&
1481 z - addr_offset * opb < skip_zeroes_at_end)))
1483 /* If there are more nonzero octets to follow, we only skip
1484 zeroes in multiples of 4, to try to avoid running over
1485 the start of an instruction which happens to start with
1487 if (z != stop_offset * opb)
1488 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1490 octets = z - addr_offset * opb;
1492 /* If we are going to display more data, and we are displaying
1493 file offsets, then tell the user how many zeroes we skip
1494 and the file offset from where we resume dumping. */
1495 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1496 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1498 (unsigned long) (section->filepos
1499 + (addr_offset + (octets / opb))));
1511 if (with_line_numbers || with_source_code)
1512 show_line (aux->abfd, section, addr_offset);
1514 if (! prefix_addresses)
1518 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1519 for (s = buf + skip_addr_chars; *s == '0'; s++)
1523 printf ("%s:\t", buf + skip_addr_chars);
1527 aux->require_sec = TRUE;
1528 objdump_print_address (section->vma + addr_offset, info);
1529 aux->require_sec = FALSE;
1536 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1537 info->stream = &sfile;
1538 info->bytes_per_line = 0;
1539 info->bytes_per_chunk = 0;
1540 info->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1542 info->flags |= USER_SPECIFIED_MACHINE_TYPE;
1544 if (info->disassembler_needs_relocs
1545 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1546 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1547 && *relppp < relppend)
1549 bfd_signed_vma distance_to_rel;
1551 distance_to_rel = (**relppp)->address
1552 - (rel_offset + addr_offset);
1554 /* Check to see if the current reloc is associated with
1555 the instruction that we are about to disassemble. */
1556 if (distance_to_rel == 0
1557 /* FIXME: This is wrong. We are trying to catch
1558 relocs that are addressed part way through the
1559 current instruction, as might happen with a packed
1560 VLIW instruction. Unfortunately we do not know the
1561 length of the current instruction since we have not
1562 disassembled it yet. Instead we take a guess based
1563 upon the length of the previous instruction. The
1564 proper solution is to have a new target-specific
1565 disassembler function which just returns the length
1566 of an instruction at a given address without trying
1567 to display its disassembly. */
1568 || (distance_to_rel > 0
1569 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1571 info->flags |= INSN_HAS_RELOC;
1572 aux->reloc = **relppp;
1576 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1577 info->fprintf_func = (fprintf_ftype) fprintf;
1578 info->stream = stdout;
1579 if (insn_width == 0 && info->bytes_per_line != 0)
1580 octets_per_line = info->bytes_per_line;
1584 printf ("%s\n", sfile.buffer);
1592 octets = octets_per_line;
1593 if (addr_offset + octets / opb > stop_offset)
1594 octets = (stop_offset - addr_offset) * opb;
1596 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1598 if (ISPRINT (data[j]))
1599 buf[j - addr_offset * opb] = data[j];
1601 buf[j - addr_offset * opb] = '.';
1603 buf[j - addr_offset * opb] = '\0';
1606 if (prefix_addresses
1608 : show_raw_insn >= 0)
1612 /* If ! prefix_addresses and ! wide_output, we print
1613 octets_per_line octets per line. */
1615 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1616 pb = octets_per_line;
1618 if (info->bytes_per_chunk)
1619 bpc = info->bytes_per_chunk;
1623 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1627 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1629 for (k = bpc - 1; k >= 0; k--)
1630 printf ("%02x", (unsigned) data[j + k]);
1635 for (k = 0; k < bpc; k++)
1636 printf ("%02x", (unsigned) data[j + k]);
1641 for (; pb < octets_per_line; pb += bpc)
1645 for (k = 0; k < bpc; k++)
1650 /* Separate raw data from instruction by extra space. */
1660 printf ("%s", sfile.buffer);
1662 if (prefix_addresses
1664 : show_raw_insn >= 0)
1672 j = addr_offset * opb + pb;
1674 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1675 for (s = buf + skip_addr_chars; *s == '0'; s++)
1679 printf ("%s:\t", buf + skip_addr_chars);
1681 pb += octets_per_line;
1684 for (; j < addr_offset * opb + pb; j += bpc)
1688 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1690 for (k = bpc - 1; k >= 0; k--)
1691 printf ("%02x", (unsigned) data[j + k]);
1696 for (k = 0; k < bpc; k++)
1697 printf ("%02x", (unsigned) data[j + k]);
1710 while ((*relppp) < relppend
1711 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1713 if (dump_reloc_info || dump_dynamic_reloc_info)
1724 objdump_print_value (section->vma - rel_offset + q->address,
1727 if (q->howto == NULL)
1728 printf (": *unknown*\t");
1729 else if (q->howto->name)
1730 printf (": %s\t", q->howto->name);
1732 printf (": %d\t", q->howto->type);
1734 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1735 printf ("*unknown*");
1738 const char *sym_name;
1740 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1741 if (sym_name != NULL && *sym_name != '\0')
1742 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1747 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1748 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1749 if (sym_name == NULL || *sym_name == '\0')
1750 sym_name = "*unknown*";
1751 printf ("%s", sym_name);
1758 objdump_print_value (q->addend, info, TRUE);
1770 addr_offset += octets / opb;
1773 free (sfile.buffer);
1777 disassemble_section (bfd *abfd, asection *section, void *info)
1779 const struct elf_backend_data * bed;
1780 bfd_vma sign_adjust = 0;
1781 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1782 struct objdump_disasm_info * paux;
1783 unsigned int opb = pinfo->octets_per_byte;
1784 bfd_byte * data = NULL;
1785 bfd_size_type datasize = 0;
1786 arelent ** rel_pp = NULL;
1787 arelent ** rel_ppstart = NULL;
1788 arelent ** rel_ppend;
1789 unsigned long stop_offset;
1790 asymbol * sym = NULL;
1794 unsigned long addr_offset;
1796 /* Sections that do not contain machine
1797 code are not normally disassembled. */
1798 if (! disassemble_all
1800 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1801 != (SEC_CODE | SEC_HAS_CONTENTS)))
1804 if (! process_section_p (section))
1807 datasize = bfd_get_section_size (section);
1811 /* Decide which set of relocs to use. Load them if necessary. */
1812 paux = (struct objdump_disasm_info *) pinfo->application_data;
1813 if (paux->dynrelbuf)
1815 rel_pp = paux->dynrelbuf;
1816 rel_count = paux->dynrelcount;
1817 /* Dynamic reloc addresses are absolute, non-dynamic are section
1818 relative. REL_OFFSET specifies the reloc address corresponding
1819 to the start of this section. */
1820 rel_offset = section->vma;
1828 if ((section->flags & SEC_RELOC) != 0
1829 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1833 relsize = bfd_get_reloc_upper_bound (abfd, section);
1835 bfd_fatal (bfd_get_filename (abfd));
1839 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1840 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1842 bfd_fatal (bfd_get_filename (abfd));
1844 /* Sort the relocs by address. */
1845 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1849 rel_ppend = rel_pp + rel_count;
1851 data = (bfd_byte *) xmalloc (datasize);
1853 bfd_get_section_contents (abfd, section, data, 0, datasize);
1855 paux->sec = section;
1856 pinfo->buffer = data;
1857 pinfo->buffer_vma = section->vma;
1858 pinfo->buffer_length = datasize;
1859 pinfo->section = section;
1861 if (start_address == (bfd_vma) -1
1862 || start_address < pinfo->buffer_vma)
1865 addr_offset = start_address - pinfo->buffer_vma;
1867 if (stop_address == (bfd_vma) -1)
1868 stop_offset = datasize / opb;
1871 if (stop_address < pinfo->buffer_vma)
1874 stop_offset = stop_address - pinfo->buffer_vma;
1875 if (stop_offset > pinfo->buffer_length / opb)
1876 stop_offset = pinfo->buffer_length / opb;
1879 /* Skip over the relocs belonging to addresses below the
1881 while (rel_pp < rel_ppend
1882 && (*rel_pp)->address < rel_offset + addr_offset)
1885 if (addr_offset < stop_offset)
1886 printf (_("\nDisassembly of section %s:\n"), section->name);
1888 /* Find the nearest symbol forwards from our current position. */
1889 paux->require_sec = TRUE;
1890 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
1891 (struct disassemble_info *) info,
1893 paux->require_sec = FALSE;
1895 /* PR 9774: If the target used signed addresses then we must make
1896 sure that we sign extend the value that we calculate for 'addr'
1897 in the loop below. */
1898 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1899 && (bed = get_elf_backend_data (abfd)) != NULL
1900 && bed->sign_extend_vma)
1901 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1903 /* Disassemble a block of instructions up to the address associated with
1904 the symbol we have just found. Then print the symbol and find the
1905 next symbol on. Repeat until we have disassembled the entire section
1906 or we have reached the end of the address range we are interested in. */
1907 while (addr_offset < stop_offset)
1911 unsigned long nextstop_offset;
1914 addr = section->vma + addr_offset;
1915 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
1917 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1922 (x < sorted_symcount
1923 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1927 pinfo->symbols = sorted_syms + place;
1928 pinfo->num_symbols = x - place;
1929 pinfo->symtab_pos = place;
1933 pinfo->symbols = NULL;
1934 pinfo->num_symbols = 0;
1935 pinfo->symtab_pos = -1;
1938 if (! prefix_addresses)
1940 pinfo->fprintf_func (pinfo->stream, "\n");
1941 objdump_print_addr_with_sym (abfd, section, sym, addr,
1943 pinfo->fprintf_func (pinfo->stream, ":\n");
1946 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1948 else if (sym == NULL)
1952 #define is_valid_next_sym(SYM) \
1953 ((SYM)->section == section \
1954 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1955 && pinfo->symbol_is_valid (SYM, pinfo))
1957 /* Search forward for the next appropriate symbol in
1958 SECTION. Note that all the symbols are sorted
1959 together into one big array, and that some sections
1960 may have overlapping addresses. */
1961 while (place < sorted_symcount
1962 && ! is_valid_next_sym (sorted_syms [place]))
1965 if (place >= sorted_symcount)
1968 nextsym = sorted_syms[place];
1971 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1972 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1973 else if (nextsym == NULL)
1974 nextstop_offset = stop_offset;
1976 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1978 if (nextstop_offset > stop_offset
1979 || nextstop_offset <= addr_offset)
1980 nextstop_offset = stop_offset;
1982 /* If a symbol is explicitly marked as being an object
1983 rather than a function, just dump the bytes without
1984 disassembling them. */
1987 || sym->section != section
1988 || bfd_asymbol_value (sym) > addr
1989 || ((sym->flags & BSF_OBJECT) == 0
1990 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1992 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1994 || (sym->flags & BSF_FUNCTION) != 0)
1999 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2000 addr_offset, nextstop_offset,
2001 rel_offset, &rel_pp, rel_ppend);
2003 addr_offset = nextstop_offset;
2009 if (rel_ppstart != NULL)
2013 /* Disassemble the contents of an object file. */
2016 disassemble_data (bfd *abfd)
2018 struct disassemble_info disasm_info;
2019 struct objdump_disasm_info aux;
2023 prev_functionname = NULL;
2026 /* We make a copy of syms to sort. We don't want to sort syms
2027 because that will screw up the relocs. */
2028 sorted_symcount = symcount ? symcount : dynsymcount;
2029 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2030 * sizeof (asymbol *));
2031 memcpy (sorted_syms, symcount ? syms : dynsyms,
2032 sorted_symcount * sizeof (asymbol *));
2034 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2036 for (i = 0; i < synthcount; ++i)
2038 sorted_syms[sorted_symcount] = synthsyms + i;
2042 /* Sort the symbols into section and symbol order. */
2043 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2045 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2047 disasm_info.application_data = (void *) &aux;
2049 aux.require_sec = FALSE;
2050 aux.dynrelbuf = NULL;
2051 aux.dynrelcount = 0;
2054 disasm_info.print_address_func = objdump_print_address;
2055 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2057 if (machine != NULL)
2059 const bfd_arch_info_type *info = bfd_scan_arch (machine);
2062 fatal (_("Can't use supplied machine %s"), machine);
2064 abfd->arch_info = info;
2067 if (endian != BFD_ENDIAN_UNKNOWN)
2069 struct bfd_target *xvec;
2071 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2072 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2073 xvec->byteorder = endian;
2077 /* Use libopcodes to locate a suitable disassembler. */
2078 aux.disassemble_fn = disassembler (abfd);
2079 if (!aux.disassemble_fn)
2081 non_fatal (_("Can't disassemble for architecture %s\n"),
2082 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2087 disasm_info.flavour = bfd_get_flavour (abfd);
2088 disasm_info.arch = bfd_get_arch (abfd);
2089 disasm_info.mach = bfd_get_mach (abfd);
2090 disasm_info.disassembler_options = disassembler_options;
2091 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2092 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2093 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2094 disasm_info.disassembler_needs_relocs = FALSE;
2096 if (bfd_big_endian (abfd))
2097 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2098 else if (bfd_little_endian (abfd))
2099 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2101 /* ??? Aborting here seems too drastic. We could default to big or little
2103 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2105 /* Allow the target to customize the info structure. */
2106 disassemble_init_for_target (& disasm_info);
2108 /* Pre-load the dynamic relocs if we are going
2109 to be dumping them along with the disassembly. */
2110 if (dump_dynamic_reloc_info)
2112 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2115 bfd_fatal (bfd_get_filename (abfd));
2119 aux.dynrelbuf = (arelent **) xmalloc (relsize);
2120 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2123 if (aux.dynrelcount < 0)
2124 bfd_fatal (bfd_get_filename (abfd));
2126 /* Sort the relocs by address. */
2127 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2131 disasm_info.symtab = sorted_syms;
2132 disasm_info.symtab_size = sorted_symcount;
2134 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2136 if (aux.dynrelbuf != NULL)
2137 free (aux.dynrelbuf);
2142 load_specific_debug_section (enum dwarf_section_display_enum debug,
2143 asection *sec, void *file)
2145 struct dwarf_section *section = &debug_displays [debug].section;
2146 bfd *abfd = (bfd *) file;
2148 int section_is_compressed;
2150 /* If it is already loaded, do nothing. */
2151 if (section->start != NULL)
2154 section_is_compressed = section->name == section->compressed_name;
2156 section->address = 0;
2157 section->size = bfd_get_section_size (sec);
2158 section->start = (unsigned char *) xmalloc (section->size);
2160 if (is_relocatable && debug_displays [debug].relocate)
2161 ret = bfd_simple_get_relocated_section_contents (abfd,
2166 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2171 free_debug_section (debug);
2172 printf (_("\nCan't get contents for section '%s'.\n"),
2177 if (section_is_compressed)
2179 bfd_size_type size = section->size;
2180 if (! bfd_uncompress_section_contents (§ion->start, &size))
2182 free_debug_section (debug);
2183 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2186 section->size = size;
2193 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2195 struct dwarf_section *section = &debug_displays [debug].section;
2196 bfd *abfd = (bfd *) file;
2199 /* If it is already loaded, do nothing. */
2200 if (section->start != NULL)
2203 /* Locate the debug section. */
2204 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2206 section->name = section->uncompressed_name;
2209 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2211 section->name = section->compressed_name;
2216 return load_specific_debug_section (debug, sec, file);
2220 free_debug_section (enum dwarf_section_display_enum debug)
2222 struct dwarf_section *section = &debug_displays [debug].section;
2224 if (section->start == NULL)
2227 free ((char *) section->start);
2228 section->start = NULL;
2229 section->address = 0;
2234 dump_dwarf_section (bfd *abfd, asection *section,
2235 void *arg ATTRIBUTE_UNUSED)
2237 const char *name = bfd_get_section_name (abfd, section);
2241 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2242 match = ".debug_info";
2246 for (i = 0; i < max; i++)
2247 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2248 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2249 && debug_displays [i].enabled != NULL
2250 && *debug_displays [i].enabled)
2252 struct dwarf_section *sec = &debug_displays [i].section;
2254 if (strcmp (sec->uncompressed_name, match) == 0)
2255 sec->name = sec->uncompressed_name;
2257 sec->name = sec->compressed_name;
2258 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2261 debug_displays [i].display (sec, abfd);
2263 if (i != info && i != abbrev)
2264 free_debug_section ((enum dwarf_section_display_enum) i);
2270 /* Dump the dwarf debugging information. */
2273 dump_dwarf (bfd *abfd)
2275 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2277 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2278 targets will return 64. */
2279 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2281 if (bfd_big_endian (abfd))
2282 byte_get = byte_get_big_endian;
2283 else if (bfd_little_endian (abfd))
2284 byte_get = byte_get_little_endian;
2288 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2290 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2291 init_dwarf_regnames (bed->elf_machine_code);
2294 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2296 free_debug_memory ();
2299 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2300 it. Return NULL on failure. */
2303 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2309 stabsect = bfd_get_section_by_name (abfd, sect_name);
2310 if (stabsect == NULL)
2312 printf (_("No %s section present\n\n"), sect_name);
2316 size = bfd_section_size (abfd, stabsect);
2317 contents = (char *) xmalloc (size);
2319 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2321 non_fatal (_("Reading %s section of %s failed: %s"),
2322 sect_name, bfd_get_filename (abfd),
2323 bfd_errmsg (bfd_get_error ()));
2334 /* Stabs entries use a 12 byte format:
2335 4 byte string table index
2337 1 byte stab other field
2338 2 byte stab desc field
2340 FIXME: This will have to change for a 64 bit object format. */
2342 #define STRDXOFF (0)
2344 #define OTHEROFF (5)
2347 #define STABSIZE (12)
2349 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2350 using string table section STRSECT_NAME (in `strtab'). */
2353 print_section_stabs (bfd *abfd,
2354 const char *stabsect_name,
2355 unsigned *string_offset_ptr)
2358 unsigned file_string_table_offset = 0;
2359 unsigned next_file_string_table_offset = *string_offset_ptr;
2360 bfd_byte *stabp, *stabs_end;
2363 stabs_end = stabp + stab_size;
2365 printf (_("Contents of %s section:\n\n"), stabsect_name);
2366 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2368 /* Loop through all symbols and print them.
2370 We start the index at -1 because there is a dummy symbol on
2371 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2372 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2376 unsigned char type, other;
2377 unsigned short desc;
2380 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2381 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2382 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2383 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2384 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2386 printf ("\n%-6d ", i);
2387 /* Either print the stab name, or, if unnamed, print its number
2388 again (makes consistent formatting for tools like awk). */
2389 name = bfd_get_stab_name (type);
2391 printf ("%-6s", name);
2392 else if (type == N_UNDF)
2395 printf ("%-6d", type);
2396 printf (" %-6d %-6d ", other, desc);
2397 bfd_printf_vma (abfd, value);
2398 printf (" %-6lu", strx);
2400 /* Symbols with type == 0 (N_UNDF) specify the length of the
2401 string table associated with this file. We use that info
2402 to know how to relocate the *next* file's string table indices. */
2405 file_string_table_offset = next_file_string_table_offset;
2406 next_file_string_table_offset += value;
2410 /* Using the (possibly updated) string table offset, print the
2411 string (if any) associated with this symbol. */
2412 if ((strx + file_string_table_offset) < stabstr_size)
2413 printf (" %s", &strtab[strx + file_string_table_offset]);
2419 *string_offset_ptr = next_file_string_table_offset;
2424 const char * section_name;
2425 const char * string_section_name;
2426 unsigned string_offset;
2431 find_stabs_section (bfd *abfd, asection *section, void *names)
2434 stab_section_names * sought = (stab_section_names *) names;
2436 /* Check for section names for which stabsect_name is a prefix, to
2437 handle .stab.N, etc. */
2438 len = strlen (sought->section_name);
2440 /* If the prefix matches, and the files section name ends with a
2441 nul or a digit, then we match. I.e., we want either an exact
2442 match or a section followed by a number. */
2443 if (strncmp (sought->section_name, section->name, len) == 0
2444 && (section->name[len] == 0
2445 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2448 strtab = read_section_stabs (abfd, sought->string_section_name,
2453 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2456 print_section_stabs (abfd, section->name, &sought->string_offset);
2462 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2464 stab_section_names s;
2466 s.section_name = stabsect_name;
2467 s.string_section_name = strsect_name;
2468 s.string_offset = 0;
2470 bfd_map_over_sections (abfd, find_stabs_section, & s);
2476 /* Dump the any sections containing stabs debugging information. */
2479 dump_stabs (bfd *abfd)
2481 dump_stabs_section (abfd, ".stab", ".stabstr");
2482 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2483 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2486 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2488 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2492 dump_bfd_header (bfd *abfd)
2496 printf (_("architecture: %s, "),
2497 bfd_printable_arch_mach (bfd_get_arch (abfd),
2498 bfd_get_mach (abfd)));
2499 printf (_("flags 0x%08x:\n"), abfd->flags);
2501 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2502 PF (HAS_RELOC, "HAS_RELOC");
2503 PF (EXEC_P, "EXEC_P");
2504 PF (HAS_LINENO, "HAS_LINENO");
2505 PF (HAS_DEBUG, "HAS_DEBUG");
2506 PF (HAS_SYMS, "HAS_SYMS");
2507 PF (HAS_LOCALS, "HAS_LOCALS");
2508 PF (DYNAMIC, "DYNAMIC");
2509 PF (WP_TEXT, "WP_TEXT");
2510 PF (D_PAGED, "D_PAGED");
2511 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2512 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2513 printf (_("\nstart address 0x"));
2514 bfd_printf_vma (abfd, abfd->start_address);
2520 dump_bfd_private_header (bfd *abfd)
2522 bfd_print_private_bfd_data (abfd, stdout);
2526 /* Display a section in hexadecimal format with associated characters.
2527 Each line prefixed by the zero padded address. */
2530 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2533 bfd_size_type datasize;
2534 bfd_size_type addr_offset;
2535 bfd_size_type start_offset;
2536 bfd_size_type stop_offset;
2537 unsigned int opb = bfd_octets_per_byte (abfd);
2538 /* Bytes per line. */
2539 const int onaline = 16;
2544 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2547 if (! process_section_p (section))
2550 if ((datasize = bfd_section_size (abfd, section)) == 0)
2553 /* Compute the address range to display. */
2554 if (start_address == (bfd_vma) -1
2555 || start_address < section->vma)
2558 start_offset = start_address - section->vma;
2560 if (stop_address == (bfd_vma) -1)
2561 stop_offset = datasize / opb;
2564 if (stop_address < section->vma)
2567 stop_offset = stop_address - section->vma;
2569 if (stop_offset > datasize / opb)
2570 stop_offset = datasize / opb;
2573 if (start_offset >= stop_offset)
2576 printf (_("Contents of section %s:"), section->name);
2577 if (display_file_offsets)
2578 printf (_(" (Starting at file offset: 0x%lx)"),
2579 (unsigned long) (section->filepos + start_offset));
2582 data = (bfd_byte *) xmalloc (datasize);
2584 bfd_get_section_contents (abfd, section, data, 0, datasize);
2588 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2589 if (strlen (buf) >= sizeof (buf))
2593 while (buf[count] == '0' && buf[count+1] != '\0')
2595 count = strlen (buf) - count;
2599 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2600 if (strlen (buf) >= sizeof (buf))
2604 while (buf[count] == '0' && buf[count+1] != '\0')
2606 count = strlen (buf) - count;
2610 for (addr_offset = start_offset;
2611 addr_offset < stop_offset; addr_offset += onaline / opb)
2615 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2616 count = strlen (buf);
2617 if ((size_t) count >= sizeof (buf))
2621 while (count < width)
2626 fputs (buf + count - width, stdout);
2629 for (j = addr_offset * opb;
2630 j < addr_offset * opb + onaline; j++)
2632 if (j < stop_offset * opb)
2633 printf ("%02x", (unsigned) (data[j]));
2641 for (j = addr_offset * opb;
2642 j < addr_offset * opb + onaline; j++)
2644 if (j >= stop_offset * opb)
2647 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2654 /* Actually display the various requested regions. */
2657 dump_data (bfd *abfd)
2659 bfd_map_over_sections (abfd, dump_section, NULL);
2662 /* Should perhaps share code and display with nm? */
2665 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2675 printf ("DYNAMIC SYMBOL TABLE:\n");
2681 printf ("SYMBOL TABLE:\n");
2685 printf (_("no symbols\n"));
2687 for (count = 0; count < max; count++)
2691 if (*current == NULL)
2692 printf (_("no information for symbol number %ld\n"), count);
2694 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2695 printf (_("could not determine the type of symbol number %ld\n"),
2698 else if (process_section_p ((* current)->section)
2699 && (dump_special_syms
2700 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2702 const char *name = (*current)->name;
2704 if (do_demangle && name != NULL && *name != '\0')
2708 /* If we want to demangle the name, we demangle it
2709 here, and temporarily clobber it while calling
2710 bfd_print_symbol. FIXME: This is a gross hack. */
2711 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2713 (*current)->name = alloc;
2714 bfd_print_symbol (cur_bfd, stdout, *current,
2715 bfd_print_symbol_all);
2718 (*current)->name = name;
2723 bfd_print_symbol (cur_bfd, stdout, *current,
2724 bfd_print_symbol_all);
2734 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2737 char *last_filename, *last_functionname;
2738 unsigned int last_line;
2740 /* Get column headers lined up reasonably. */
2748 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2749 width = strlen (buf) - 7;
2751 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2754 last_filename = NULL;
2755 last_functionname = NULL;
2758 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2761 const char *filename, *functionname;
2763 const char *sym_name;
2764 const char *section_name;
2766 if (start_address != (bfd_vma) -1
2767 && q->address < start_address)
2769 if (stop_address != (bfd_vma) -1
2770 && q->address > stop_address)
2773 if (with_line_numbers
2775 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2776 &filename, &functionname, &line))
2778 if (functionname != NULL
2779 && (last_functionname == NULL
2780 || strcmp (functionname, last_functionname) != 0))
2782 printf ("%s():\n", functionname);
2783 if (last_functionname != NULL)
2784 free (last_functionname);
2785 last_functionname = xstrdup (functionname);
2789 && (line != last_line
2790 || (filename != NULL
2791 && last_filename != NULL
2792 && strcmp (filename, last_filename) != 0)))
2794 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2796 if (last_filename != NULL)
2797 free (last_filename);
2798 if (filename == NULL)
2799 last_filename = NULL;
2801 last_filename = xstrdup (filename);
2805 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2807 sym_name = (*(q->sym_ptr_ptr))->name;
2808 section_name = (*(q->sym_ptr_ptr))->section->name;
2813 section_name = NULL;
2816 bfd_printf_vma (abfd, q->address);
2817 if (q->howto == NULL)
2818 printf (" *unknown* ");
2819 else if (q->howto->name)
2820 printf (" %-16s ", q->howto->name);
2822 printf (" %-16d ", q->howto->type);
2826 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2830 if (section_name == NULL)
2831 section_name = "*unknown*";
2832 printf ("[%s]", section_name);
2838 bfd_printf_vma (abfd, q->addend);
2846 dump_relocs_in_section (bfd *abfd,
2848 void *dummy ATTRIBUTE_UNUSED)
2854 if ( bfd_is_abs_section (section)
2855 || bfd_is_und_section (section)
2856 || bfd_is_com_section (section)
2857 || (! process_section_p (section))
2858 || ((section->flags & SEC_RELOC) == 0))
2861 relsize = bfd_get_reloc_upper_bound (abfd, section);
2863 bfd_fatal (bfd_get_filename (abfd));
2865 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2869 printf (" (none)\n\n");
2873 relpp = (arelent **) xmalloc (relsize);
2874 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2877 bfd_fatal (bfd_get_filename (abfd));
2878 else if (relcount == 0)
2879 printf (" (none)\n\n");
2883 dump_reloc_set (abfd, section, relpp, relcount);
2890 dump_relocs (bfd *abfd)
2892 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2896 dump_dynamic_relocs (bfd *abfd)
2902 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2904 bfd_fatal (bfd_get_filename (abfd));
2906 printf ("DYNAMIC RELOCATION RECORDS");
2909 printf (" (none)\n\n");
2912 relpp = (arelent **) xmalloc (relsize);
2913 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2916 bfd_fatal (bfd_get_filename (abfd));
2917 else if (relcount == 0)
2918 printf (" (none)\n\n");
2922 dump_reloc_set (abfd, NULL, relpp, relcount);
2929 /* Creates a table of paths, to search for source files. */
2932 add_include_path (const char *path)
2936 include_path_count++;
2937 include_paths = (const char **)
2938 xrealloc (include_paths, include_path_count * sizeof (*include_paths));
2939 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2940 if (path[1] == ':' && path[2] == 0)
2941 path = concat (path, ".", (const char *) 0);
2943 include_paths[include_path_count - 1] = path;
2947 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2951 if ((section->flags & SEC_DEBUGGING) == 0)
2953 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2954 section->vma += adjust_section_vma;
2956 section->lma += adjust_section_vma;
2960 /* Dump selected contents of ABFD. */
2963 dump_bfd (bfd *abfd)
2965 /* If we are adjusting section VMA's, change them all now. Changing
2966 the BFD information is a hack. However, we must do it, or
2967 bfd_find_nearest_line will not do the right thing. */
2968 if (adjust_section_vma != 0)
2970 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2971 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2974 if (! dump_debugging_tags)
2975 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2978 print_arelt_descr (stdout, abfd, TRUE);
2979 if (dump_file_header)
2980 dump_bfd_header (abfd);
2981 if (dump_private_headers)
2982 dump_bfd_private_header (abfd);
2983 if (! dump_debugging_tags)
2985 if (dump_section_headers)
2986 dump_headers (abfd);
2992 || dump_dwarf_section_info)
2993 syms = slurp_symtab (abfd);
2994 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2995 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2996 dynsyms = slurp_dynamic_symtab (abfd);
2999 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3000 dynsymcount, dynsyms, &synthsyms);
3006 dump_symbols (abfd, FALSE);
3007 if (dump_dynamic_symtab)
3008 dump_symbols (abfd, TRUE);
3009 if (dump_dwarf_section_info)
3011 if (dump_stab_section_info)
3013 if (dump_reloc_info && ! disassemble)
3015 if (dump_dynamic_reloc_info && ! disassemble)
3016 dump_dynamic_relocs (abfd);
3017 if (dump_section_contents)
3020 disassemble_data (abfd);
3026 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3027 if (dhandle != NULL)
3029 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3031 dump_debugging_tags ? TRUE : FALSE))
3033 non_fatal (_("%s: printing debugging information failed"),
3034 bfd_get_filename (abfd));
3038 /* PR 6483: If there was no STABS or IEEE debug
3039 info in the file, try DWARF instead. */
3040 else if (! dump_dwarf_section_info)
3070 display_bfd (bfd *abfd)
3074 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3080 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3082 nonfatal (bfd_get_filename (abfd));
3083 list_matching_formats (matching);
3088 if (bfd_get_error () != bfd_error_file_not_recognized)
3090 nonfatal (bfd_get_filename (abfd));
3094 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3100 nonfatal (bfd_get_filename (abfd));
3102 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3104 list_matching_formats (matching);
3110 display_file (char *filename, char *target)
3115 if (get_file_size (filename) < 1)
3121 file = bfd_openr (filename, target);
3124 nonfatal (filename);
3128 /* If the file is an archive, process all of its elements. */
3129 if (bfd_check_format (file, bfd_archive))
3131 bfd *last_arfile = NULL;
3133 printf (_("In archive %s:\n"), bfd_get_filename (file));
3136 bfd_set_error (bfd_error_no_error);
3138 arfile = bfd_openr_next_archived_file (file, arfile);
3141 if (bfd_get_error () != bfd_error_no_more_archived_files)
3142 nonfatal (bfd_get_filename (file));
3146 display_bfd (arfile);
3148 if (last_arfile != NULL)
3149 bfd_close (last_arfile);
3150 last_arfile = arfile;
3153 if (last_arfile != NULL)
3154 bfd_close (last_arfile);
3163 main (int argc, char **argv)
3166 char *target = default_target;
3167 bfd_boolean seenflag = FALSE;
3169 #if defined (HAVE_SETLOCALE)
3170 #if defined (HAVE_LC_MESSAGES)
3171 setlocale (LC_MESSAGES, "");
3173 setlocale (LC_CTYPE, "");
3176 bindtextdomain (PACKAGE, LOCALEDIR);
3177 textdomain (PACKAGE);
3179 program_name = *argv;
3180 xmalloc_set_program_name (program_name);
3182 START_PROGRESS (program_name, 0);
3184 expandargv (&argc, &argv);
3187 set_default_bfd_target ();
3189 while ((c = getopt_long (argc, argv,
3190 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3191 long_options, (int *) 0))
3197 break; /* We've been given a long option. */
3202 if (disassembler_options)
3203 /* Ignore potential memory leak for now. */
3204 disassembler_options = concat (disassembler_options, ",",
3205 optarg, (const char *) NULL);
3207 disassembler_options = optarg;
3210 if (only_used == only_size)
3213 only = (char **) xrealloc (only, only_size * sizeof (char *));
3215 only [only_used++] = optarg;
3218 display_file_offsets = TRUE;
3221 with_line_numbers = TRUE;
3230 enum demangling_styles style;
3232 style = cplus_demangle_name_to_style (optarg);
3233 if (style == unknown_demangling)
3234 fatal (_("unknown demangling style `%s'"),
3237 cplus_demangle_set_style (style);
3243 case OPTION_ADJUST_VMA:
3244 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3246 case OPTION_START_ADDRESS:
3247 start_address = parse_vma (optarg, "--start-address");
3248 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3249 fatal (_("error: the start address should be before the end address"));
3251 case OPTION_STOP_ADDRESS:
3252 stop_address = parse_vma (optarg, "--stop-address");
3253 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3254 fatal (_("error: the stop address should be after the start address"));
3258 prefix_length = strlen (prefix);
3259 /* Remove an unnecessary trailing '/' */
3260 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3263 case OPTION_PREFIX_STRIP:
3264 prefix_strip = atoi (optarg);
3265 if (prefix_strip < 0)
3266 fatal (_("error: prefix strip must be non-negative"));
3268 case OPTION_INSN_WIDTH:
3269 insn_width = strtoul (optarg, NULL, 0);
3270 if (insn_width <= 0)
3271 fatal (_("error: instruction width must be positive"));
3274 if (strcmp (optarg, "B") == 0)
3275 endian = BFD_ENDIAN_BIG;
3276 else if (strcmp (optarg, "L") == 0)
3277 endian = BFD_ENDIAN_LITTLE;
3280 non_fatal (_("unrecognized -E option"));
3285 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3286 endian = BFD_ENDIAN_BIG;
3287 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3288 endian = BFD_ENDIAN_LITTLE;
3291 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3297 dump_file_header = TRUE;
3301 formats_info = TRUE;
3305 add_include_path (optarg);
3308 dump_private_headers = TRUE;
3312 dump_private_headers = TRUE;
3314 dump_reloc_info = TRUE;
3315 dump_file_header = TRUE;
3316 dump_ar_hdrs = TRUE;
3317 dump_section_headers = TRUE;
3325 dump_dynamic_symtab = TRUE;
3333 disassemble_zeroes = TRUE;
3337 disassemble_all = TRUE;
3342 with_source_code = TRUE;
3351 dump_debugging_tags = 1;
3356 dump_dwarf_section_info = TRUE;
3359 dwarf_select_sections_by_letters (optarg);
3361 dwarf_select_sections_all ();
3364 dump_dwarf_section_info = TRUE;
3367 dwarf_select_sections_by_names (optarg);
3369 dwarf_select_sections_all ();
3372 dump_stab_section_info = TRUE;
3376 dump_section_contents = TRUE;
3380 dump_reloc_info = TRUE;
3384 dump_dynamic_reloc_info = TRUE;
3388 dump_ar_hdrs = TRUE;
3392 dump_section_headers = TRUE;
3400 show_version = TRUE;
3410 print_version ("objdump");
3416 exit_status = display_info ();
3420 display_file ("a.out", target);
3422 for (; optind < argc;)
3423 display_file (argv[optind++], target);
3426 END_PROGRESS (program_name);