1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2017 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status
= 0;
80 static char *default_target
= NULL
; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version
= 0; /* Show the version number. */
85 static int dump_section_contents
; /* -s */
86 static int dump_section_headers
; /* -h */
87 static bfd_boolean dump_file_header
; /* -f */
88 static int dump_symtab
; /* -t */
89 static int dump_dynamic_symtab
; /* -T */
90 static int dump_reloc_info
; /* -r */
91 static int dump_dynamic_reloc_info
; /* -R */
92 static int dump_ar_hdrs
; /* -a */
93 static int dump_private_headers
; /* -p */
94 static char *dump_private_options
; /* -P */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int suppress_bfd_header
;
113 static int dump_special_syms
= 0; /* --special-syms */
114 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
115 static int file_start_context
= 0; /* --file-start-context */
116 static bfd_boolean display_file_offsets
;/* -F */
117 static const char *prefix
; /* --prefix */
118 static int prefix_strip
; /* --prefix-strip */
119 static size_t prefix_length
;
121 /* A structure to record the sections mentioned in -j switches. */
124 const char * name
; /* The name of the section. */
125 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
126 struct only
* next
; /* Pointer to the next structure in the list. */
128 /* Pointer to an array of 'only' structures.
129 This pointer is NULL if the -j switch has not been used. */
130 static struct only
* only_list
= NULL
;
132 /* Variables for handling include file path table. */
133 static const char **include_paths
;
134 static int include_path_count
;
136 /* Extra info to pass to the section disassembler and address printing
138 struct objdump_disasm_info
142 bfd_boolean require_sec
;
143 arelent
** dynrelbuf
;
145 disassembler_ftype disassemble_fn
;
149 /* Architecture to disassemble for, or default if NULL. */
150 static char *machine
= NULL
;
152 /* Target specific options to the disassembler. */
153 static char *disassembler_options
= NULL
;
155 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
156 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
158 /* The symbol table. */
159 static asymbol
**syms
;
161 /* Number of symbols in `syms'. */
162 static long symcount
= 0;
164 /* The sorted symbol table. */
165 static asymbol
**sorted_syms
;
167 /* Number of symbols in `sorted_syms'. */
168 static long sorted_symcount
= 0;
170 /* The dynamic symbol table. */
171 static asymbol
**dynsyms
;
173 /* The synthetic symbol table. */
174 static asymbol
*synthsyms
;
175 static long synthcount
= 0;
177 /* Number of symbols in `dynsyms'. */
178 static long dynsymcount
= 0;
180 static bfd_byte
*stabs
;
181 static bfd_size_type stab_size
;
184 static bfd_size_type stabstr_size
;
186 static bfd_boolean is_relocatable
= FALSE
;
188 /* Handlers for -P/--private. */
189 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
191 OBJDUMP_PRIVATE_VECTORS
195 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
197 usage (FILE *stream
, int status
)
199 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
200 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
201 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
202 fprintf (stream
, _("\
203 -a, --archive-headers Display archive header information\n\
204 -f, --file-headers Display the contents of the overall file header\n\
205 -p, --private-headers Display object format specific file header contents\n\
206 -P, --private=OPT,OPT... Display object format specific contents\n\
207 -h, --[section-]headers Display the contents of the section headers\n\
208 -x, --all-headers Display the contents of all headers\n\
209 -d, --disassemble Display assembler contents of executable sections\n\
210 -D, --disassemble-all Display assembler contents of all sections\n\
211 -S, --source Intermix source code with disassembly\n\
212 -s, --full-contents Display the full contents of all sections requested\n\
213 -g, --debugging Display debug information in object file\n\
214 -e, --debugging-tags Display debug information using ctags style\n\
215 -G, --stabs Display (in raw form) any STABS info in the file\n\
216 -W[lLiaprmfFsoRt] or\n\
217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 Display DWARF info in the file\n\
222 -t, --syms Display the contents of the symbol table(s)\n\
223 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
224 -r, --reloc Display the relocation entries in the file\n\
225 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
226 @<file> Read options from <file>\n\
227 -v, --version Display this program's version number\n\
228 -i, --info List object formats and architectures supported\n\
229 -H, --help Display this information\n\
233 const struct objdump_private_desc
* const *desc
;
235 fprintf (stream
, _("\n The following switches are optional:\n"));
236 fprintf (stream
, _("\
237 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
238 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
239 -j, --section=NAME Only display information for section NAME\n\
240 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
241 -EB --endian=big Assume big endian format when disassembling\n\
242 -EL --endian=little Assume little endian format when disassembling\n\
243 --file-start-context Include context from start of file (with -S)\n\
244 -I, --include=DIR Add DIR to search list for source files\n\
245 -l, --line-numbers Include line numbers and filenames in output\n\
246 -F, --file-offsets Include file offsets when displaying information\n\
247 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
248 The STYLE, if specified, can be `auto', `gnu',\n\
249 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251 -w, --wide Format output for more than 80 columns\n\
252 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
253 --start-address=ADDR Only process data whose address is >= ADDR\n\
254 --stop-address=ADDR Only process data whose address is <= ADDR\n\
255 --prefix-addresses Print complete address alongside disassembly\n\
256 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
257 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
258 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
259 --special-syms Include special symbols in symbol dumps\n\
260 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
261 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
262 fprintf (stream
, _("\
263 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
264 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
266 --dwarf-check Make additional dwarf internal consistency checks.\
268 list_supported_targets (program_name
, stream
);
269 list_supported_architectures (program_name
, stream
);
271 disassembler_usage (stream
);
273 if (objdump_private_vectors
[0] != NULL
)
276 _("\nOptions supported for -P/--private switch:\n"));
277 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
278 (*desc
)->help (stream
);
281 if (REPORT_BUGS_TO
[0] && status
== 0)
282 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
286 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
290 OPTION_START_ADDRESS
,
302 static struct option long_options
[]=
304 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
305 {"all-headers", no_argument
, NULL
, 'x'},
306 {"private-headers", no_argument
, NULL
, 'p'},
307 {"private", required_argument
, NULL
, 'P'},
308 {"architecture", required_argument
, NULL
, 'm'},
309 {"archive-headers", no_argument
, NULL
, 'a'},
310 {"debugging", no_argument
, NULL
, 'g'},
311 {"debugging-tags", no_argument
, NULL
, 'e'},
312 {"demangle", optional_argument
, NULL
, 'C'},
313 {"disassemble", no_argument
, NULL
, 'd'},
314 {"disassemble-all", no_argument
, NULL
, 'D'},
315 {"disassembler-options", required_argument
, NULL
, 'M'},
316 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
317 {"dynamic-reloc", no_argument
, NULL
, 'R'},
318 {"dynamic-syms", no_argument
, NULL
, 'T'},
319 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
320 {"file-headers", no_argument
, NULL
, 'f'},
321 {"file-offsets", no_argument
, NULL
, 'F'},
322 {"file-start-context", no_argument
, &file_start_context
, 1},
323 {"full-contents", no_argument
, NULL
, 's'},
324 {"headers", no_argument
, NULL
, 'h'},
325 {"help", no_argument
, NULL
, 'H'},
326 {"info", no_argument
, NULL
, 'i'},
327 {"line-numbers", no_argument
, NULL
, 'l'},
328 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
329 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
330 {"reloc", no_argument
, NULL
, 'r'},
331 {"section", required_argument
, NULL
, 'j'},
332 {"section-headers", no_argument
, NULL
, 'h'},
333 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
334 {"source", no_argument
, NULL
, 'S'},
335 {"special-syms", no_argument
, &dump_special_syms
, 1},
336 {"include", required_argument
, NULL
, 'I'},
337 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
338 {"stabs", no_argument
, NULL
, 'G'},
339 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
340 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
341 {"syms", no_argument
, NULL
, 't'},
342 {"target", required_argument
, NULL
, 'b'},
343 {"version", no_argument
, NULL
, 'V'},
344 {"wide", no_argument
, NULL
, 'w'},
345 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
346 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
347 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
348 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
349 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
350 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
351 {0, no_argument
, 0, 0}
355 nonfatal (const char *msg
)
361 /* Returns TRUE if the specified section should be dumped. */
364 process_section_p (asection
* section
)
368 if (only_list
== NULL
)
371 for (only
= only_list
; only
; only
= only
->next
)
372 if (strcmp (only
->name
, section
->name
) == 0)
381 /* Add an entry to the 'only' list. */
384 add_only (char * name
)
388 /* First check to make sure that we do not
389 already have an entry for this name. */
390 for (only
= only_list
; only
; only
= only
->next
)
391 if (strcmp (only
->name
, name
) == 0)
394 only
= xmalloc (sizeof * only
);
397 only
->next
= only_list
;
401 /* Release the memory used by the 'only' list.
402 PR 11225: Issue a warning message for unseen sections.
403 Only do this if none of the sections were seen. This is mainly to support
404 tools like the GAS testsuite where an object file is dumped with a list of
405 generic section names known to be present in a range of different file
409 free_only_list (void)
411 bfd_boolean at_least_one_seen
= FALSE
;
415 if (only_list
== NULL
)
418 for (only
= only_list
; only
; only
= only
->next
)
421 at_least_one_seen
= TRUE
;
425 for (only
= only_list
; only
; only
= next
)
427 if (! at_least_one_seen
)
429 non_fatal (_("section '%s' mentioned in a -j option, "
430 "but not found in any input file"),
441 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
444 unsigned int opb
= bfd_octets_per_byte (abfd
);
445 int longest_section_name
= *((int *) data
);
447 /* Ignore linker created section. See elfNN_ia64_object_p in
449 if (section
->flags
& SEC_LINKER_CREATED
)
452 /* PR 10413: Skip sections that we are ignoring. */
453 if (! process_section_p (section
))
456 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
457 bfd_get_section_name (abfd
, section
),
458 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
459 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
461 bfd_printf_vma (abfd
, section
->lma
);
462 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
463 bfd_get_section_alignment (abfd
, section
));
469 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
471 PF (SEC_HAS_CONTENTS
, "CONTENTS");
472 PF (SEC_ALLOC
, "ALLOC");
473 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
474 PF (SEC_LOAD
, "LOAD");
475 PF (SEC_RELOC
, "RELOC");
476 PF (SEC_READONLY
, "READONLY");
477 PF (SEC_CODE
, "CODE");
478 PF (SEC_DATA
, "DATA");
480 PF (SEC_DEBUGGING
, "DEBUGGING");
481 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
482 PF (SEC_EXCLUDE
, "EXCLUDE");
483 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
484 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
486 PF (SEC_TIC54X_BLOCK
, "BLOCK");
487 PF (SEC_TIC54X_CLINK
, "CLINK");
489 PF (SEC_SMALL_DATA
, "SMALL_DATA");
490 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
492 PF (SEC_COFF_SHARED
, "SHARED");
493 PF (SEC_COFF_NOREAD
, "NOREAD");
495 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
496 PF (SEC_ELF_PURECODE
, "PURECODE");
497 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
498 PF (SEC_GROUP
, "GROUP");
499 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
501 PF (SEC_MEP_VLIW
, "VLIW");
504 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
507 struct coff_comdat_info
*comdat
;
509 switch (section
->flags
& SEC_LINK_DUPLICATES
)
513 case SEC_LINK_DUPLICATES_DISCARD
:
514 ls
= "LINK_ONCE_DISCARD";
516 case SEC_LINK_DUPLICATES_ONE_ONLY
:
517 ls
= "LINK_ONCE_ONE_ONLY";
519 case SEC_LINK_DUPLICATES_SAME_SIZE
:
520 ls
= "LINK_ONCE_SAME_SIZE";
522 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
523 ls
= "LINK_ONCE_SAME_CONTENTS";
526 printf ("%s%s", comma
, ls
);
528 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
530 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
539 /* Called on each SECTION in ABFD, update the int variable pointed to by
540 DATA which contains the string length of the longest section name. */
543 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
545 int *longest_so_far
= (int *) data
;
549 /* Ignore linker created section. */
550 if (section
->flags
& SEC_LINKER_CREATED
)
553 /* Skip sections that we are ignoring. */
554 if (! process_section_p (section
))
557 name
= bfd_get_section_name (abfd
, section
);
558 len
= (int) strlen (name
);
559 if (len
> *longest_so_far
)
560 *longest_so_far
= len
;
564 dump_headers (bfd
*abfd
)
566 /* The default width of 13 is just an arbitrary choice. */
567 int max_section_name_length
= 13;
573 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
574 if (bfd_get_arch_size (abfd
) == 32)
580 printf (_("Sections:\n"));
583 bfd_map_over_sections (abfd
, find_longest_section_name
,
584 &max_section_name_length
);
586 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
587 max_section_name_length
, "Name",
588 bfd_vma_width
, "VMA",
589 bfd_vma_width
, "LMA");
592 printf (_(" Flags"));
595 bfd_map_over_sections (abfd
, dump_section_header
,
596 &max_section_name_length
);
600 slurp_symtab (bfd
*abfd
)
605 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
611 storage
= bfd_get_symtab_upper_bound (abfd
);
614 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
615 bfd_fatal (_("error message was"));
618 sy
= (asymbol
**) xmalloc (storage
);
620 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
622 bfd_fatal (bfd_get_filename (abfd
));
626 /* Read in the dynamic symbols. */
629 slurp_dynamic_symtab (bfd
*abfd
)
634 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
637 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
639 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
645 bfd_fatal (bfd_get_filename (abfd
));
648 sy
= (asymbol
**) xmalloc (storage
);
650 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
652 bfd_fatal (bfd_get_filename (abfd
));
656 /* Some symbol names are significant and should be kept in the
657 table of sorted symbol names, even if they are marked as
658 debugging/section symbols. */
661 is_significant_symbol_name (const char * name
)
663 return strcmp (name
, ".plt") == 0
664 || strcmp (name
, ".got") == 0
665 || strcmp (name
, ".plt.got") == 0;
668 /* Filter out (in place) symbols that are useless for disassembly.
669 COUNT is the number of elements in SYMBOLS.
670 Return the number of useful symbols. */
673 remove_useless_symbols (asymbol
**symbols
, long count
)
675 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
679 asymbol
*sym
= *in_ptr
++;
681 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
683 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
684 && ! is_significant_symbol_name (sym
->name
))
686 if (bfd_is_und_section (sym
->section
)
687 || bfd_is_com_section (sym
->section
))
692 return out_ptr
- symbols
;
695 /* Sort symbols into value order. */
698 compare_symbols (const void *ap
, const void *bp
)
700 const asymbol
*a
= * (const asymbol
**) ap
;
701 const asymbol
*b
= * (const asymbol
**) bp
;
711 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
713 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
716 if (a
->section
> b
->section
)
718 else if (a
->section
< b
->section
)
721 an
= bfd_asymbol_name (a
);
722 bn
= bfd_asymbol_name (b
);
726 /* The symbols gnu_compiled and gcc2_compiled convey no real
727 information, so put them after other symbols with the same value. */
728 af
= (strstr (an
, "gnu_compiled") != NULL
729 || strstr (an
, "gcc2_compiled") != NULL
);
730 bf
= (strstr (bn
, "gnu_compiled") != NULL
731 || strstr (bn
, "gcc2_compiled") != NULL
);
738 /* We use a heuristic for the file name, to try to sort it after
739 more useful symbols. It may not work on non Unix systems, but it
740 doesn't really matter; the only difference is precisely which
741 symbol names get printed. */
743 #define file_symbol(s, sn, snl) \
744 (((s)->flags & BSF_FILE) != 0 \
745 || ((sn)[(snl) - 2] == '.' \
746 && ((sn)[(snl) - 1] == 'o' \
747 || (sn)[(snl) - 1] == 'a')))
749 af
= file_symbol (a
, an
, anl
);
750 bf
= file_symbol (b
, bn
, bnl
);
757 /* Try to sort global symbols before local symbols before function
758 symbols before debugging symbols. */
763 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
765 if ((aflags
& BSF_DEBUGGING
) != 0)
770 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
772 if ((aflags
& BSF_FUNCTION
) != 0)
777 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
779 if ((aflags
& BSF_LOCAL
) != 0)
784 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
786 if ((aflags
& BSF_GLOBAL
) != 0)
792 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
793 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
798 if ((a
->flags
& BSF_SYNTHETIC
) == 0)
799 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
801 if ((b
->flags
& BSF_SYNTHETIC
) == 0)
802 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
804 return asz
> bsz
? -1 : 1;
807 /* Symbols that start with '.' might be section names, so sort them
808 after symbols that don't start with '.'. */
809 if (an
[0] == '.' && bn
[0] != '.')
811 if (an
[0] != '.' && bn
[0] == '.')
814 /* Finally, if we can't distinguish them in any other way, try to
815 get consistent results by sorting the symbols by name. */
816 return strcmp (an
, bn
);
819 /* Sort relocs into address order. */
822 compare_relocs (const void *ap
, const void *bp
)
824 const arelent
*a
= * (const arelent
**) ap
;
825 const arelent
*b
= * (const arelent
**) bp
;
827 if (a
->address
> b
->address
)
829 else if (a
->address
< b
->address
)
832 /* So that associated relocations tied to the same address show up
833 in the correct order, we don't do any further sorting. */
842 /* Print an address (VMA) to the output stream in INFO.
843 If SKIP_ZEROES is TRUE, omit leading zeroes. */
846 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
847 bfd_boolean skip_zeroes
)
851 struct objdump_disasm_info
*aux
;
853 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
854 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
859 for (p
= buf
; *p
== '0'; ++p
)
864 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
867 /* Print the name of a symbol. */
870 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
874 const char *name
, *version_string
= NULL
;
875 bfd_boolean hidden
= FALSE
;
878 name
= bfd_asymbol_name (sym
);
879 if (do_demangle
&& name
[0] != '\0')
881 /* Demangle the name. */
882 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
887 if ((sym
->flags
& BSF_SYNTHETIC
) == 0)
888 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
890 if (bfd_is_und_section (bfd_get_section (sym
)))
895 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
896 if (version_string
&& *version_string
!= '\0')
897 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
903 if (version_string
&& *version_string
!= '\0')
904 printf (hidden
? "@%s" : "@@%s", version_string
);
911 /* Locate a symbol given a bfd and a section (from INFO->application_data),
912 and a VMA. If INFO->application_data->require_sec is TRUE, then always
913 require the symbol to be in the section. Returns NULL if there is no
914 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
915 of the symbol in sorted_syms. */
918 find_symbol_for_address (bfd_vma vma
,
919 struct disassemble_info
*inf
,
922 /* @@ Would it speed things up to cache the last two symbols returned,
923 and maybe their address ranges? For many processors, only one memory
924 operand can be present at a time, so the 2-entry cache wouldn't be
925 constantly churned by code doing heavy memory accesses. */
927 /* Indices in `sorted_syms'. */
929 long max_count
= sorted_symcount
;
931 struct objdump_disasm_info
*aux
;
935 bfd_boolean want_section
;
937 if (sorted_symcount
< 1)
940 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
943 opb
= inf
->octets_per_byte
;
945 /* Perform a binary search looking for the closest symbol to the
946 required value. We are searching the range (min, max_count]. */
947 while (min
+ 1 < max_count
)
951 thisplace
= (max_count
+ min
) / 2;
952 sym
= sorted_syms
[thisplace
];
954 if (bfd_asymbol_value (sym
) > vma
)
955 max_count
= thisplace
;
956 else if (bfd_asymbol_value (sym
) < vma
)
965 /* The symbol we want is now in min, the low end of the range we
966 were searching. If there are several symbols with the same
967 value, we want the first (non-section/non-debugging) one. */
970 && (bfd_asymbol_value (sorted_syms
[thisplace
])
971 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
972 && ((sorted_syms
[thisplace
- 1]->flags
973 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
977 /* Prefer a symbol in the current section if we have multple symbols
978 with the same value, as can occur with overlays or zero size
981 while (min
< max_count
982 && (bfd_asymbol_value (sorted_syms
[min
])
983 == bfd_asymbol_value (sorted_syms
[thisplace
])))
985 if (sorted_syms
[min
]->section
== sec
986 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
993 return sorted_syms
[thisplace
];
998 /* If the file is relocatable, and the symbol could be from this
999 section, prefer a symbol from this section over symbols from
1000 others, even if the other symbol's value might be closer.
1002 Note that this may be wrong for some symbol references if the
1003 sections have overlapping memory ranges, but in that case there's
1004 no way to tell what's desired without looking at the relocation
1007 Also give the target a chance to reject symbols. */
1008 want_section
= (aux
->require_sec
1009 || ((abfd
->flags
& HAS_RELOC
) != 0
1010 && vma
>= bfd_get_section_vma (abfd
, sec
)
1011 && vma
< (bfd_get_section_vma (abfd
, sec
)
1012 + bfd_section_size (abfd
, sec
) / opb
)));
1013 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1014 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1017 long newplace
= sorted_symcount
;
1019 for (i
= min
- 1; i
>= 0; i
--)
1021 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1022 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1024 if (newplace
== sorted_symcount
)
1027 if (bfd_asymbol_value (sorted_syms
[i
])
1028 != bfd_asymbol_value (sorted_syms
[newplace
]))
1031 /* Remember this symbol and keep searching until we reach
1032 an earlier address. */
1037 if (newplace
!= sorted_symcount
)
1038 thisplace
= newplace
;
1041 /* We didn't find a good symbol with a smaller value.
1042 Look for one with a larger value. */
1043 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1045 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1046 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1054 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1055 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1056 /* There is no suitable symbol. */
1060 /* If we have not found an exact match for the specified address
1061 and we have dynamic relocations available, then we can produce
1062 a better result by matching a relocation to the address and
1063 using the symbol associated with that relocation. */
1065 && aux
->dynrelbuf
!= NULL
1066 && sorted_syms
[thisplace
]->value
!= vma
1067 /* If we have matched a synthetic symbol, then stick with that. */
1068 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1073 for (rel_count
= aux
->dynrelcount
, rel_pp
= aux
->dynrelbuf
;
1076 arelent
* rel
= rel_pp
[rel_count
];
1078 if (rel
->address
== vma
1079 && rel
->sym_ptr_ptr
!= NULL
1080 /* Absolute relocations do not provide a more helpful symbolic address. */
1081 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1084 * place
= thisplace
;
1085 return * rel
->sym_ptr_ptr
;
1088 /* We are scanning backwards, so if we go below the target address
1090 if (rel_pp
[rel_count
]->address
< vma
)
1098 return sorted_syms
[thisplace
];
1101 /* Print an address and the offset to the nearest symbol. */
1104 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1105 bfd_vma vma
, struct disassemble_info
*inf
,
1106 bfd_boolean skip_zeroes
)
1108 objdump_print_value (vma
, inf
, skip_zeroes
);
1114 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1115 bfd_get_section_name (abfd
, sec
));
1116 secaddr
= bfd_get_section_vma (abfd
, sec
);
1119 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1120 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1122 else if (vma
> secaddr
)
1124 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1125 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1127 (*inf
->fprintf_func
) (inf
->stream
, ">");
1131 (*inf
->fprintf_func
) (inf
->stream
, " <");
1133 objdump_print_symname (abfd
, inf
, sym
);
1135 if (bfd_asymbol_value (sym
) == vma
)
1137 /* Undefined symbols in an executables and dynamic objects do not have
1138 a value associated with them, so it does not make sense to display
1139 an offset relative to them. Normally we would not be provided with
1140 this kind of symbol, but the target backend might choose to do so,
1141 and the code in find_symbol_for_address might return an as yet
1142 unresolved symbol associated with a dynamic reloc. */
1143 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1144 && bfd_is_und_section (sym
->section
))
1146 else if (bfd_asymbol_value (sym
) > vma
)
1148 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1149 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1151 else if (vma
> bfd_asymbol_value (sym
))
1153 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1154 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1157 (*inf
->fprintf_func
) (inf
->stream
, ">");
1160 if (display_file_offsets
)
1161 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1162 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1165 /* Print an address (VMA), symbolically if possible.
1166 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1169 objdump_print_addr (bfd_vma vma
,
1170 struct disassemble_info
*inf
,
1171 bfd_boolean skip_zeroes
)
1173 struct objdump_disasm_info
*aux
;
1174 asymbol
*sym
= NULL
;
1175 bfd_boolean skip_find
= FALSE
;
1177 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1179 if (sorted_symcount
< 1)
1181 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1182 objdump_print_value (vma
, inf
, skip_zeroes
);
1184 if (display_file_offsets
)
1185 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1186 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1190 if (aux
->reloc
!= NULL
1191 && aux
->reloc
->sym_ptr_ptr
!= NULL
1192 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1194 sym
= * aux
->reloc
->sym_ptr_ptr
;
1196 /* Adjust the vma to the reloc. */
1197 vma
+= bfd_asymbol_value (sym
);
1199 if (bfd_is_und_section (bfd_get_section (sym
)))
1204 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1206 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1210 /* Print VMA to INFO. This function is passed to the disassembler
1214 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1216 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1219 /* Determine if the given address has a symbol associated with it. */
1222 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1226 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1228 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1231 /* Hold the last function name and the last line number we displayed
1232 in a disassembly. */
1234 static char *prev_functionname
;
1235 static unsigned int prev_line
;
1236 static unsigned int prev_discriminator
;
1238 /* We keep a list of all files that we have seen when doing a
1239 disassembly with source, so that we know how much of the file to
1240 display. This can be important for inlined functions. */
1242 struct print_file_list
1244 struct print_file_list
*next
;
1245 const char *filename
;
1246 const char *modname
;
1249 const char **linemap
;
1252 unsigned max_printed
;
1256 static struct print_file_list
*print_files
;
1258 /* The number of preceding context lines to show when we start
1259 displaying a file for the first time. */
1261 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1263 /* Read a complete file into memory. */
1266 slurp_file (const char *fn
, size_t *size
)
1269 int ps
= getpagesize ();
1274 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1278 if (fstat (fd
, &st
) < 0)
1285 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1286 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1287 if (map
!= (char *) -1L)
1293 map
= (const char *) malloc (*size
);
1294 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1296 free ((void *) map
);
1303 #define line_map_decrease 5
1305 /* Precompute array of lines for a mapped file. */
1307 static const char **
1308 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1310 const char *p
, *lstart
, *end
;
1311 int chars_per_line
= 45; /* First iteration will use 40. */
1312 unsigned int lineno
;
1313 const char **linemap
= NULL
;
1314 unsigned long line_map_size
= 0;
1320 for (p
= map
; p
< end
; p
++)
1324 if (p
+ 1 < end
&& p
[1] == '\r')
1327 else if (*p
== '\r')
1329 if (p
+ 1 < end
&& p
[1] == '\n')
1335 /* End of line found. */
1337 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1339 unsigned long newsize
;
1341 chars_per_line
-= line_map_decrease
;
1342 if (chars_per_line
<= 1)
1344 line_map_size
= size
/ chars_per_line
+ 1;
1345 if (line_map_size
< lineno
+ 1)
1346 line_map_size
= lineno
+ 1;
1347 newsize
= line_map_size
* sizeof (char *);
1348 linemap
= (const char **) xrealloc (linemap
, newsize
);
1351 linemap
[lineno
++] = lstart
;
1359 /* Tries to open MODNAME, and if successful adds a node to print_files
1360 linked list and returns that node. Returns NULL on failure. */
1362 static struct print_file_list
*
1363 try_print_file_open (const char *origname
, const char *modname
)
1365 struct print_file_list
*p
;
1367 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1369 p
->map
= slurp_file (modname
, &p
->mapsize
);
1376 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1379 p
->filename
= origname
;
1380 p
->modname
= modname
;
1381 p
->next
= print_files
;
1387 /* If the source file, as described in the symtab, is not found
1388 try to locate it in one of the paths specified with -I
1389 If found, add location to print_files linked list. */
1391 static struct print_file_list
*
1392 update_source_path (const char *filename
)
1394 struct print_file_list
*p
;
1398 p
= try_print_file_open (filename
, filename
);
1402 if (include_path_count
== 0)
1405 /* Get the name of the file. */
1406 fname
= lbasename (filename
);
1408 /* If file exists under a new path, we need to add it to the list
1409 so that show_line knows about it. */
1410 for (i
= 0; i
< include_path_count
; i
++)
1412 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1414 p
= try_print_file_open (filename
, modname
);
1424 /* Print a source file line. */
1427 print_line (struct print_file_list
*p
, unsigned int linenum
)
1433 if (linenum
>= p
->maxline
)
1435 l
= p
->linemap
[linenum
];
1436 /* Test fwrite return value to quiet glibc warning. */
1437 len
= strcspn (l
, "\n\r");
1438 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1442 /* Print a range of source code lines. */
1445 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1449 while (start
<= end
)
1451 print_line (p
, start
);
1456 /* Show the line number, or the source line, in a disassembly
1460 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1462 const char *filename
;
1463 const char *functionname
;
1464 unsigned int linenumber
;
1465 unsigned int discriminator
;
1469 if (! with_line_numbers
&& ! with_source_code
)
1472 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1473 &filename
, &functionname
,
1474 &linenumber
, &discriminator
))
1477 if (filename
!= NULL
&& *filename
== '\0')
1479 if (functionname
!= NULL
&& *functionname
== '\0')
1480 functionname
= NULL
;
1483 && IS_ABSOLUTE_PATH (filename
)
1487 const char *fname
= filename
;
1489 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1492 memcpy (path
, prefix
, prefix_length
);
1493 path_up
= path
+ prefix_length
;
1495 /* Build relocated filename, stripping off leading directories
1496 from the initial filename if requested. */
1497 if (prefix_strip
> 0)
1502 /* Skip selected directory levels. */
1503 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1504 if (IS_DIR_SEPARATOR(*s
))
1511 /* Update complete filename. */
1512 strncpy (path_up
, fname
, PATH_MAX
);
1513 path_up
[PATH_MAX
] = '\0';
1521 if (with_line_numbers
)
1523 if (functionname
!= NULL
1524 && (prev_functionname
== NULL
1525 || strcmp (functionname
, prev_functionname
) != 0))
1526 printf ("%s():\n", functionname
);
1527 if (linenumber
> 0 && (linenumber
!= prev_line
||
1528 (discriminator
!= prev_discriminator
)))
1530 if (discriminator
> 0)
1531 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1532 linenumber
, discriminator
);
1534 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1538 if (with_source_code
1542 struct print_file_list
**pp
, *p
;
1545 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1546 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1553 filename
= xstrdup (filename
);
1554 p
= update_source_path (filename
);
1557 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1559 if (file_start_context
&& p
->first
)
1563 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1564 if (l
>= linenumber
)
1566 if (p
->max_printed
>= l
)
1568 if (p
->max_printed
< linenumber
)
1569 l
= p
->max_printed
+ 1;
1574 dump_lines (p
, l
, linenumber
);
1575 if (p
->max_printed
< linenumber
)
1576 p
->max_printed
= linenumber
;
1577 p
->last_line
= linenumber
;
1582 if (functionname
!= NULL
1583 && (prev_functionname
== NULL
1584 || strcmp (functionname
, prev_functionname
) != 0))
1586 if (prev_functionname
!= NULL
)
1587 free (prev_functionname
);
1588 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1589 strcpy (prev_functionname
, functionname
);
1592 if (linenumber
> 0 && linenumber
!= prev_line
)
1593 prev_line
= linenumber
;
1595 if (discriminator
!= prev_discriminator
)
1596 prev_discriminator
= discriminator
;
1602 /* Pseudo FILE object for strings. */
1610 /* sprintf to a "stream". */
1612 static int ATTRIBUTE_PRINTF_2
1613 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1620 size_t space
= f
->alloc
- f
->pos
;
1622 va_start (args
, format
);
1623 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1629 f
->alloc
= (f
->alloc
+ n
) * 2;
1630 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1637 /* The number of zeroes we want to see before we start skipping them.
1638 The number is arbitrarily chosen. */
1640 #define DEFAULT_SKIP_ZEROES 8
1642 /* The number of zeroes to skip at the end of a section. If the
1643 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1644 SKIP_ZEROES, they will be disassembled. If there are fewer than
1645 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1646 attempt to avoid disassembling zeroes inserted by section
1649 #define DEFAULT_SKIP_ZEROES_AT_END 3
1651 /* Disassemble some data in memory between given values. */
1654 disassemble_bytes (struct disassemble_info
* inf
,
1655 disassembler_ftype disassemble_fn
,
1658 bfd_vma start_offset
,
1659 bfd_vma stop_offset
,
1662 arelent
** relppend
)
1664 struct objdump_disasm_info
*aux
;
1666 int octets_per_line
;
1667 int skip_addr_chars
;
1668 bfd_vma addr_offset
;
1669 unsigned int opb
= inf
->octets_per_byte
;
1670 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1671 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1675 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1679 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1683 octets_per_line
= insn_width
;
1685 octets_per_line
= 4;
1687 octets_per_line
= 16;
1689 /* Figure out how many characters to skip at the start of an
1690 address, to make the disassembly look nicer. We discard leading
1691 zeroes in chunks of 4, ensuring that there is always a leading
1693 skip_addr_chars
= 0;
1694 if (! prefix_addresses
)
1698 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1700 while (buf
[skip_addr_chars
] == '0')
1703 /* Don't discard zeros on overflow. */
1704 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1705 skip_addr_chars
= 0;
1707 if (skip_addr_chars
!= 0)
1708 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1711 inf
->insn_info_valid
= 0;
1713 addr_offset
= start_offset
;
1714 while (addr_offset
< stop_offset
)
1717 bfd_boolean need_nl
= FALSE
;
1718 int previous_octets
;
1720 /* Remember the length of the previous instruction. */
1721 previous_octets
= octets
;
1724 /* Make sure we don't use relocs from previous instructions. */
1727 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1729 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1732 if (! disassemble_zeroes
1733 && (inf
->insn_info_valid
== 0
1734 || inf
->branch_delay_insns
== 0)
1735 && (z
- addr_offset
* opb
>= skip_zeroes
1736 || (z
== stop_offset
* opb
&&
1737 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1739 /* If there are more nonzero octets to follow, we only skip
1740 zeroes in multiples of 4, to try to avoid running over
1741 the start of an instruction which happens to start with
1743 if (z
!= stop_offset
* opb
)
1744 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1746 octets
= z
- addr_offset
* opb
;
1748 /* If we are going to display more data, and we are displaying
1749 file offsets, then tell the user how many zeroes we skip
1750 and the file offset from where we resume dumping. */
1751 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1752 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1754 (unsigned long) (section
->filepos
1755 + (addr_offset
+ (octets
/ opb
))));
1765 if (with_line_numbers
|| with_source_code
)
1766 show_line (aux
->abfd
, section
, addr_offset
);
1768 if (! prefix_addresses
)
1772 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1773 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1777 printf ("%s:\t", buf
+ skip_addr_chars
);
1781 aux
->require_sec
= TRUE
;
1782 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1783 aux
->require_sec
= FALSE
;
1790 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1791 inf
->stream
= &sfile
;
1792 inf
->bytes_per_line
= 0;
1793 inf
->bytes_per_chunk
= 0;
1794 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1796 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1798 if (inf
->disassembler_needs_relocs
1799 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1800 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1801 && *relppp
< relppend
)
1803 bfd_signed_vma distance_to_rel
;
1805 distance_to_rel
= (**relppp
)->address
1806 - (rel_offset
+ addr_offset
);
1808 /* Check to see if the current reloc is associated with
1809 the instruction that we are about to disassemble. */
1810 if (distance_to_rel
== 0
1811 /* FIXME: This is wrong. We are trying to catch
1812 relocs that are addressed part way through the
1813 current instruction, as might happen with a packed
1814 VLIW instruction. Unfortunately we do not know the
1815 length of the current instruction since we have not
1816 disassembled it yet. Instead we take a guess based
1817 upon the length of the previous instruction. The
1818 proper solution is to have a new target-specific
1819 disassembler function which just returns the length
1820 of an instruction at a given address without trying
1821 to display its disassembly. */
1822 || (distance_to_rel
> 0
1823 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1825 inf
->flags
|= INSN_HAS_RELOC
;
1826 aux
->reloc
= **relppp
;
1830 if (! disassemble_all
1831 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1832 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1833 /* Set a stop_vma so that the disassembler will not read
1834 beyond the next symbol. We assume that symbols appear on
1835 the boundaries between instructions. We only do this when
1836 disassembling code of course, and when -D is in effect. */
1837 inf
->stop_vma
= section
->vma
+ stop_offset
;
1839 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1842 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1843 inf
->stream
= stdout
;
1844 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1845 octets_per_line
= inf
->bytes_per_line
;
1846 if (octets
< (int) opb
)
1849 printf ("%s\n", sfile
.buffer
);
1852 non_fatal (_("disassemble_fn returned length %d"),
1863 octets
= octets_per_line
;
1864 if (addr_offset
+ octets
/ opb
> stop_offset
)
1865 octets
= (stop_offset
- addr_offset
) * opb
;
1867 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1869 if (ISPRINT (data
[j
]))
1870 buf
[j
- addr_offset
* opb
] = data
[j
];
1872 buf
[j
- addr_offset
* opb
] = '.';
1874 buf
[j
- addr_offset
* opb
] = '\0';
1877 if (prefix_addresses
1879 : show_raw_insn
>= 0)
1883 /* If ! prefix_addresses and ! wide_output, we print
1884 octets_per_line octets per line. */
1886 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1887 pb
= octets_per_line
;
1889 if (inf
->bytes_per_chunk
)
1890 bpc
= inf
->bytes_per_chunk
;
1894 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1898 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1900 for (k
= bpc
- 1; k
>= 0; k
--)
1901 printf ("%02x", (unsigned) data
[j
+ k
]);
1906 for (k
= 0; k
< bpc
; k
++)
1907 printf ("%02x", (unsigned) data
[j
+ k
]);
1912 for (; pb
< octets_per_line
; pb
+= bpc
)
1916 for (k
= 0; k
< bpc
; k
++)
1921 /* Separate raw data from instruction by extra space. */
1931 printf ("%s", sfile
.buffer
);
1933 if (prefix_addresses
1935 : show_raw_insn
>= 0)
1943 j
= addr_offset
* opb
+ pb
;
1945 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1946 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1950 printf ("%s:\t", buf
+ skip_addr_chars
);
1952 pb
+= octets_per_line
;
1955 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1959 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1961 for (k
= bpc
- 1; k
>= 0; k
--)
1962 printf ("%02x", (unsigned) data
[j
+ k
]);
1967 for (k
= 0; k
< bpc
; k
++)
1968 printf ("%02x", (unsigned) data
[j
+ k
]);
1981 while ((*relppp
) < relppend
1982 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1984 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1995 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1998 if (q
->howto
== NULL
)
1999 printf (": *unknown*\t");
2000 else if (q
->howto
->name
)
2001 printf (": %s\t", q
->howto
->name
);
2003 printf (": %d\t", q
->howto
->type
);
2005 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2006 printf ("*unknown*");
2009 const char *sym_name
;
2011 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2012 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2013 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2018 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2019 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2020 if (sym_name
== NULL
|| *sym_name
== '\0')
2021 sym_name
= "*unknown*";
2022 printf ("%s", sym_name
);
2028 bfd_signed_vma addend
= q
->addend
;
2036 objdump_print_value (addend
, inf
, TRUE
);
2048 addr_offset
+= octets
/ opb
;
2051 free (sfile
.buffer
);
2055 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2057 const struct elf_backend_data
* bed
;
2058 bfd_vma sign_adjust
= 0;
2059 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2060 struct objdump_disasm_info
* paux
;
2061 unsigned int opb
= pinfo
->octets_per_byte
;
2062 bfd_byte
* data
= NULL
;
2063 bfd_size_type datasize
= 0;
2064 arelent
** rel_pp
= NULL
;
2065 arelent
** rel_ppstart
= NULL
;
2066 arelent
** rel_ppend
;
2067 bfd_vma stop_offset
;
2068 asymbol
* sym
= NULL
;
2072 unsigned long addr_offset
;
2074 /* Sections that do not contain machine
2075 code are not normally disassembled. */
2076 if (! disassemble_all
2077 && only_list
== NULL
2078 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2079 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2082 if (! process_section_p (section
))
2085 datasize
= bfd_get_section_size (section
);
2089 if (start_address
== (bfd_vma
) -1
2090 || start_address
< section
->vma
)
2093 addr_offset
= start_address
- section
->vma
;
2095 if (stop_address
== (bfd_vma
) -1)
2096 stop_offset
= datasize
/ opb
;
2099 if (stop_address
< section
->vma
)
2102 stop_offset
= stop_address
- section
->vma
;
2103 if (stop_offset
> datasize
/ opb
)
2104 stop_offset
= datasize
/ opb
;
2107 if (addr_offset
>= stop_offset
)
2110 /* Decide which set of relocs to use. Load them if necessary. */
2111 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2112 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2114 rel_pp
= paux
->dynrelbuf
;
2115 rel_count
= paux
->dynrelcount
;
2116 /* Dynamic reloc addresses are absolute, non-dynamic are section
2117 relative. REL_OFFSET specifies the reloc address corresponding
2118 to the start of this section. */
2119 rel_offset
= section
->vma
;
2127 if ((section
->flags
& SEC_RELOC
) != 0
2128 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2132 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2134 bfd_fatal (bfd_get_filename (abfd
));
2138 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2139 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2141 bfd_fatal (bfd_get_filename (abfd
));
2143 /* Sort the relocs by address. */
2144 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2148 rel_ppend
= rel_pp
+ rel_count
;
2150 data
= (bfd_byte
*) xmalloc (datasize
);
2152 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2154 paux
->sec
= section
;
2155 pinfo
->buffer
= data
;
2156 pinfo
->buffer_vma
= section
->vma
;
2157 pinfo
->buffer_length
= datasize
;
2158 pinfo
->section
= section
;
2160 /* Skip over the relocs belonging to addresses below the
2162 while (rel_pp
< rel_ppend
2163 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2166 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2168 /* Find the nearest symbol forwards from our current position. */
2169 paux
->require_sec
= TRUE
;
2170 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2171 (struct disassemble_info
*) inf
,
2173 paux
->require_sec
= FALSE
;
2175 /* PR 9774: If the target used signed addresses then we must make
2176 sure that we sign extend the value that we calculate for 'addr'
2177 in the loop below. */
2178 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2179 && (bed
= get_elf_backend_data (abfd
)) != NULL
2180 && bed
->sign_extend_vma
)
2181 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2183 /* Disassemble a block of instructions up to the address associated with
2184 the symbol we have just found. Then print the symbol and find the
2185 next symbol on. Repeat until we have disassembled the entire section
2186 or we have reached the end of the address range we are interested in. */
2187 while (addr_offset
< stop_offset
)
2191 bfd_vma nextstop_offset
;
2194 addr
= section
->vma
+ addr_offset
;
2195 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2197 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2202 (x
< sorted_symcount
2203 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2207 pinfo
->symbols
= sorted_syms
+ place
;
2208 pinfo
->num_symbols
= x
- place
;
2209 pinfo
->symtab_pos
= place
;
2213 pinfo
->symbols
= NULL
;
2214 pinfo
->num_symbols
= 0;
2215 pinfo
->symtab_pos
= -1;
2218 if (! prefix_addresses
)
2220 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2221 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2223 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2226 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2228 else if (sym
== NULL
)
2232 #define is_valid_next_sym(SYM) \
2233 ((SYM)->section == section \
2234 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2235 && pinfo->symbol_is_valid (SYM, pinfo))
2237 /* Search forward for the next appropriate symbol in
2238 SECTION. Note that all the symbols are sorted
2239 together into one big array, and that some sections
2240 may have overlapping addresses. */
2241 while (place
< sorted_symcount
2242 && ! is_valid_next_sym (sorted_syms
[place
]))
2245 if (place
>= sorted_symcount
)
2248 nextsym
= sorted_syms
[place
];
2251 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2252 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2253 else if (nextsym
== NULL
)
2254 nextstop_offset
= stop_offset
;
2256 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2258 if (nextstop_offset
> stop_offset
2259 || nextstop_offset
<= addr_offset
)
2260 nextstop_offset
= stop_offset
;
2262 /* If a symbol is explicitly marked as being an object
2263 rather than a function, just dump the bytes without
2264 disassembling them. */
2267 || sym
->section
!= section
2268 || bfd_asymbol_value (sym
) > addr
2269 || ((sym
->flags
& BSF_OBJECT
) == 0
2270 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2272 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2274 || (sym
->flags
& BSF_FUNCTION
) != 0)
2279 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2280 addr_offset
, nextstop_offset
,
2281 rel_offset
, &rel_pp
, rel_ppend
);
2283 addr_offset
= nextstop_offset
;
2289 if (rel_ppstart
!= NULL
)
2293 /* Disassemble the contents of an object file. */
2296 disassemble_data (bfd
*abfd
)
2298 struct disassemble_info disasm_info
;
2299 struct objdump_disasm_info aux
;
2303 prev_functionname
= NULL
;
2305 prev_discriminator
= 0;
2307 /* We make a copy of syms to sort. We don't want to sort syms
2308 because that will screw up the relocs. */
2309 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2310 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2311 * sizeof (asymbol
*));
2312 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2313 sorted_symcount
* sizeof (asymbol
*));
2315 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2317 for (i
= 0; i
< synthcount
; ++i
)
2319 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2323 /* Sort the symbols into section and symbol order. */
2324 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2326 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2328 disasm_info
.application_data
= (void *) &aux
;
2330 aux
.require_sec
= FALSE
;
2331 aux
.dynrelbuf
= NULL
;
2332 aux
.dynrelcount
= 0;
2335 disasm_info
.print_address_func
= objdump_print_address
;
2336 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2338 if (machine
!= NULL
)
2340 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2343 fatal (_("can't use supplied machine %s"), machine
);
2345 abfd
->arch_info
= inf
;
2348 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2350 struct bfd_target
*xvec
;
2352 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2353 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2354 xvec
->byteorder
= endian
;
2358 /* Use libopcodes to locate a suitable disassembler. */
2359 aux
.disassemble_fn
= disassembler (abfd
);
2360 if (!aux
.disassemble_fn
)
2362 non_fatal (_("can't disassemble for architecture %s\n"),
2363 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2368 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2369 disasm_info
.arch
= bfd_get_arch (abfd
);
2370 disasm_info
.mach
= bfd_get_mach (abfd
);
2371 disasm_info
.disassembler_options
= disassembler_options
;
2372 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2373 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2374 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2375 disasm_info
.disassembler_needs_relocs
= FALSE
;
2377 if (bfd_big_endian (abfd
))
2378 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2379 else if (bfd_little_endian (abfd
))
2380 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2382 /* ??? Aborting here seems too drastic. We could default to big or little
2384 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2386 /* Allow the target to customize the info structure. */
2387 disassemble_init_for_target (& disasm_info
);
2389 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2391 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2393 if (relsize
< 0 && dump_dynamic_reloc_info
)
2394 bfd_fatal (bfd_get_filename (abfd
));
2398 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2399 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2402 if (aux
.dynrelcount
< 0)
2403 bfd_fatal (bfd_get_filename (abfd
));
2405 /* Sort the relocs by address. */
2406 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2410 disasm_info
.symtab
= sorted_syms
;
2411 disasm_info
.symtab_size
= sorted_symcount
;
2413 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2415 if (aux
.dynrelbuf
!= NULL
)
2416 free (aux
.dynrelbuf
);
2421 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2422 asection
*sec
, void *file
)
2424 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2425 bfd
*abfd
= (bfd
*) file
;
2428 /* If it is already loaded, do nothing. */
2429 if (section
->start
!= NULL
)
2432 section
->reloc_info
= NULL
;
2433 section
->num_relocs
= 0;
2434 section
->address
= bfd_get_section_vma (abfd
, sec
);
2435 section
->size
= bfd_get_section_size (sec
);
2436 section
->start
= NULL
;
2437 section
->user_data
= sec
;
2438 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2442 free_debug_section (debug
);
2443 printf (_("\nCan't get contents for section '%s'.\n"),
2448 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2450 bfd_cache_section_contents (sec
, section
->start
);
2452 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2459 free_debug_section (debug
);
2460 printf (_("\nCan't get contents for section '%s'.\n"),
2467 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2470 unsigned long reloc_count
;
2473 relocs
= (arelent
**) xmalloc (reloc_size
);
2475 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2476 if (reloc_count
== 0)
2480 section
->reloc_info
= relocs
;
2481 section
->num_relocs
= reloc_count
;
2490 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2495 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2498 relocs
= (arelent
**) dsec
->reloc_info
;
2500 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2501 if (rp
->address
== offset
)
2508 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2510 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2511 bfd
*abfd
= (bfd
*) file
;
2514 /* If it is already loaded, do nothing. */
2515 if (section
->start
!= NULL
)
2518 /* Locate the debug section. */
2519 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2521 section
->name
= section
->uncompressed_name
;
2524 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2526 section
->name
= section
->compressed_name
;
2531 return load_specific_debug_section (debug
, sec
, file
);
2535 free_debug_section (enum dwarf_section_display_enum debug
)
2537 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2539 if (section
->start
== NULL
)
2542 /* PR 17512: file: 0f67f69d. */
2543 if (section
->user_data
!= NULL
)
2545 asection
* sec
= (asection
*) section
->user_data
;
2547 /* If we are freeing contents that are also pointed to by the BFD
2548 library's section structure then make sure to update those pointers
2549 too. Otherwise, the next time we try to load data for this section
2550 we can end up using a stale pointer. */
2551 if (section
->start
== sec
->contents
)
2553 sec
->contents
= NULL
;
2554 sec
->flags
&= ~ SEC_IN_MEMORY
;
2555 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2559 free ((char *) section
->start
);
2560 section
->start
= NULL
;
2561 section
->address
= 0;
2566 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2567 void *arg ATTRIBUTE_UNUSED
)
2569 const char *name
= bfd_get_section_name (abfd
, section
);
2573 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2574 match
= ".debug_info";
2578 for (i
= 0; i
< max
; i
++)
2579 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2580 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2581 && debug_displays
[i
].enabled
!= NULL
2582 && *debug_displays
[i
].enabled
)
2584 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2586 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2587 sec
->name
= sec
->uncompressed_name
;
2589 sec
->name
= sec
->compressed_name
;
2590 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2593 debug_displays
[i
].display (sec
, abfd
);
2595 if (i
!= info
&& i
!= abbrev
)
2596 free_debug_section ((enum dwarf_section_display_enum
) i
);
2602 /* Dump the dwarf debugging information. */
2605 dump_dwarf (bfd
*abfd
)
2607 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2609 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2611 if (bfd_big_endian (abfd
))
2612 byte_get
= byte_get_big_endian
;
2613 else if (bfd_little_endian (abfd
))
2614 byte_get
= byte_get_little_endian
;
2616 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2618 warn (_("File %s does not contain any dwarf debug information\n"),
2619 bfd_get_filename (abfd
));
2623 switch (bfd_get_arch (abfd
))
2626 switch (bfd_get_mach (abfd
))
2628 case bfd_mach_x86_64
:
2629 case bfd_mach_x86_64_intel_syntax
:
2630 case bfd_mach_x86_64_nacl
:
2631 case bfd_mach_x64_32
:
2632 case bfd_mach_x64_32_intel_syntax
:
2633 case bfd_mach_x64_32_nacl
:
2634 init_dwarf_regnames_x86_64 ();
2638 init_dwarf_regnames_i386 ();
2643 case bfd_arch_iamcu
:
2644 init_dwarf_regnames_iamcu ();
2647 case bfd_arch_aarch64
:
2648 init_dwarf_regnames_aarch64();
2652 init_dwarf_regnames_s390 ();
2659 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2661 free_debug_memory ();
2664 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2665 it. Return NULL on failure. */
2668 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2674 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2675 if (stabsect
== NULL
)
2677 printf (_("No %s section present\n\n"), sect_name
);
2681 size
= bfd_section_size (abfd
, stabsect
);
2682 contents
= (char *) xmalloc (size
);
2684 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2686 non_fatal (_("reading %s section of %s failed: %s"),
2687 sect_name
, bfd_get_filename (abfd
),
2688 bfd_errmsg (bfd_get_error ()));
2699 /* Stabs entries use a 12 byte format:
2700 4 byte string table index
2702 1 byte stab other field
2703 2 byte stab desc field
2705 FIXME: This will have to change for a 64 bit object format. */
2707 #define STRDXOFF (0)
2709 #define OTHEROFF (5)
2712 #define STABSIZE (12)
2714 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2715 using string table section STRSECT_NAME (in `strtab'). */
2718 print_section_stabs (bfd
*abfd
,
2719 const char *stabsect_name
,
2720 unsigned *string_offset_ptr
)
2723 unsigned file_string_table_offset
= 0;
2724 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2725 bfd_byte
*stabp
, *stabs_end
;
2728 stabs_end
= stabp
+ stab_size
;
2730 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2731 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2733 /* Loop through all symbols and print them.
2735 We start the index at -1 because there is a dummy symbol on
2736 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2737 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2741 unsigned char type
, other
;
2742 unsigned short desc
;
2745 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2746 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2747 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2748 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2749 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2751 printf ("\n%-6d ", i
);
2752 /* Either print the stab name, or, if unnamed, print its number
2753 again (makes consistent formatting for tools like awk). */
2754 name
= bfd_get_stab_name (type
);
2756 printf ("%-6s", name
);
2757 else if (type
== N_UNDF
)
2760 printf ("%-6d", type
);
2761 printf (" %-6d %-6d ", other
, desc
);
2762 bfd_printf_vma (abfd
, value
);
2763 printf (" %-6lu", strx
);
2765 /* Symbols with type == 0 (N_UNDF) specify the length of the
2766 string table associated with this file. We use that info
2767 to know how to relocate the *next* file's string table indices. */
2770 file_string_table_offset
= next_file_string_table_offset
;
2771 next_file_string_table_offset
+= value
;
2775 bfd_size_type amt
= strx
+ file_string_table_offset
;
2777 /* Using the (possibly updated) string table offset, print the
2778 string (if any) associated with this symbol. */
2779 if (amt
< stabstr_size
)
2780 /* PR 17512: file: 079-79389-0.001:0.1. */
2781 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2787 *string_offset_ptr
= next_file_string_table_offset
;
2792 const char * section_name
;
2793 const char * string_section_name
;
2794 unsigned string_offset
;
2799 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2802 stab_section_names
* sought
= (stab_section_names
*) names
;
2804 /* Check for section names for which stabsect_name is a prefix, to
2805 handle .stab.N, etc. */
2806 len
= strlen (sought
->section_name
);
2808 /* If the prefix matches, and the files section name ends with a
2809 nul or a digit, then we match. I.e., we want either an exact
2810 match or a section followed by a number. */
2811 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2812 && (section
->name
[len
] == 0
2813 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2816 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2821 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2824 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2830 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2832 stab_section_names s
;
2834 s
.section_name
= stabsect_name
;
2835 s
.string_section_name
= strsect_name
;
2836 s
.string_offset
= 0;
2838 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2844 /* Dump the any sections containing stabs debugging information. */
2847 dump_stabs (bfd
*abfd
)
2849 dump_stabs_section (abfd
, ".stab", ".stabstr");
2850 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2851 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2854 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2856 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2860 dump_bfd_header (bfd
*abfd
)
2864 printf (_("architecture: %s, "),
2865 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2866 bfd_get_mach (abfd
)));
2867 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2869 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2870 PF (HAS_RELOC
, "HAS_RELOC");
2871 PF (EXEC_P
, "EXEC_P");
2872 PF (HAS_LINENO
, "HAS_LINENO");
2873 PF (HAS_DEBUG
, "HAS_DEBUG");
2874 PF (HAS_SYMS
, "HAS_SYMS");
2875 PF (HAS_LOCALS
, "HAS_LOCALS");
2876 PF (DYNAMIC
, "DYNAMIC");
2877 PF (WP_TEXT
, "WP_TEXT");
2878 PF (D_PAGED
, "D_PAGED");
2879 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2880 printf (_("\nstart address 0x"));
2881 bfd_printf_vma (abfd
, abfd
->start_address
);
2887 dump_bfd_private_header (bfd
*abfd
)
2889 bfd_print_private_bfd_data (abfd
, stdout
);
2893 dump_target_specific (bfd
*abfd
)
2895 const struct objdump_private_desc
* const *desc
;
2896 struct objdump_private_option
*opt
;
2899 /* Find the desc. */
2900 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2901 if ((*desc
)->filter (abfd
))
2906 non_fatal (_("option -P/--private not supported by this file"));
2910 /* Clear all options. */
2911 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2912 opt
->selected
= FALSE
;
2914 /* Decode options. */
2915 b
= dump_private_options
;
2918 e
= strchr (b
, ',');
2923 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2924 if (strcmp (opt
->name
, b
) == 0)
2926 opt
->selected
= TRUE
;
2929 if (opt
->name
== NULL
)
2930 non_fatal (_("target specific dump '%s' not supported"), b
);
2941 (*desc
)->dump (abfd
);
2944 /* Display a section in hexadecimal format with associated characters.
2945 Each line prefixed by the zero padded address. */
2948 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2951 bfd_size_type datasize
;
2952 bfd_vma addr_offset
;
2953 bfd_vma start_offset
;
2954 bfd_vma stop_offset
;
2955 unsigned int opb
= bfd_octets_per_byte (abfd
);
2956 /* Bytes per line. */
2957 const int onaline
= 16;
2962 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2965 if (! process_section_p (section
))
2968 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2971 /* Compute the address range to display. */
2972 if (start_address
== (bfd_vma
) -1
2973 || start_address
< section
->vma
)
2976 start_offset
= start_address
- section
->vma
;
2978 if (stop_address
== (bfd_vma
) -1)
2979 stop_offset
= datasize
/ opb
;
2982 if (stop_address
< section
->vma
)
2985 stop_offset
= stop_address
- section
->vma
;
2987 if (stop_offset
> datasize
/ opb
)
2988 stop_offset
= datasize
/ opb
;
2991 if (start_offset
>= stop_offset
)
2994 printf (_("Contents of section %s:"), section
->name
);
2995 if (display_file_offsets
)
2996 printf (_(" (Starting at file offset: 0x%lx)"),
2997 (unsigned long) (section
->filepos
+ start_offset
));
3000 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3002 non_fatal (_("Reading section %s failed because: %s"),
3003 section
->name
, bfd_errmsg (bfd_get_error ()));
3009 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3010 if (strlen (buf
) >= sizeof (buf
))
3014 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3016 count
= strlen (buf
) - count
;
3020 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3021 if (strlen (buf
) >= sizeof (buf
))
3025 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3027 count
= strlen (buf
) - count
;
3031 for (addr_offset
= start_offset
;
3032 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3036 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3037 count
= strlen (buf
);
3038 if ((size_t) count
>= sizeof (buf
))
3042 while (count
< width
)
3047 fputs (buf
+ count
- width
, stdout
);
3050 for (j
= addr_offset
* opb
;
3051 j
< addr_offset
* opb
+ onaline
; j
++)
3053 if (j
< stop_offset
* opb
)
3054 printf ("%02x", (unsigned) (data
[j
]));
3062 for (j
= addr_offset
* opb
;
3063 j
< addr_offset
* opb
+ onaline
; j
++)
3065 if (j
>= stop_offset
* opb
)
3068 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3075 /* Actually display the various requested regions. */
3078 dump_data (bfd
*abfd
)
3080 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3083 /* Should perhaps share code and display with nm? */
3086 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3095 max_count
= dynsymcount
;
3096 printf ("DYNAMIC SYMBOL TABLE:\n");
3101 max_count
= symcount
;
3102 printf ("SYMBOL TABLE:\n");
3106 printf (_("no symbols\n"));
3108 for (count
= 0; count
< max_count
; count
++)
3112 if (*current
== NULL
)
3113 printf (_("no information for symbol number %ld\n"), count
);
3115 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3116 printf (_("could not determine the type of symbol number %ld\n"),
3119 else if (process_section_p ((* current
)->section
)
3120 && (dump_special_syms
3121 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3123 const char *name
= (*current
)->name
;
3125 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3129 /* If we want to demangle the name, we demangle it
3130 here, and temporarily clobber it while calling
3131 bfd_print_symbol. FIXME: This is a gross hack. */
3132 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3134 (*current
)->name
= alloc
;
3135 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3136 bfd_print_symbol_all
);
3139 (*current
)->name
= name
;
3144 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3145 bfd_print_symbol_all
);
3155 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3158 char *last_filename
, *last_functionname
;
3159 unsigned int last_line
;
3160 unsigned int last_discriminator
;
3162 /* Get column headers lined up reasonably. */
3170 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3171 width
= strlen (buf
) - 7;
3173 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3176 last_filename
= NULL
;
3177 last_functionname
= NULL
;
3179 last_discriminator
= 0;
3181 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3184 const char *filename
, *functionname
;
3185 unsigned int linenumber
;
3186 unsigned int discriminator
;
3187 const char *sym_name
;
3188 const char *section_name
;
3189 bfd_vma addend2
= 0;
3191 if (start_address
!= (bfd_vma
) -1
3192 && q
->address
< start_address
)
3194 if (stop_address
!= (bfd_vma
) -1
3195 && q
->address
> stop_address
)
3198 if (with_line_numbers
3200 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3201 &filename
, &functionname
,
3202 &linenumber
, &discriminator
))
3204 if (functionname
!= NULL
3205 && (last_functionname
== NULL
3206 || strcmp (functionname
, last_functionname
) != 0))
3208 printf ("%s():\n", functionname
);
3209 if (last_functionname
!= NULL
)
3210 free (last_functionname
);
3211 last_functionname
= xstrdup (functionname
);
3215 && (linenumber
!= last_line
3216 || (filename
!= NULL
3217 && last_filename
!= NULL
3218 && filename_cmp (filename
, last_filename
) != 0)
3219 || (discriminator
!= last_discriminator
)))
3221 if (discriminator
> 0)
3222 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3224 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3225 linenumber
, discriminator
);
3226 last_line
= linenumber
;
3227 last_discriminator
= discriminator
;
3228 if (last_filename
!= NULL
)
3229 free (last_filename
);
3230 if (filename
== NULL
)
3231 last_filename
= NULL
;
3233 last_filename
= xstrdup (filename
);
3237 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3239 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3240 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3245 section_name
= NULL
;
3248 bfd_printf_vma (abfd
, q
->address
);
3249 if (q
->howto
== NULL
)
3250 printf (" *unknown* ");
3251 else if (q
->howto
->name
)
3253 const char *name
= q
->howto
->name
;
3255 /* R_SPARC_OLO10 relocations contain two addends.
3256 But because 'arelent' lacks enough storage to
3257 store them both, the 64-bit ELF Sparc backend
3258 records this as two relocations. One R_SPARC_LO10
3259 and one R_SPARC_13, both pointing to the same
3260 address. This is merely so that we have some
3261 place to store both addend fields.
3263 Undo this transformation, otherwise the output
3264 will be confusing. */
3265 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3266 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3268 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3270 arelent
*q2
= *(p
+ 1);
3273 && q
->address
== q2
->address
3274 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3276 name
= "R_SPARC_OLO10";
3277 addend2
= q2
->addend
;
3281 printf (" %-16s ", name
);
3284 printf (" %-16d ", q
->howto
->type
);
3288 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3292 if (section_name
== NULL
)
3293 section_name
= "*unknown*";
3294 printf ("[%s]", section_name
);
3299 bfd_signed_vma addend
= q
->addend
;
3307 bfd_printf_vma (abfd
, addend
);
3312 bfd_printf_vma (abfd
, addend2
);
3318 if (last_filename
!= NULL
)
3319 free (last_filename
);
3320 if (last_functionname
!= NULL
)
3321 free (last_functionname
);
3325 dump_relocs_in_section (bfd
*abfd
,
3327 void *dummy ATTRIBUTE_UNUSED
)
3333 if ( bfd_is_abs_section (section
)
3334 || bfd_is_und_section (section
)
3335 || bfd_is_com_section (section
)
3336 || (! process_section_p (section
))
3337 || ((section
->flags
& SEC_RELOC
) == 0))
3340 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3342 bfd_fatal (bfd_get_filename (abfd
));
3344 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3348 printf (" (none)\n\n");
3352 relpp
= (arelent
**) xmalloc (relsize
);
3353 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3358 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3359 bfd_fatal (_("error message was"));
3361 else if (relcount
== 0)
3362 printf (" (none)\n\n");
3366 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3373 dump_relocs (bfd
*abfd
)
3375 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3379 dump_dynamic_relocs (bfd
*abfd
)
3385 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3387 bfd_fatal (bfd_get_filename (abfd
));
3389 printf ("DYNAMIC RELOCATION RECORDS");
3392 printf (" (none)\n\n");
3395 relpp
= (arelent
**) xmalloc (relsize
);
3396 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3399 bfd_fatal (bfd_get_filename (abfd
));
3400 else if (relcount
== 0)
3401 printf (" (none)\n\n");
3405 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3412 /* Creates a table of paths, to search for source files. */
3415 add_include_path (const char *path
)
3419 include_path_count
++;
3420 include_paths
= (const char **)
3421 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3422 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3423 if (path
[1] == ':' && path
[2] == 0)
3424 path
= concat (path
, ".", (const char *) 0);
3426 include_paths
[include_path_count
- 1] = path
;
3430 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3434 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3436 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3437 section
->vma
+= adjust_section_vma
;
3439 section
->lma
+= adjust_section_vma
;
3443 /* Dump selected contents of ABFD. */
3446 dump_bfd (bfd
*abfd
)
3448 /* If we are adjusting section VMA's, change them all now. Changing
3449 the BFD information is a hack. However, we must do it, or
3450 bfd_find_nearest_line will not do the right thing. */
3451 if (adjust_section_vma
!= 0)
3453 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3454 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3457 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3458 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3461 print_arelt_descr (stdout
, abfd
, TRUE
);
3462 if (dump_file_header
)
3463 dump_bfd_header (abfd
);
3464 if (dump_private_headers
)
3465 dump_bfd_private_header (abfd
);
3466 if (dump_private_options
!= NULL
)
3467 dump_target_specific (abfd
);
3468 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3475 || dump_dwarf_section_info
)
3476 syms
= slurp_symtab (abfd
);
3478 if (dump_section_headers
)
3479 dump_headers (abfd
);
3481 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3482 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3483 dynsyms
= slurp_dynamic_symtab (abfd
);
3486 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3487 dynsymcount
, dynsyms
, &synthsyms
);
3493 dump_symbols (abfd
, FALSE
);
3494 if (dump_dynamic_symtab
)
3495 dump_symbols (abfd
, TRUE
);
3496 if (dump_dwarf_section_info
)
3498 if (dump_stab_section_info
)
3500 if (dump_reloc_info
&& ! disassemble
)
3502 if (dump_dynamic_reloc_info
&& ! disassemble
)
3503 dump_dynamic_relocs (abfd
);
3504 if (dump_section_contents
)
3507 disassemble_data (abfd
);
3513 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3514 if (dhandle
!= NULL
)
3516 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3518 dump_debugging_tags
? TRUE
: FALSE
))
3520 non_fatal (_("%s: printing debugging information failed"),
3521 bfd_get_filename (abfd
));
3525 /* PR 6483: If there was no STABS or IEEE debug
3526 info in the file, try DWARF instead. */
3527 else if (! dump_dwarf_section_info
)
3529 dwarf_select_sections_all ();
3558 display_object_bfd (bfd
*abfd
)
3562 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3568 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3570 nonfatal (bfd_get_filename (abfd
));
3571 list_matching_formats (matching
);
3576 if (bfd_get_error () != bfd_error_file_not_recognized
)
3578 nonfatal (bfd_get_filename (abfd
));
3582 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3588 nonfatal (bfd_get_filename (abfd
));
3590 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3592 list_matching_formats (matching
);
3598 display_any_bfd (bfd
*file
, int level
)
3600 /* Decompress sections unless dumping the section contents. */
3601 if (!dump_section_contents
)
3602 file
->flags
|= BFD_DECOMPRESS
;
3604 /* If the file is an archive, process all of its elements. */
3605 if (bfd_check_format (file
, bfd_archive
))
3608 bfd
*last_arfile
= NULL
;
3611 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3612 else if (level
> 100)
3614 /* Prevent corrupted files from spinning us into an
3615 infinite loop. 100 is an arbitrary heuristic. */
3616 fatal (_("Archive nesting is too deep"));
3620 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3624 bfd_set_error (bfd_error_no_error
);
3626 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3629 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3630 nonfatal (bfd_get_filename (file
));
3634 display_any_bfd (arfile
, level
+ 1);
3636 if (last_arfile
!= NULL
)
3638 bfd_close (last_arfile
);
3639 /* PR 17512: file: ac585d01. */
3640 if (arfile
== last_arfile
)
3646 last_arfile
= arfile
;
3649 if (last_arfile
!= NULL
)
3650 bfd_close (last_arfile
);
3653 display_object_bfd (file
);
3657 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3661 if (get_file_size (filename
) < 1)
3667 file
= bfd_openr (filename
, target
);
3670 nonfatal (filename
);
3674 display_any_bfd (file
, 0);
3676 /* This is an optimization to improve the speed of objdump, especially when
3677 dumping a file with lots of associated debug informatiom. Calling
3678 bfd_close on such a file can take a non-trivial amount of time as there
3679 are lots of lists to walk and buffers to free. This is only really
3680 necessary however if we are about to load another file and we need the
3681 memory back. Otherwise, if we are about to exit, then we can save (a lot
3682 of) time by only doing a quick close, and allowing the OS to reclaim the
3687 bfd_close_all_done (file
);
3691 main (int argc
, char **argv
)
3694 char *target
= default_target
;
3695 bfd_boolean seenflag
= FALSE
;
3697 #if defined (HAVE_SETLOCALE)
3698 #if defined (HAVE_LC_MESSAGES)
3699 setlocale (LC_MESSAGES
, "");
3701 setlocale (LC_CTYPE
, "");
3704 bindtextdomain (PACKAGE
, LOCALEDIR
);
3705 textdomain (PACKAGE
);
3707 program_name
= *argv
;
3708 xmalloc_set_program_name (program_name
);
3709 bfd_set_error_program_name (program_name
);
3711 START_PROGRESS (program_name
, 0);
3713 expandargv (&argc
, &argv
);
3716 set_default_bfd_target ();
3718 while ((c
= getopt_long (argc
, argv
,
3719 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3720 long_options
, (int *) 0))
3726 break; /* We've been given a long option. */
3731 if (disassembler_options
)
3732 /* Ignore potential memory leak for now. */
3733 disassembler_options
= concat (disassembler_options
, ",",
3734 optarg
, (const char *) NULL
);
3736 disassembler_options
= optarg
;
3742 display_file_offsets
= TRUE
;
3745 with_line_numbers
= TRUE
;
3754 enum demangling_styles style
;
3756 style
= cplus_demangle_name_to_style (optarg
);
3757 if (style
== unknown_demangling
)
3758 fatal (_("unknown demangling style `%s'"),
3761 cplus_demangle_set_style (style
);
3767 case OPTION_ADJUST_VMA
:
3768 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3770 case OPTION_START_ADDRESS
:
3771 start_address
= parse_vma (optarg
, "--start-address");
3772 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3773 fatal (_("error: the start address should be before the end address"));
3775 case OPTION_STOP_ADDRESS
:
3776 stop_address
= parse_vma (optarg
, "--stop-address");
3777 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3778 fatal (_("error: the stop address should be after the start address"));
3782 prefix_length
= strlen (prefix
);
3783 /* Remove an unnecessary trailing '/' */
3784 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3787 case OPTION_PREFIX_STRIP
:
3788 prefix_strip
= atoi (optarg
);
3789 if (prefix_strip
< 0)
3790 fatal (_("error: prefix strip must be non-negative"));
3792 case OPTION_INSN_WIDTH
:
3793 insn_width
= strtoul (optarg
, NULL
, 0);
3794 if (insn_width
<= 0)
3795 fatal (_("error: instruction width must be positive"));
3798 if (strcmp (optarg
, "B") == 0)
3799 endian
= BFD_ENDIAN_BIG
;
3800 else if (strcmp (optarg
, "L") == 0)
3801 endian
= BFD_ENDIAN_LITTLE
;
3804 nonfatal (_("unrecognized -E option"));
3809 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3810 endian
= BFD_ENDIAN_BIG
;
3811 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3812 endian
= BFD_ENDIAN_LITTLE
;
3815 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3822 dump_file_header
= TRUE
;
3826 formats_info
= TRUE
;
3830 add_include_path (optarg
);
3833 dump_private_headers
= TRUE
;
3837 dump_private_options
= optarg
;
3841 dump_private_headers
= TRUE
;
3843 dump_reloc_info
= TRUE
;
3844 dump_file_header
= TRUE
;
3845 dump_ar_hdrs
= TRUE
;
3846 dump_section_headers
= TRUE
;
3854 dump_dynamic_symtab
= TRUE
;
3862 disassemble_zeroes
= TRUE
;
3866 disassemble_all
= TRUE
;
3871 with_source_code
= TRUE
;
3880 dump_debugging_tags
= 1;
3885 dump_dwarf_section_info
= TRUE
;
3888 dwarf_select_sections_by_letters (optarg
);
3890 dwarf_select_sections_all ();
3893 dump_dwarf_section_info
= TRUE
;
3896 dwarf_select_sections_by_names (optarg
);
3898 dwarf_select_sections_all ();
3900 case OPTION_DWARF_DEPTH
:
3903 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3906 case OPTION_DWARF_START
:
3909 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3910 suppress_bfd_header
= 1;
3913 case OPTION_DWARF_CHECK
:
3917 dump_stab_section_info
= TRUE
;
3921 dump_section_contents
= TRUE
;
3925 dump_reloc_info
= TRUE
;
3929 dump_dynamic_reloc_info
= TRUE
;
3933 dump_ar_hdrs
= TRUE
;
3937 dump_section_headers
= TRUE
;
3942 show_version
= TRUE
;
3948 /* No need to set seenflag or to break - usage() does not return. */
3955 print_version ("objdump");
3961 exit_status
= display_info ();
3965 display_file ("a.out", target
, TRUE
);
3967 for (; optind
< argc
;)
3969 display_file (argv
[optind
], target
, optind
== argc
- 1);
3976 END_PROGRESS (program_name
);