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
, struct stat
*fst
)
1269 int ps
= getpagesize ();
1273 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1277 if (fstat (fd
, fst
) < 0)
1282 *size
= fst
->st_size
;
1284 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1285 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1286 if (map
!= (char *) -1L)
1292 map
= (const char *) malloc (*size
);
1293 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1295 free ((void *) map
);
1302 #define line_map_decrease 5
1304 /* Precompute array of lines for a mapped file. */
1306 static const char **
1307 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1309 const char *p
, *lstart
, *end
;
1310 int chars_per_line
= 45; /* First iteration will use 40. */
1311 unsigned int lineno
;
1312 const char **linemap
= NULL
;
1313 unsigned long line_map_size
= 0;
1319 for (p
= map
; p
< end
; p
++)
1323 if (p
+ 1 < end
&& p
[1] == '\r')
1326 else if (*p
== '\r')
1328 if (p
+ 1 < end
&& p
[1] == '\n')
1334 /* End of line found. */
1336 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1338 unsigned long newsize
;
1340 chars_per_line
-= line_map_decrease
;
1341 if (chars_per_line
<= 1)
1343 line_map_size
= size
/ chars_per_line
+ 1;
1344 if (line_map_size
< lineno
+ 1)
1345 line_map_size
= lineno
+ 1;
1346 newsize
= line_map_size
* sizeof (char *);
1347 linemap
= (const char **) xrealloc (linemap
, newsize
);
1350 linemap
[lineno
++] = lstart
;
1358 /* Tries to open MODNAME, and if successful adds a node to print_files
1359 linked list and returns that node. Returns NULL on failure. */
1361 static struct print_file_list
*
1362 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1364 struct print_file_list
*p
;
1366 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1368 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1375 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1378 p
->filename
= origname
;
1379 p
->modname
= modname
;
1380 p
->next
= print_files
;
1386 /* If the source file, as described in the symtab, is not found
1387 try to locate it in one of the paths specified with -I
1388 If found, add location to print_files linked list. */
1390 static struct print_file_list
*
1391 update_source_path (const char *filename
, bfd
*abfd
)
1393 struct print_file_list
*p
;
1398 p
= try_print_file_open (filename
, filename
, &fst
);
1401 if (include_path_count
== 0)
1404 /* Get the name of the file. */
1405 fname
= lbasename (filename
);
1407 /* If file exists under a new path, we need to add it to the list
1408 so that show_line knows about it. */
1409 for (i
= 0; i
< include_path_count
; i
++)
1411 char *modname
= concat (include_paths
[i
], "/", fname
,
1414 p
= try_print_file_open (filename
, modname
, &fst
);
1424 long mtime
= bfd_get_mtime (abfd
);
1426 if (fst
.st_mtime
> mtime
)
1427 warn (_("source file %s is more recent than object file\n"),
1434 /* Print a source file line. */
1437 print_line (struct print_file_list
*p
, unsigned int linenum
)
1443 if (linenum
>= p
->maxline
)
1445 l
= p
->linemap
[linenum
];
1446 /* Test fwrite return value to quiet glibc warning. */
1447 len
= strcspn (l
, "\n\r");
1448 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1452 /* Print a range of source code lines. */
1455 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1459 while (start
<= end
)
1461 print_line (p
, start
);
1466 /* Show the line number, or the source line, in a disassembly
1470 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1472 const char *filename
;
1473 const char *functionname
;
1474 unsigned int linenumber
;
1475 unsigned int discriminator
;
1479 if (! with_line_numbers
&& ! with_source_code
)
1482 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1483 &filename
, &functionname
,
1484 &linenumber
, &discriminator
))
1487 if (filename
!= NULL
&& *filename
== '\0')
1489 if (functionname
!= NULL
&& *functionname
== '\0')
1490 functionname
= NULL
;
1493 && IS_ABSOLUTE_PATH (filename
)
1497 const char *fname
= filename
;
1499 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1502 memcpy (path
, prefix
, prefix_length
);
1503 path_up
= path
+ prefix_length
;
1505 /* Build relocated filename, stripping off leading directories
1506 from the initial filename if requested. */
1507 if (prefix_strip
> 0)
1512 /* Skip selected directory levels. */
1513 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1514 if (IS_DIR_SEPARATOR(*s
))
1521 /* Update complete filename. */
1522 strncpy (path_up
, fname
, PATH_MAX
);
1523 path_up
[PATH_MAX
] = '\0';
1531 if (with_line_numbers
)
1533 if (functionname
!= NULL
1534 && (prev_functionname
== NULL
1535 || strcmp (functionname
, prev_functionname
) != 0))
1536 printf ("%s():\n", functionname
);
1537 if (linenumber
> 0 && (linenumber
!= prev_line
||
1538 (discriminator
!= prev_discriminator
)))
1540 if (discriminator
> 0)
1541 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1542 linenumber
, discriminator
);
1544 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1548 if (with_source_code
1552 struct print_file_list
**pp
, *p
;
1555 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1556 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1563 filename
= xstrdup (filename
);
1564 p
= update_source_path (filename
, abfd
);
1567 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1569 if (file_start_context
&& p
->first
)
1573 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1574 if (l
>= linenumber
)
1576 if (p
->max_printed
>= l
)
1578 if (p
->max_printed
< linenumber
)
1579 l
= p
->max_printed
+ 1;
1584 dump_lines (p
, l
, linenumber
);
1585 if (p
->max_printed
< linenumber
)
1586 p
->max_printed
= linenumber
;
1587 p
->last_line
= linenumber
;
1592 if (functionname
!= NULL
1593 && (prev_functionname
== NULL
1594 || strcmp (functionname
, prev_functionname
) != 0))
1596 if (prev_functionname
!= NULL
)
1597 free (prev_functionname
);
1598 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1599 strcpy (prev_functionname
, functionname
);
1602 if (linenumber
> 0 && linenumber
!= prev_line
)
1603 prev_line
= linenumber
;
1605 if (discriminator
!= prev_discriminator
)
1606 prev_discriminator
= discriminator
;
1612 /* Pseudo FILE object for strings. */
1620 /* sprintf to a "stream". */
1622 static int ATTRIBUTE_PRINTF_2
1623 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1630 size_t space
= f
->alloc
- f
->pos
;
1632 va_start (args
, format
);
1633 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1639 f
->alloc
= (f
->alloc
+ n
) * 2;
1640 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1647 /* The number of zeroes we want to see before we start skipping them.
1648 The number is arbitrarily chosen. */
1650 #define DEFAULT_SKIP_ZEROES 8
1652 /* The number of zeroes to skip at the end of a section. If the
1653 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1654 SKIP_ZEROES, they will be disassembled. If there are fewer than
1655 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1656 attempt to avoid disassembling zeroes inserted by section
1659 #define DEFAULT_SKIP_ZEROES_AT_END 3
1661 /* Disassemble some data in memory between given values. */
1664 disassemble_bytes (struct disassemble_info
* inf
,
1665 disassembler_ftype disassemble_fn
,
1668 bfd_vma start_offset
,
1669 bfd_vma stop_offset
,
1672 arelent
** relppend
)
1674 struct objdump_disasm_info
*aux
;
1676 int octets_per_line
;
1677 int skip_addr_chars
;
1678 bfd_vma addr_offset
;
1679 unsigned int opb
= inf
->octets_per_byte
;
1680 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1681 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1685 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1689 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1693 octets_per_line
= insn_width
;
1695 octets_per_line
= 4;
1697 octets_per_line
= 16;
1699 /* Figure out how many characters to skip at the start of an
1700 address, to make the disassembly look nicer. We discard leading
1701 zeroes in chunks of 4, ensuring that there is always a leading
1703 skip_addr_chars
= 0;
1704 if (! prefix_addresses
)
1708 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1710 while (buf
[skip_addr_chars
] == '0')
1713 /* Don't discard zeros on overflow. */
1714 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1715 skip_addr_chars
= 0;
1717 if (skip_addr_chars
!= 0)
1718 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1721 inf
->insn_info_valid
= 0;
1723 addr_offset
= start_offset
;
1724 while (addr_offset
< stop_offset
)
1727 bfd_boolean need_nl
= FALSE
;
1728 int previous_octets
;
1730 /* Remember the length of the previous instruction. */
1731 previous_octets
= octets
;
1734 /* Make sure we don't use relocs from previous instructions. */
1737 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1739 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1742 if (! disassemble_zeroes
1743 && (inf
->insn_info_valid
== 0
1744 || inf
->branch_delay_insns
== 0)
1745 && (z
- addr_offset
* opb
>= skip_zeroes
1746 || (z
== stop_offset
* opb
&&
1747 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1749 /* If there are more nonzero octets to follow, we only skip
1750 zeroes in multiples of 4, to try to avoid running over
1751 the start of an instruction which happens to start with
1753 if (z
!= stop_offset
* opb
)
1754 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1756 octets
= z
- addr_offset
* opb
;
1758 /* If we are going to display more data, and we are displaying
1759 file offsets, then tell the user how many zeroes we skip
1760 and the file offset from where we resume dumping. */
1761 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1762 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1764 (unsigned long) (section
->filepos
1765 + (addr_offset
+ (octets
/ opb
))));
1775 if (with_line_numbers
|| with_source_code
)
1776 show_line (aux
->abfd
, section
, addr_offset
);
1778 if (! prefix_addresses
)
1782 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1783 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1787 printf ("%s:\t", buf
+ skip_addr_chars
);
1791 aux
->require_sec
= TRUE
;
1792 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1793 aux
->require_sec
= FALSE
;
1800 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1801 inf
->stream
= &sfile
;
1802 inf
->bytes_per_line
= 0;
1803 inf
->bytes_per_chunk
= 0;
1804 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1806 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1808 if (inf
->disassembler_needs_relocs
1809 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1810 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1811 && *relppp
< relppend
)
1813 bfd_signed_vma distance_to_rel
;
1815 distance_to_rel
= (**relppp
)->address
1816 - (rel_offset
+ addr_offset
);
1818 /* Check to see if the current reloc is associated with
1819 the instruction that we are about to disassemble. */
1820 if (distance_to_rel
== 0
1821 /* FIXME: This is wrong. We are trying to catch
1822 relocs that are addressed part way through the
1823 current instruction, as might happen with a packed
1824 VLIW instruction. Unfortunately we do not know the
1825 length of the current instruction since we have not
1826 disassembled it yet. Instead we take a guess based
1827 upon the length of the previous instruction. The
1828 proper solution is to have a new target-specific
1829 disassembler function which just returns the length
1830 of an instruction at a given address without trying
1831 to display its disassembly. */
1832 || (distance_to_rel
> 0
1833 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1835 inf
->flags
|= INSN_HAS_RELOC
;
1836 aux
->reloc
= **relppp
;
1840 if (! disassemble_all
1841 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1842 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1843 /* Set a stop_vma so that the disassembler will not read
1844 beyond the next symbol. We assume that symbols appear on
1845 the boundaries between instructions. We only do this when
1846 disassembling code of course, and when -D is in effect. */
1847 inf
->stop_vma
= section
->vma
+ stop_offset
;
1849 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1852 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1853 inf
->stream
= stdout
;
1854 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1855 octets_per_line
= inf
->bytes_per_line
;
1856 if (octets
< (int) opb
)
1859 printf ("%s\n", sfile
.buffer
);
1862 non_fatal (_("disassemble_fn returned length %d"),
1873 octets
= octets_per_line
;
1874 if (addr_offset
+ octets
/ opb
> stop_offset
)
1875 octets
= (stop_offset
- addr_offset
) * opb
;
1877 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1879 if (ISPRINT (data
[j
]))
1880 buf
[j
- addr_offset
* opb
] = data
[j
];
1882 buf
[j
- addr_offset
* opb
] = '.';
1884 buf
[j
- addr_offset
* opb
] = '\0';
1887 if (prefix_addresses
1889 : show_raw_insn
>= 0)
1893 /* If ! prefix_addresses and ! wide_output, we print
1894 octets_per_line octets per line. */
1896 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1897 pb
= octets_per_line
;
1899 if (inf
->bytes_per_chunk
)
1900 bpc
= inf
->bytes_per_chunk
;
1904 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1908 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1910 for (k
= bpc
- 1; k
>= 0; k
--)
1911 printf ("%02x", (unsigned) data
[j
+ k
]);
1916 for (k
= 0; k
< bpc
; k
++)
1917 printf ("%02x", (unsigned) data
[j
+ k
]);
1922 for (; pb
< octets_per_line
; pb
+= bpc
)
1926 for (k
= 0; k
< bpc
; k
++)
1931 /* Separate raw data from instruction by extra space. */
1941 printf ("%s", sfile
.buffer
);
1943 if (prefix_addresses
1945 : show_raw_insn
>= 0)
1953 j
= addr_offset
* opb
+ pb
;
1955 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1956 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1960 printf ("%s:\t", buf
+ skip_addr_chars
);
1962 pb
+= octets_per_line
;
1965 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1969 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1971 for (k
= bpc
- 1; k
>= 0; k
--)
1972 printf ("%02x", (unsigned) data
[j
+ k
]);
1977 for (k
= 0; k
< bpc
; k
++)
1978 printf ("%02x", (unsigned) data
[j
+ k
]);
1991 while ((*relppp
) < relppend
1992 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1994 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2005 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2008 if (q
->howto
== NULL
)
2009 printf (": *unknown*\t");
2010 else if (q
->howto
->name
)
2011 printf (": %s\t", q
->howto
->name
);
2013 printf (": %d\t", q
->howto
->type
);
2015 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2016 printf ("*unknown*");
2019 const char *sym_name
;
2021 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2022 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2023 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2028 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2029 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2030 if (sym_name
== NULL
|| *sym_name
== '\0')
2031 sym_name
= "*unknown*";
2032 printf ("%s", sym_name
);
2038 bfd_signed_vma addend
= q
->addend
;
2046 objdump_print_value (addend
, inf
, TRUE
);
2058 addr_offset
+= octets
/ opb
;
2061 free (sfile
.buffer
);
2065 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2067 const struct elf_backend_data
* bed
;
2068 bfd_vma sign_adjust
= 0;
2069 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2070 struct objdump_disasm_info
* paux
;
2071 unsigned int opb
= pinfo
->octets_per_byte
;
2072 bfd_byte
* data
= NULL
;
2073 bfd_size_type datasize
= 0;
2074 arelent
** rel_pp
= NULL
;
2075 arelent
** rel_ppstart
= NULL
;
2076 arelent
** rel_ppend
;
2077 bfd_vma stop_offset
;
2078 asymbol
* sym
= NULL
;
2082 unsigned long addr_offset
;
2084 /* Sections that do not contain machine
2085 code are not normally disassembled. */
2086 if (! disassemble_all
2087 && only_list
== NULL
2088 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2089 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2092 if (! process_section_p (section
))
2095 datasize
= bfd_get_section_size (section
);
2099 if (start_address
== (bfd_vma
) -1
2100 || start_address
< section
->vma
)
2103 addr_offset
= start_address
- section
->vma
;
2105 if (stop_address
== (bfd_vma
) -1)
2106 stop_offset
= datasize
/ opb
;
2109 if (stop_address
< section
->vma
)
2112 stop_offset
= stop_address
- section
->vma
;
2113 if (stop_offset
> datasize
/ opb
)
2114 stop_offset
= datasize
/ opb
;
2117 if (addr_offset
>= stop_offset
)
2120 /* Decide which set of relocs to use. Load them if necessary. */
2121 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2122 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2124 rel_pp
= paux
->dynrelbuf
;
2125 rel_count
= paux
->dynrelcount
;
2126 /* Dynamic reloc addresses are absolute, non-dynamic are section
2127 relative. REL_OFFSET specifies the reloc address corresponding
2128 to the start of this section. */
2129 rel_offset
= section
->vma
;
2137 if ((section
->flags
& SEC_RELOC
) != 0
2138 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2142 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2144 bfd_fatal (bfd_get_filename (abfd
));
2148 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2149 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2151 bfd_fatal (bfd_get_filename (abfd
));
2153 /* Sort the relocs by address. */
2154 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2158 rel_ppend
= rel_pp
+ rel_count
;
2160 data
= (bfd_byte
*) xmalloc (datasize
);
2162 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2164 paux
->sec
= section
;
2165 pinfo
->buffer
= data
;
2166 pinfo
->buffer_vma
= section
->vma
;
2167 pinfo
->buffer_length
= datasize
;
2168 pinfo
->section
= section
;
2170 /* Skip over the relocs belonging to addresses below the
2172 while (rel_pp
< rel_ppend
2173 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2176 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2178 /* Find the nearest symbol forwards from our current position. */
2179 paux
->require_sec
= TRUE
;
2180 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2181 (struct disassemble_info
*) inf
,
2183 paux
->require_sec
= FALSE
;
2185 /* PR 9774: If the target used signed addresses then we must make
2186 sure that we sign extend the value that we calculate for 'addr'
2187 in the loop below. */
2188 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2189 && (bed
= get_elf_backend_data (abfd
)) != NULL
2190 && bed
->sign_extend_vma
)
2191 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2193 /* Disassemble a block of instructions up to the address associated with
2194 the symbol we have just found. Then print the symbol and find the
2195 next symbol on. Repeat until we have disassembled the entire section
2196 or we have reached the end of the address range we are interested in. */
2197 while (addr_offset
< stop_offset
)
2201 bfd_vma nextstop_offset
;
2204 addr
= section
->vma
+ addr_offset
;
2205 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2207 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2212 (x
< sorted_symcount
2213 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2217 pinfo
->symbols
= sorted_syms
+ place
;
2218 pinfo
->num_symbols
= x
- place
;
2219 pinfo
->symtab_pos
= place
;
2223 pinfo
->symbols
= NULL
;
2224 pinfo
->num_symbols
= 0;
2225 pinfo
->symtab_pos
= -1;
2228 if (! prefix_addresses
)
2230 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2231 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2233 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2236 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2238 else if (sym
== NULL
)
2242 #define is_valid_next_sym(SYM) \
2243 ((SYM)->section == section \
2244 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2245 && pinfo->symbol_is_valid (SYM, pinfo))
2247 /* Search forward for the next appropriate symbol in
2248 SECTION. Note that all the symbols are sorted
2249 together into one big array, and that some sections
2250 may have overlapping addresses. */
2251 while (place
< sorted_symcount
2252 && ! is_valid_next_sym (sorted_syms
[place
]))
2255 if (place
>= sorted_symcount
)
2258 nextsym
= sorted_syms
[place
];
2261 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2262 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2263 else if (nextsym
== NULL
)
2264 nextstop_offset
= stop_offset
;
2266 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2268 if (nextstop_offset
> stop_offset
2269 || nextstop_offset
<= addr_offset
)
2270 nextstop_offset
= stop_offset
;
2272 /* If a symbol is explicitly marked as being an object
2273 rather than a function, just dump the bytes without
2274 disassembling them. */
2277 || sym
->section
!= section
2278 || bfd_asymbol_value (sym
) > addr
2279 || ((sym
->flags
& BSF_OBJECT
) == 0
2280 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2282 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2284 || (sym
->flags
& BSF_FUNCTION
) != 0)
2289 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2290 addr_offset
, nextstop_offset
,
2291 rel_offset
, &rel_pp
, rel_ppend
);
2293 addr_offset
= nextstop_offset
;
2299 if (rel_ppstart
!= NULL
)
2303 /* Disassemble the contents of an object file. */
2306 disassemble_data (bfd
*abfd
)
2308 struct disassemble_info disasm_info
;
2309 struct objdump_disasm_info aux
;
2313 prev_functionname
= NULL
;
2315 prev_discriminator
= 0;
2317 /* We make a copy of syms to sort. We don't want to sort syms
2318 because that will screw up the relocs. */
2319 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2320 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2321 * sizeof (asymbol
*));
2322 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2323 sorted_symcount
* sizeof (asymbol
*));
2325 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2327 for (i
= 0; i
< synthcount
; ++i
)
2329 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2333 /* Sort the symbols into section and symbol order. */
2334 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2336 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2338 disasm_info
.application_data
= (void *) &aux
;
2340 aux
.require_sec
= FALSE
;
2341 aux
.dynrelbuf
= NULL
;
2342 aux
.dynrelcount
= 0;
2345 disasm_info
.print_address_func
= objdump_print_address
;
2346 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2348 if (machine
!= NULL
)
2350 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2353 fatal (_("can't use supplied machine %s"), machine
);
2355 abfd
->arch_info
= inf
;
2358 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2360 struct bfd_target
*xvec
;
2362 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2363 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2364 xvec
->byteorder
= endian
;
2368 /* Use libopcodes to locate a suitable disassembler. */
2369 aux
.disassemble_fn
= disassembler (abfd
);
2370 if (!aux
.disassemble_fn
)
2372 non_fatal (_("can't disassemble for architecture %s\n"),
2373 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2378 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2379 disasm_info
.arch
= bfd_get_arch (abfd
);
2380 disasm_info
.mach
= bfd_get_mach (abfd
);
2381 disasm_info
.disassembler_options
= disassembler_options
;
2382 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2383 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2384 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2385 disasm_info
.disassembler_needs_relocs
= FALSE
;
2387 if (bfd_big_endian (abfd
))
2388 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2389 else if (bfd_little_endian (abfd
))
2390 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2392 /* ??? Aborting here seems too drastic. We could default to big or little
2394 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2396 /* Allow the target to customize the info structure. */
2397 disassemble_init_for_target (& disasm_info
);
2399 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2401 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2403 if (relsize
< 0 && dump_dynamic_reloc_info
)
2404 bfd_fatal (bfd_get_filename (abfd
));
2408 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2409 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2412 if (aux
.dynrelcount
< 0)
2413 bfd_fatal (bfd_get_filename (abfd
));
2415 /* Sort the relocs by address. */
2416 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2420 disasm_info
.symtab
= sorted_syms
;
2421 disasm_info
.symtab_size
= sorted_symcount
;
2423 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2425 if (aux
.dynrelbuf
!= NULL
)
2426 free (aux
.dynrelbuf
);
2431 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2432 asection
*sec
, void *file
)
2434 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2435 bfd
*abfd
= (bfd
*) file
;
2438 /* If it is already loaded, do nothing. */
2439 if (section
->start
!= NULL
)
2442 section
->reloc_info
= NULL
;
2443 section
->num_relocs
= 0;
2444 section
->address
= bfd_get_section_vma (abfd
, sec
);
2445 section
->size
= bfd_get_section_size (sec
);
2446 section
->start
= NULL
;
2447 section
->user_data
= sec
;
2448 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2452 free_debug_section (debug
);
2453 printf (_("\nCan't get contents for section '%s'.\n"),
2458 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2460 bfd_cache_section_contents (sec
, section
->start
);
2462 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2469 free_debug_section (debug
);
2470 printf (_("\nCan't get contents for section '%s'.\n"),
2477 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2480 unsigned long reloc_count
;
2483 relocs
= (arelent
**) xmalloc (reloc_size
);
2485 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2486 if (reloc_count
== 0)
2490 section
->reloc_info
= relocs
;
2491 section
->num_relocs
= reloc_count
;
2500 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2505 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2508 relocs
= (arelent
**) dsec
->reloc_info
;
2510 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2511 if (rp
->address
== offset
)
2518 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2520 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2521 bfd
*abfd
= (bfd
*) file
;
2524 /* If it is already loaded, do nothing. */
2525 if (section
->start
!= NULL
)
2528 /* Locate the debug section. */
2529 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2531 section
->name
= section
->uncompressed_name
;
2534 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2536 section
->name
= section
->compressed_name
;
2541 return load_specific_debug_section (debug
, sec
, file
);
2545 free_debug_section (enum dwarf_section_display_enum debug
)
2547 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2549 if (section
->start
== NULL
)
2552 /* PR 17512: file: 0f67f69d. */
2553 if (section
->user_data
!= NULL
)
2555 asection
* sec
= (asection
*) section
->user_data
;
2557 /* If we are freeing contents that are also pointed to by the BFD
2558 library's section structure then make sure to update those pointers
2559 too. Otherwise, the next time we try to load data for this section
2560 we can end up using a stale pointer. */
2561 if (section
->start
== sec
->contents
)
2563 sec
->contents
= NULL
;
2564 sec
->flags
&= ~ SEC_IN_MEMORY
;
2565 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2569 free ((char *) section
->start
);
2570 section
->start
= NULL
;
2571 section
->address
= 0;
2576 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2577 void *arg ATTRIBUTE_UNUSED
)
2579 const char *name
= bfd_get_section_name (abfd
, section
);
2583 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2584 match
= ".debug_info";
2588 for (i
= 0; i
< max
; i
++)
2589 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2590 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2591 && debug_displays
[i
].enabled
!= NULL
2592 && *debug_displays
[i
].enabled
)
2594 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2596 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2597 sec
->name
= sec
->uncompressed_name
;
2599 sec
->name
= sec
->compressed_name
;
2600 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2603 debug_displays
[i
].display (sec
, abfd
);
2605 if (i
!= info
&& i
!= abbrev
)
2606 free_debug_section ((enum dwarf_section_display_enum
) i
);
2612 /* Dump the dwarf debugging information. */
2615 dump_dwarf (bfd
*abfd
)
2617 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2619 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2621 if (bfd_big_endian (abfd
))
2622 byte_get
= byte_get_big_endian
;
2623 else if (bfd_little_endian (abfd
))
2624 byte_get
= byte_get_little_endian
;
2626 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2628 warn (_("File %s does not contain any dwarf debug information\n"),
2629 bfd_get_filename (abfd
));
2633 switch (bfd_get_arch (abfd
))
2636 switch (bfd_get_mach (abfd
))
2638 case bfd_mach_x86_64
:
2639 case bfd_mach_x86_64_intel_syntax
:
2640 case bfd_mach_x86_64_nacl
:
2641 case bfd_mach_x64_32
:
2642 case bfd_mach_x64_32_intel_syntax
:
2643 case bfd_mach_x64_32_nacl
:
2644 init_dwarf_regnames_x86_64 ();
2648 init_dwarf_regnames_i386 ();
2653 case bfd_arch_iamcu
:
2654 init_dwarf_regnames_iamcu ();
2657 case bfd_arch_aarch64
:
2658 init_dwarf_regnames_aarch64();
2662 init_dwarf_regnames_s390 ();
2669 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2671 free_debug_memory ();
2674 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2675 it. Return NULL on failure. */
2678 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2684 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2685 if (stabsect
== NULL
)
2687 printf (_("No %s section present\n\n"), sect_name
);
2691 size
= bfd_section_size (abfd
, stabsect
);
2692 contents
= (char *) xmalloc (size
);
2694 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2696 non_fatal (_("reading %s section of %s failed: %s"),
2697 sect_name
, bfd_get_filename (abfd
),
2698 bfd_errmsg (bfd_get_error ()));
2709 /* Stabs entries use a 12 byte format:
2710 4 byte string table index
2712 1 byte stab other field
2713 2 byte stab desc field
2715 FIXME: This will have to change for a 64 bit object format. */
2717 #define STRDXOFF (0)
2719 #define OTHEROFF (5)
2722 #define STABSIZE (12)
2724 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2725 using string table section STRSECT_NAME (in `strtab'). */
2728 print_section_stabs (bfd
*abfd
,
2729 const char *stabsect_name
,
2730 unsigned *string_offset_ptr
)
2733 unsigned file_string_table_offset
= 0;
2734 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2735 bfd_byte
*stabp
, *stabs_end
;
2738 stabs_end
= stabp
+ stab_size
;
2740 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2741 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2743 /* Loop through all symbols and print them.
2745 We start the index at -1 because there is a dummy symbol on
2746 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2747 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2751 unsigned char type
, other
;
2752 unsigned short desc
;
2755 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2756 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2757 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2758 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2759 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2761 printf ("\n%-6d ", i
);
2762 /* Either print the stab name, or, if unnamed, print its number
2763 again (makes consistent formatting for tools like awk). */
2764 name
= bfd_get_stab_name (type
);
2766 printf ("%-6s", name
);
2767 else if (type
== N_UNDF
)
2770 printf ("%-6d", type
);
2771 printf (" %-6d %-6d ", other
, desc
);
2772 bfd_printf_vma (abfd
, value
);
2773 printf (" %-6lu", strx
);
2775 /* Symbols with type == 0 (N_UNDF) specify the length of the
2776 string table associated with this file. We use that info
2777 to know how to relocate the *next* file's string table indices. */
2780 file_string_table_offset
= next_file_string_table_offset
;
2781 next_file_string_table_offset
+= value
;
2785 bfd_size_type amt
= strx
+ file_string_table_offset
;
2787 /* Using the (possibly updated) string table offset, print the
2788 string (if any) associated with this symbol. */
2789 if (amt
< stabstr_size
)
2790 /* PR 17512: file: 079-79389-0.001:0.1. */
2791 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2797 *string_offset_ptr
= next_file_string_table_offset
;
2802 const char * section_name
;
2803 const char * string_section_name
;
2804 unsigned string_offset
;
2809 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2812 stab_section_names
* sought
= (stab_section_names
*) names
;
2814 /* Check for section names for which stabsect_name is a prefix, to
2815 handle .stab.N, etc. */
2816 len
= strlen (sought
->section_name
);
2818 /* If the prefix matches, and the files section name ends with a
2819 nul or a digit, then we match. I.e., we want either an exact
2820 match or a section followed by a number. */
2821 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2822 && (section
->name
[len
] == 0
2823 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2826 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2831 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2834 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2840 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2842 stab_section_names s
;
2844 s
.section_name
= stabsect_name
;
2845 s
.string_section_name
= strsect_name
;
2846 s
.string_offset
= 0;
2848 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2854 /* Dump the any sections containing stabs debugging information. */
2857 dump_stabs (bfd
*abfd
)
2859 dump_stabs_section (abfd
, ".stab", ".stabstr");
2860 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2861 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2864 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2866 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2870 dump_bfd_header (bfd
*abfd
)
2874 printf (_("architecture: %s, "),
2875 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2876 bfd_get_mach (abfd
)));
2877 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2879 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2880 PF (HAS_RELOC
, "HAS_RELOC");
2881 PF (EXEC_P
, "EXEC_P");
2882 PF (HAS_LINENO
, "HAS_LINENO");
2883 PF (HAS_DEBUG
, "HAS_DEBUG");
2884 PF (HAS_SYMS
, "HAS_SYMS");
2885 PF (HAS_LOCALS
, "HAS_LOCALS");
2886 PF (DYNAMIC
, "DYNAMIC");
2887 PF (WP_TEXT
, "WP_TEXT");
2888 PF (D_PAGED
, "D_PAGED");
2889 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2890 printf (_("\nstart address 0x"));
2891 bfd_printf_vma (abfd
, abfd
->start_address
);
2897 dump_bfd_private_header (bfd
*abfd
)
2899 bfd_print_private_bfd_data (abfd
, stdout
);
2903 dump_target_specific (bfd
*abfd
)
2905 const struct objdump_private_desc
* const *desc
;
2906 struct objdump_private_option
*opt
;
2909 /* Find the desc. */
2910 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2911 if ((*desc
)->filter (abfd
))
2916 non_fatal (_("option -P/--private not supported by this file"));
2920 /* Clear all options. */
2921 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2922 opt
->selected
= FALSE
;
2924 /* Decode options. */
2925 b
= dump_private_options
;
2928 e
= strchr (b
, ',');
2933 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2934 if (strcmp (opt
->name
, b
) == 0)
2936 opt
->selected
= TRUE
;
2939 if (opt
->name
== NULL
)
2940 non_fatal (_("target specific dump '%s' not supported"), b
);
2951 (*desc
)->dump (abfd
);
2954 /* Display a section in hexadecimal format with associated characters.
2955 Each line prefixed by the zero padded address. */
2958 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2961 bfd_size_type datasize
;
2962 bfd_vma addr_offset
;
2963 bfd_vma start_offset
;
2964 bfd_vma stop_offset
;
2965 unsigned int opb
= bfd_octets_per_byte (abfd
);
2966 /* Bytes per line. */
2967 const int onaline
= 16;
2972 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2975 if (! process_section_p (section
))
2978 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2981 /* Compute the address range to display. */
2982 if (start_address
== (bfd_vma
) -1
2983 || start_address
< section
->vma
)
2986 start_offset
= start_address
- section
->vma
;
2988 if (stop_address
== (bfd_vma
) -1)
2989 stop_offset
= datasize
/ opb
;
2992 if (stop_address
< section
->vma
)
2995 stop_offset
= stop_address
- section
->vma
;
2997 if (stop_offset
> datasize
/ opb
)
2998 stop_offset
= datasize
/ opb
;
3001 if (start_offset
>= stop_offset
)
3004 printf (_("Contents of section %s:"), section
->name
);
3005 if (display_file_offsets
)
3006 printf (_(" (Starting at file offset: 0x%lx)"),
3007 (unsigned long) (section
->filepos
+ start_offset
));
3010 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3012 non_fatal (_("Reading section %s failed because: %s"),
3013 section
->name
, bfd_errmsg (bfd_get_error ()));
3019 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3020 if (strlen (buf
) >= sizeof (buf
))
3024 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3026 count
= strlen (buf
) - count
;
3030 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3031 if (strlen (buf
) >= sizeof (buf
))
3035 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3037 count
= strlen (buf
) - count
;
3041 for (addr_offset
= start_offset
;
3042 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3046 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3047 count
= strlen (buf
);
3048 if ((size_t) count
>= sizeof (buf
))
3052 while (count
< width
)
3057 fputs (buf
+ count
- width
, stdout
);
3060 for (j
= addr_offset
* opb
;
3061 j
< addr_offset
* opb
+ onaline
; j
++)
3063 if (j
< stop_offset
* opb
)
3064 printf ("%02x", (unsigned) (data
[j
]));
3072 for (j
= addr_offset
* opb
;
3073 j
< addr_offset
* opb
+ onaline
; j
++)
3075 if (j
>= stop_offset
* opb
)
3078 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3085 /* Actually display the various requested regions. */
3088 dump_data (bfd
*abfd
)
3090 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3093 /* Should perhaps share code and display with nm? */
3096 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3105 max_count
= dynsymcount
;
3106 printf ("DYNAMIC SYMBOL TABLE:\n");
3111 max_count
= symcount
;
3112 printf ("SYMBOL TABLE:\n");
3116 printf (_("no symbols\n"));
3118 for (count
= 0; count
< max_count
; count
++)
3122 if (*current
== NULL
)
3123 printf (_("no information for symbol number %ld\n"), count
);
3125 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3126 printf (_("could not determine the type of symbol number %ld\n"),
3129 else if (process_section_p ((* current
)->section
)
3130 && (dump_special_syms
3131 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3133 const char *name
= (*current
)->name
;
3135 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3139 /* If we want to demangle the name, we demangle it
3140 here, and temporarily clobber it while calling
3141 bfd_print_symbol. FIXME: This is a gross hack. */
3142 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3144 (*current
)->name
= alloc
;
3145 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3146 bfd_print_symbol_all
);
3149 (*current
)->name
= name
;
3154 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3155 bfd_print_symbol_all
);
3165 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3168 char *last_filename
, *last_functionname
;
3169 unsigned int last_line
;
3170 unsigned int last_discriminator
;
3172 /* Get column headers lined up reasonably. */
3180 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3181 width
= strlen (buf
) - 7;
3183 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3186 last_filename
= NULL
;
3187 last_functionname
= NULL
;
3189 last_discriminator
= 0;
3191 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3194 const char *filename
, *functionname
;
3195 unsigned int linenumber
;
3196 unsigned int discriminator
;
3197 const char *sym_name
;
3198 const char *section_name
;
3199 bfd_vma addend2
= 0;
3201 if (start_address
!= (bfd_vma
) -1
3202 && q
->address
< start_address
)
3204 if (stop_address
!= (bfd_vma
) -1
3205 && q
->address
> stop_address
)
3208 if (with_line_numbers
3210 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3211 &filename
, &functionname
,
3212 &linenumber
, &discriminator
))
3214 if (functionname
!= NULL
3215 && (last_functionname
== NULL
3216 || strcmp (functionname
, last_functionname
) != 0))
3218 printf ("%s():\n", functionname
);
3219 if (last_functionname
!= NULL
)
3220 free (last_functionname
);
3221 last_functionname
= xstrdup (functionname
);
3225 && (linenumber
!= last_line
3226 || (filename
!= NULL
3227 && last_filename
!= NULL
3228 && filename_cmp (filename
, last_filename
) != 0)
3229 || (discriminator
!= last_discriminator
)))
3231 if (discriminator
> 0)
3232 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3234 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3235 linenumber
, discriminator
);
3236 last_line
= linenumber
;
3237 last_discriminator
= discriminator
;
3238 if (last_filename
!= NULL
)
3239 free (last_filename
);
3240 if (filename
== NULL
)
3241 last_filename
= NULL
;
3243 last_filename
= xstrdup (filename
);
3247 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3249 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3250 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3255 section_name
= NULL
;
3258 bfd_printf_vma (abfd
, q
->address
);
3259 if (q
->howto
== NULL
)
3260 printf (" *unknown* ");
3261 else if (q
->howto
->name
)
3263 const char *name
= q
->howto
->name
;
3265 /* R_SPARC_OLO10 relocations contain two addends.
3266 But because 'arelent' lacks enough storage to
3267 store them both, the 64-bit ELF Sparc backend
3268 records this as two relocations. One R_SPARC_LO10
3269 and one R_SPARC_13, both pointing to the same
3270 address. This is merely so that we have some
3271 place to store both addend fields.
3273 Undo this transformation, otherwise the output
3274 will be confusing. */
3275 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3276 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3278 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3280 arelent
*q2
= *(p
+ 1);
3283 && q
->address
== q2
->address
3284 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3286 name
= "R_SPARC_OLO10";
3287 addend2
= q2
->addend
;
3291 printf (" %-16s ", name
);
3294 printf (" %-16d ", q
->howto
->type
);
3298 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3302 if (section_name
== NULL
)
3303 section_name
= "*unknown*";
3304 printf ("[%s]", section_name
);
3309 bfd_signed_vma addend
= q
->addend
;
3317 bfd_printf_vma (abfd
, addend
);
3322 bfd_printf_vma (abfd
, addend2
);
3328 if (last_filename
!= NULL
)
3329 free (last_filename
);
3330 if (last_functionname
!= NULL
)
3331 free (last_functionname
);
3335 dump_relocs_in_section (bfd
*abfd
,
3337 void *dummy ATTRIBUTE_UNUSED
)
3343 if ( bfd_is_abs_section (section
)
3344 || bfd_is_und_section (section
)
3345 || bfd_is_com_section (section
)
3346 || (! process_section_p (section
))
3347 || ((section
->flags
& SEC_RELOC
) == 0))
3350 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3352 bfd_fatal (bfd_get_filename (abfd
));
3354 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3358 printf (" (none)\n\n");
3362 relpp
= (arelent
**) xmalloc (relsize
);
3363 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3368 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3369 bfd_fatal (_("error message was"));
3371 else if (relcount
== 0)
3372 printf (" (none)\n\n");
3376 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3383 dump_relocs (bfd
*abfd
)
3385 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3389 dump_dynamic_relocs (bfd
*abfd
)
3395 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3397 bfd_fatal (bfd_get_filename (abfd
));
3399 printf ("DYNAMIC RELOCATION RECORDS");
3402 printf (" (none)\n\n");
3405 relpp
= (arelent
**) xmalloc (relsize
);
3406 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3409 bfd_fatal (bfd_get_filename (abfd
));
3410 else if (relcount
== 0)
3411 printf (" (none)\n\n");
3415 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3422 /* Creates a table of paths, to search for source files. */
3425 add_include_path (const char *path
)
3429 include_path_count
++;
3430 include_paths
= (const char **)
3431 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3432 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3433 if (path
[1] == ':' && path
[2] == 0)
3434 path
= concat (path
, ".", (const char *) 0);
3436 include_paths
[include_path_count
- 1] = path
;
3440 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3444 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3446 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3447 section
->vma
+= adjust_section_vma
;
3449 section
->lma
+= adjust_section_vma
;
3453 /* Dump selected contents of ABFD. */
3456 dump_bfd (bfd
*abfd
)
3458 /* If we are adjusting section VMA's, change them all now. Changing
3459 the BFD information is a hack. However, we must do it, or
3460 bfd_find_nearest_line will not do the right thing. */
3461 if (adjust_section_vma
!= 0)
3463 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3464 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3467 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3468 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3471 print_arelt_descr (stdout
, abfd
, TRUE
);
3472 if (dump_file_header
)
3473 dump_bfd_header (abfd
);
3474 if (dump_private_headers
)
3475 dump_bfd_private_header (abfd
);
3476 if (dump_private_options
!= NULL
)
3477 dump_target_specific (abfd
);
3478 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3485 || dump_dwarf_section_info
)
3486 syms
= slurp_symtab (abfd
);
3488 if (dump_section_headers
)
3489 dump_headers (abfd
);
3491 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3492 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3493 dynsyms
= slurp_dynamic_symtab (abfd
);
3496 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3497 dynsymcount
, dynsyms
, &synthsyms
);
3503 dump_symbols (abfd
, FALSE
);
3504 if (dump_dynamic_symtab
)
3505 dump_symbols (abfd
, TRUE
);
3506 if (dump_dwarf_section_info
)
3508 if (dump_stab_section_info
)
3510 if (dump_reloc_info
&& ! disassemble
)
3512 if (dump_dynamic_reloc_info
&& ! disassemble
)
3513 dump_dynamic_relocs (abfd
);
3514 if (dump_section_contents
)
3517 disassemble_data (abfd
);
3523 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3524 if (dhandle
!= NULL
)
3526 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3528 dump_debugging_tags
? TRUE
: FALSE
))
3530 non_fatal (_("%s: printing debugging information failed"),
3531 bfd_get_filename (abfd
));
3535 /* PR 6483: If there was no STABS or IEEE debug
3536 info in the file, try DWARF instead. */
3537 else if (! dump_dwarf_section_info
)
3539 dwarf_select_sections_all ();
3568 display_object_bfd (bfd
*abfd
)
3572 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3578 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3580 nonfatal (bfd_get_filename (abfd
));
3581 list_matching_formats (matching
);
3586 if (bfd_get_error () != bfd_error_file_not_recognized
)
3588 nonfatal (bfd_get_filename (abfd
));
3592 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3598 nonfatal (bfd_get_filename (abfd
));
3600 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3602 list_matching_formats (matching
);
3608 display_any_bfd (bfd
*file
, int level
)
3610 /* Decompress sections unless dumping the section contents. */
3611 if (!dump_section_contents
)
3612 file
->flags
|= BFD_DECOMPRESS
;
3614 /* If the file is an archive, process all of its elements. */
3615 if (bfd_check_format (file
, bfd_archive
))
3618 bfd
*last_arfile
= NULL
;
3621 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3622 else if (level
> 100)
3624 /* Prevent corrupted files from spinning us into an
3625 infinite loop. 100 is an arbitrary heuristic. */
3626 fatal (_("Archive nesting is too deep"));
3630 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3634 bfd_set_error (bfd_error_no_error
);
3636 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3639 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3640 nonfatal (bfd_get_filename (file
));
3644 display_any_bfd (arfile
, level
+ 1);
3646 if (last_arfile
!= NULL
)
3648 bfd_close (last_arfile
);
3649 /* PR 17512: file: ac585d01. */
3650 if (arfile
== last_arfile
)
3656 last_arfile
= arfile
;
3659 if (last_arfile
!= NULL
)
3660 bfd_close (last_arfile
);
3663 display_object_bfd (file
);
3667 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3671 if (get_file_size (filename
) < 1)
3677 file
= bfd_openr (filename
, target
);
3680 nonfatal (filename
);
3684 display_any_bfd (file
, 0);
3686 /* This is an optimization to improve the speed of objdump, especially when
3687 dumping a file with lots of associated debug informatiom. Calling
3688 bfd_close on such a file can take a non-trivial amount of time as there
3689 are lots of lists to walk and buffers to free. This is only really
3690 necessary however if we are about to load another file and we need the
3691 memory back. Otherwise, if we are about to exit, then we can save (a lot
3692 of) time by only doing a quick close, and allowing the OS to reclaim the
3697 bfd_close_all_done (file
);
3701 main (int argc
, char **argv
)
3704 char *target
= default_target
;
3705 bfd_boolean seenflag
= FALSE
;
3707 #if defined (HAVE_SETLOCALE)
3708 #if defined (HAVE_LC_MESSAGES)
3709 setlocale (LC_MESSAGES
, "");
3711 setlocale (LC_CTYPE
, "");
3714 bindtextdomain (PACKAGE
, LOCALEDIR
);
3715 textdomain (PACKAGE
);
3717 program_name
= *argv
;
3718 xmalloc_set_program_name (program_name
);
3719 bfd_set_error_program_name (program_name
);
3721 START_PROGRESS (program_name
, 0);
3723 expandargv (&argc
, &argv
);
3726 set_default_bfd_target ();
3728 while ((c
= getopt_long (argc
, argv
,
3729 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3730 long_options
, (int *) 0))
3736 break; /* We've been given a long option. */
3743 if (disassembler_options
)
3744 /* Ignore potential memory leak for now. */
3745 options
= concat (disassembler_options
, ",",
3746 optarg
, (const char *) NULL
);
3749 disassembler_options
= remove_whitespace_and_extra_commas (options
);
3756 display_file_offsets
= TRUE
;
3759 with_line_numbers
= TRUE
;
3768 enum demangling_styles style
;
3770 style
= cplus_demangle_name_to_style (optarg
);
3771 if (style
== unknown_demangling
)
3772 fatal (_("unknown demangling style `%s'"),
3775 cplus_demangle_set_style (style
);
3779 do_wide
= wide_output
= TRUE
;
3781 case OPTION_ADJUST_VMA
:
3782 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3784 case OPTION_START_ADDRESS
:
3785 start_address
= parse_vma (optarg
, "--start-address");
3786 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3787 fatal (_("error: the start address should be before the end address"));
3789 case OPTION_STOP_ADDRESS
:
3790 stop_address
= parse_vma (optarg
, "--stop-address");
3791 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3792 fatal (_("error: the stop address should be after the start address"));
3796 prefix_length
= strlen (prefix
);
3797 /* Remove an unnecessary trailing '/' */
3798 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3801 case OPTION_PREFIX_STRIP
:
3802 prefix_strip
= atoi (optarg
);
3803 if (prefix_strip
< 0)
3804 fatal (_("error: prefix strip must be non-negative"));
3806 case OPTION_INSN_WIDTH
:
3807 insn_width
= strtoul (optarg
, NULL
, 0);
3808 if (insn_width
<= 0)
3809 fatal (_("error: instruction width must be positive"));
3812 if (strcmp (optarg
, "B") == 0)
3813 endian
= BFD_ENDIAN_BIG
;
3814 else if (strcmp (optarg
, "L") == 0)
3815 endian
= BFD_ENDIAN_LITTLE
;
3818 nonfatal (_("unrecognized -E option"));
3823 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3824 endian
= BFD_ENDIAN_BIG
;
3825 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3826 endian
= BFD_ENDIAN_LITTLE
;
3829 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3836 dump_file_header
= TRUE
;
3840 formats_info
= TRUE
;
3844 add_include_path (optarg
);
3847 dump_private_headers
= TRUE
;
3851 dump_private_options
= optarg
;
3855 dump_private_headers
= TRUE
;
3857 dump_reloc_info
= TRUE
;
3858 dump_file_header
= TRUE
;
3859 dump_ar_hdrs
= TRUE
;
3860 dump_section_headers
= TRUE
;
3868 dump_dynamic_symtab
= TRUE
;
3876 disassemble_zeroes
= TRUE
;
3880 disassemble_all
= TRUE
;
3885 with_source_code
= TRUE
;
3894 dump_debugging_tags
= 1;
3899 dump_dwarf_section_info
= TRUE
;
3902 dwarf_select_sections_by_letters (optarg
);
3904 dwarf_select_sections_all ();
3907 dump_dwarf_section_info
= TRUE
;
3910 dwarf_select_sections_by_names (optarg
);
3912 dwarf_select_sections_all ();
3914 case OPTION_DWARF_DEPTH
:
3917 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3920 case OPTION_DWARF_START
:
3923 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3924 suppress_bfd_header
= 1;
3927 case OPTION_DWARF_CHECK
:
3931 dump_stab_section_info
= TRUE
;
3935 dump_section_contents
= TRUE
;
3939 dump_reloc_info
= TRUE
;
3943 dump_dynamic_reloc_info
= TRUE
;
3947 dump_ar_hdrs
= TRUE
;
3951 dump_section_headers
= TRUE
;
3956 show_version
= TRUE
;
3962 /* No need to set seenflag or to break - usage() does not return. */
3969 print_version ("objdump");
3975 exit_status
= display_info ();
3979 display_file ("a.out", target
, TRUE
);
3981 for (; optind
< argc
;)
3983 display_file (argv
[optind
], target
, optind
== argc
- 1);
3990 END_PROGRESS (program_name
);