1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2018 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
;
120 static bfd_boolean unwind_inlines
; /* --inlines. */
122 /* A structure to record the sections mentioned in -j switches. */
125 const char * name
; /* The name of the section. */
126 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
127 struct only
* next
; /* Pointer to the next structure in the list. */
129 /* Pointer to an array of 'only' structures.
130 This pointer is NULL if the -j switch has not been used. */
131 static struct only
* only_list
= NULL
;
133 /* Variables for handling include file path table. */
134 static const char **include_paths
;
135 static int include_path_count
;
137 /* Extra info to pass to the section disassembler and address printing
139 struct objdump_disasm_info
143 bfd_boolean require_sec
;
144 arelent
** dynrelbuf
;
146 disassembler_ftype disassemble_fn
;
150 /* Architecture to disassemble for, or default if NULL. */
151 static char *machine
= NULL
;
153 /* Target specific options to the disassembler. */
154 static char *disassembler_options
= NULL
;
156 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
157 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
159 /* The symbol table. */
160 static asymbol
**syms
;
162 /* Number of symbols in `syms'. */
163 static long symcount
= 0;
165 /* The sorted symbol table. */
166 static asymbol
**sorted_syms
;
168 /* Number of symbols in `sorted_syms'. */
169 static long sorted_symcount
= 0;
171 /* The dynamic symbol table. */
172 static asymbol
**dynsyms
;
174 /* The synthetic symbol table. */
175 static asymbol
*synthsyms
;
176 static long synthcount
= 0;
178 /* Number of symbols in `dynsyms'. */
179 static long dynsymcount
= 0;
181 static bfd_byte
*stabs
;
182 static bfd_size_type stab_size
;
184 static bfd_byte
*strtab
;
185 static bfd_size_type stabstr_size
;
187 static bfd_boolean is_relocatable
= FALSE
;
189 /* Handlers for -P/--private. */
190 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
192 OBJDUMP_PRIVATE_VECTORS
196 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
198 usage (FILE *stream
, int status
)
200 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
201 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
202 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
203 fprintf (stream
, _("\
204 -a, --archive-headers Display archive header information\n\
205 -f, --file-headers Display the contents of the overall file header\n\
206 -p, --private-headers Display object format specific file header contents\n\
207 -P, --private=OPT,OPT... Display object format specific contents\n\
208 -h, --[section-]headers Display the contents of the section headers\n\
209 -x, --all-headers Display the contents of all headers\n\
210 -d, --disassemble Display assembler contents of executable sections\n\
211 -D, --disassemble-all Display assembler contents of all sections\n\
212 -S, --source Intermix source code with disassembly\n\
213 -s, --full-contents Display the full contents of all sections requested\n\
214 -g, --debugging Display debug information in object file\n\
215 -e, --debugging-tags Display debug information using ctags style\n\
216 -G, --stabs Display (in raw form) any STABS info in the file\n\
217 -W[lLiaprmfFsoRtUuTgAckK] or\n\
218 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
219 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
220 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 =addr,=cu_index,=links,=follow-links]\n\
222 Display DWARF info in the file\n\
223 -t, --syms Display the contents of the symbol table(s)\n\
224 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
225 -r, --reloc Display the relocation entries in the file\n\
226 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
227 @<file> Read options from <file>\n\
228 -v, --version Display this program's version number\n\
229 -i, --info List object formats and architectures supported\n\
230 -H, --help Display this information\n\
234 const struct objdump_private_desc
* const *desc
;
236 fprintf (stream
, _("\n The following switches are optional:\n"));
237 fprintf (stream
, _("\
238 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
239 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
240 -j, --section=NAME Only display information for section NAME\n\
241 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
242 -EB --endian=big Assume big endian format when disassembling\n\
243 -EL --endian=little Assume little endian format when disassembling\n\
244 --file-start-context Include context from start of file (with -S)\n\
245 -I, --include=DIR Add DIR to search list for source files\n\
246 -l, --line-numbers Include line numbers and filenames in output\n\
247 -F, --file-offsets Include file offsets when displaying information\n\
248 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
249 The STYLE, if specified, can be `auto', `gnu',\n\
250 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
252 -w, --wide Format output for more than 80 columns\n\
253 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
254 --start-address=ADDR Only process data whose address is >= ADDR\n\
255 --stop-address=ADDR Only process data whose address is <= ADDR\n\
256 --prefix-addresses Print complete address alongside disassembly\n\
257 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
258 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
259 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
260 --special-syms Include special symbols in symbol dumps\n\
261 --inlines Print all inlines for source line (with -l)\n\
262 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
263 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
264 fprintf (stream
, _("\
265 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
266 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
268 --dwarf-check Make additional dwarf internal consistency checks.\
270 list_supported_targets (program_name
, stream
);
271 list_supported_architectures (program_name
, stream
);
273 disassembler_usage (stream
);
275 if (objdump_private_vectors
[0] != NULL
)
278 _("\nOptions supported for -P/--private switch:\n"));
279 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
280 (*desc
)->help (stream
);
283 if (REPORT_BUGS_TO
[0] && status
== 0)
284 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
288 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
292 OPTION_START_ADDRESS
,
305 static struct option long_options
[]=
307 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
308 {"all-headers", no_argument
, NULL
, 'x'},
309 {"private-headers", no_argument
, NULL
, 'p'},
310 {"private", required_argument
, NULL
, 'P'},
311 {"architecture", required_argument
, NULL
, 'm'},
312 {"archive-headers", no_argument
, NULL
, 'a'},
313 {"debugging", no_argument
, NULL
, 'g'},
314 {"debugging-tags", no_argument
, NULL
, 'e'},
315 {"demangle", optional_argument
, NULL
, 'C'},
316 {"disassemble", no_argument
, NULL
, 'd'},
317 {"disassemble-all", no_argument
, NULL
, 'D'},
318 {"disassembler-options", required_argument
, NULL
, 'M'},
319 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
320 {"dynamic-reloc", no_argument
, NULL
, 'R'},
321 {"dynamic-syms", no_argument
, NULL
, 'T'},
322 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
323 {"file-headers", no_argument
, NULL
, 'f'},
324 {"file-offsets", no_argument
, NULL
, 'F'},
325 {"file-start-context", no_argument
, &file_start_context
, 1},
326 {"full-contents", no_argument
, NULL
, 's'},
327 {"headers", no_argument
, NULL
, 'h'},
328 {"help", no_argument
, NULL
, 'H'},
329 {"info", no_argument
, NULL
, 'i'},
330 {"line-numbers", no_argument
, NULL
, 'l'},
331 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
332 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
333 {"reloc", no_argument
, NULL
, 'r'},
334 {"section", required_argument
, NULL
, 'j'},
335 {"section-headers", no_argument
, NULL
, 'h'},
336 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
337 {"source", no_argument
, NULL
, 'S'},
338 {"special-syms", no_argument
, &dump_special_syms
, 1},
339 {"include", required_argument
, NULL
, 'I'},
340 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
341 {"stabs", no_argument
, NULL
, 'G'},
342 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
343 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
344 {"syms", no_argument
, NULL
, 't'},
345 {"target", required_argument
, NULL
, 'b'},
346 {"version", no_argument
, NULL
, 'V'},
347 {"wide", no_argument
, NULL
, 'w'},
348 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
349 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
350 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
351 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
352 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
353 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
354 {"inlines", no_argument
, 0, OPTION_INLINES
},
355 {0, no_argument
, 0, 0}
359 nonfatal (const char *msg
)
365 /* Returns TRUE if the specified section should be dumped. */
368 process_section_p (asection
* section
)
372 if (only_list
== NULL
)
375 for (only
= only_list
; only
; only
= only
->next
)
376 if (strcmp (only
->name
, section
->name
) == 0)
385 /* Add an entry to the 'only' list. */
388 add_only (char * name
)
392 /* First check to make sure that we do not
393 already have an entry for this name. */
394 for (only
= only_list
; only
; only
= only
->next
)
395 if (strcmp (only
->name
, name
) == 0)
398 only
= xmalloc (sizeof * only
);
401 only
->next
= only_list
;
405 /* Release the memory used by the 'only' list.
406 PR 11225: Issue a warning message for unseen sections.
407 Only do this if none of the sections were seen. This is mainly to support
408 tools like the GAS testsuite where an object file is dumped with a list of
409 generic section names known to be present in a range of different file
413 free_only_list (void)
415 bfd_boolean at_least_one_seen
= FALSE
;
419 if (only_list
== NULL
)
422 for (only
= only_list
; only
; only
= only
->next
)
425 at_least_one_seen
= TRUE
;
429 for (only
= only_list
; only
; only
= next
)
431 if (! at_least_one_seen
)
433 non_fatal (_("section '%s' mentioned in a -j option, "
434 "but not found in any input file"),
445 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
448 unsigned int opb
= bfd_octets_per_byte (abfd
);
449 int longest_section_name
= *((int *) data
);
451 /* Ignore linker created section. See elfNN_ia64_object_p in
453 if (section
->flags
& SEC_LINKER_CREATED
)
456 /* PR 10413: Skip sections that we are ignoring. */
457 if (! process_section_p (section
))
460 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
461 bfd_get_section_name (abfd
, section
),
462 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
463 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
465 bfd_printf_vma (abfd
, section
->lma
);
466 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
467 bfd_get_section_alignment (abfd
, section
));
473 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
475 PF (SEC_HAS_CONTENTS
, "CONTENTS");
476 PF (SEC_ALLOC
, "ALLOC");
477 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
478 PF (SEC_LOAD
, "LOAD");
479 PF (SEC_RELOC
, "RELOC");
480 PF (SEC_READONLY
, "READONLY");
481 PF (SEC_CODE
, "CODE");
482 PF (SEC_DATA
, "DATA");
484 PF (SEC_DEBUGGING
, "DEBUGGING");
485 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
486 PF (SEC_EXCLUDE
, "EXCLUDE");
487 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
488 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
490 PF (SEC_TIC54X_BLOCK
, "BLOCK");
491 PF (SEC_TIC54X_CLINK
, "CLINK");
493 PF (SEC_SMALL_DATA
, "SMALL_DATA");
494 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
496 PF (SEC_COFF_SHARED
, "SHARED");
497 PF (SEC_COFF_NOREAD
, "NOREAD");
499 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
500 PF (SEC_ELF_PURECODE
, "PURECODE");
501 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
502 PF (SEC_GROUP
, "GROUP");
503 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
505 PF (SEC_MEP_VLIW
, "VLIW");
508 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
511 struct coff_comdat_info
*comdat
;
513 switch (section
->flags
& SEC_LINK_DUPLICATES
)
517 case SEC_LINK_DUPLICATES_DISCARD
:
518 ls
= "LINK_ONCE_DISCARD";
520 case SEC_LINK_DUPLICATES_ONE_ONLY
:
521 ls
= "LINK_ONCE_ONE_ONLY";
523 case SEC_LINK_DUPLICATES_SAME_SIZE
:
524 ls
= "LINK_ONCE_SAME_SIZE";
526 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
527 ls
= "LINK_ONCE_SAME_CONTENTS";
530 printf ("%s%s", comma
, ls
);
532 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
534 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
543 /* Called on each SECTION in ABFD, update the int variable pointed to by
544 DATA which contains the string length of the longest section name. */
547 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
549 int *longest_so_far
= (int *) data
;
553 /* Ignore linker created section. */
554 if (section
->flags
& SEC_LINKER_CREATED
)
557 /* Skip sections that we are ignoring. */
558 if (! process_section_p (section
))
561 name
= bfd_get_section_name (abfd
, section
);
562 len
= (int) strlen (name
);
563 if (len
> *longest_so_far
)
564 *longest_so_far
= len
;
568 dump_headers (bfd
*abfd
)
570 /* The default width of 13 is just an arbitrary choice. */
571 int max_section_name_length
= 13;
577 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
578 if (bfd_get_arch_size (abfd
) == 32)
584 printf (_("Sections:\n"));
587 bfd_map_over_sections (abfd
, find_longest_section_name
,
588 &max_section_name_length
);
590 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
591 max_section_name_length
, "Name",
592 bfd_vma_width
, "VMA",
593 bfd_vma_width
, "LMA");
596 printf (_(" Flags"));
599 bfd_map_over_sections (abfd
, dump_section_header
,
600 &max_section_name_length
);
604 slurp_symtab (bfd
*abfd
)
609 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
615 storage
= bfd_get_symtab_upper_bound (abfd
);
618 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
619 bfd_fatal (_("error message was"));
622 sy
= (asymbol
**) xmalloc (storage
);
624 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
626 bfd_fatal (bfd_get_filename (abfd
));
630 /* Read in the dynamic symbols. */
633 slurp_dynamic_symtab (bfd
*abfd
)
638 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
641 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
643 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
649 bfd_fatal (bfd_get_filename (abfd
));
652 sy
= (asymbol
**) xmalloc (storage
);
654 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
656 bfd_fatal (bfd_get_filename (abfd
));
660 /* Some symbol names are significant and should be kept in the
661 table of sorted symbol names, even if they are marked as
662 debugging/section symbols. */
665 is_significant_symbol_name (const char * name
)
667 return strcmp (name
, ".plt") == 0
668 || strcmp (name
, ".got") == 0
669 || strcmp (name
, ".plt.got") == 0;
672 /* Filter out (in place) symbols that are useless for disassembly.
673 COUNT is the number of elements in SYMBOLS.
674 Return the number of useful symbols. */
677 remove_useless_symbols (asymbol
**symbols
, long count
)
679 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
683 asymbol
*sym
= *in_ptr
++;
685 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
687 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
688 && ! is_significant_symbol_name (sym
->name
))
690 if (bfd_is_und_section (sym
->section
)
691 || bfd_is_com_section (sym
->section
))
696 return out_ptr
- symbols
;
699 /* Sort symbols into value order. */
702 compare_symbols (const void *ap
, const void *bp
)
704 const asymbol
*a
= * (const asymbol
**) ap
;
705 const asymbol
*b
= * (const asymbol
**) bp
;
715 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
717 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
720 if (a
->section
> b
->section
)
722 else if (a
->section
< b
->section
)
725 an
= bfd_asymbol_name (a
);
726 bn
= bfd_asymbol_name (b
);
730 /* The symbols gnu_compiled and gcc2_compiled convey no real
731 information, so put them after other symbols with the same value. */
732 af
= (strstr (an
, "gnu_compiled") != NULL
733 || strstr (an
, "gcc2_compiled") != NULL
);
734 bf
= (strstr (bn
, "gnu_compiled") != NULL
735 || strstr (bn
, "gcc2_compiled") != NULL
);
742 /* We use a heuristic for the file name, to try to sort it after
743 more useful symbols. It may not work on non Unix systems, but it
744 doesn't really matter; the only difference is precisely which
745 symbol names get printed. */
747 #define file_symbol(s, sn, snl) \
748 (((s)->flags & BSF_FILE) != 0 \
749 || ((sn)[(snl) - 2] == '.' \
750 && ((sn)[(snl) - 1] == 'o' \
751 || (sn)[(snl) - 1] == 'a')))
753 af
= file_symbol (a
, an
, anl
);
754 bf
= file_symbol (b
, bn
, bnl
);
761 /* Try to sort global symbols before local symbols before function
762 symbols before debugging symbols. */
767 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
769 if ((aflags
& BSF_DEBUGGING
) != 0)
774 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
776 if ((aflags
& BSF_FUNCTION
) != 0)
781 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
783 if ((aflags
& BSF_LOCAL
) != 0)
788 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
790 if ((aflags
& BSF_GLOBAL
) != 0)
796 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
797 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
802 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
803 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
805 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
806 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
808 return asz
> bsz
? -1 : 1;
811 /* Symbols that start with '.' might be section names, so sort them
812 after symbols that don't start with '.'. */
813 if (an
[0] == '.' && bn
[0] != '.')
815 if (an
[0] != '.' && bn
[0] == '.')
818 /* Finally, if we can't distinguish them in any other way, try to
819 get consistent results by sorting the symbols by name. */
820 return strcmp (an
, bn
);
823 /* Sort relocs into address order. */
826 compare_relocs (const void *ap
, const void *bp
)
828 const arelent
*a
= * (const arelent
**) ap
;
829 const arelent
*b
= * (const arelent
**) bp
;
831 if (a
->address
> b
->address
)
833 else if (a
->address
< b
->address
)
836 /* So that associated relocations tied to the same address show up
837 in the correct order, we don't do any further sorting. */
846 /* Print an address (VMA) to the output stream in INFO.
847 If SKIP_ZEROES is TRUE, omit leading zeroes. */
850 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
851 bfd_boolean skip_zeroes
)
855 struct objdump_disasm_info
*aux
;
857 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
858 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
863 for (p
= buf
; *p
== '0'; ++p
)
868 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
871 /* Print the name of a symbol. */
874 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
878 const char *name
, *version_string
= NULL
;
879 bfd_boolean hidden
= FALSE
;
882 name
= bfd_asymbol_name (sym
);
883 if (do_demangle
&& name
[0] != '\0')
885 /* Demangle the name. */
886 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
891 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
892 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
894 if (bfd_is_und_section (bfd_get_section (sym
)))
899 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
900 if (version_string
&& *version_string
!= '\0')
901 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
907 if (version_string
&& *version_string
!= '\0')
908 printf (hidden
? "@%s" : "@@%s", version_string
);
915 /* Locate a symbol given a bfd and a section (from INFO->application_data),
916 and a VMA. If INFO->application_data->require_sec is TRUE, then always
917 require the symbol to be in the section. Returns NULL if there is no
918 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
919 of the symbol in sorted_syms. */
922 find_symbol_for_address (bfd_vma vma
,
923 struct disassemble_info
*inf
,
926 /* @@ Would it speed things up to cache the last two symbols returned,
927 and maybe their address ranges? For many processors, only one memory
928 operand can be present at a time, so the 2-entry cache wouldn't be
929 constantly churned by code doing heavy memory accesses. */
931 /* Indices in `sorted_syms'. */
933 long max_count
= sorted_symcount
;
935 struct objdump_disasm_info
*aux
;
939 bfd_boolean want_section
;
941 if (sorted_symcount
< 1)
944 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
947 opb
= inf
->octets_per_byte
;
949 /* Perform a binary search looking for the closest symbol to the
950 required value. We are searching the range (min, max_count]. */
951 while (min
+ 1 < max_count
)
955 thisplace
= (max_count
+ min
) / 2;
956 sym
= sorted_syms
[thisplace
];
958 if (bfd_asymbol_value (sym
) > vma
)
959 max_count
= thisplace
;
960 else if (bfd_asymbol_value (sym
) < vma
)
969 /* The symbol we want is now in min, the low end of the range we
970 were searching. If there are several symbols with the same
971 value, we want the first (non-section/non-debugging) one. */
974 && (bfd_asymbol_value (sorted_syms
[thisplace
])
975 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
976 && ((sorted_syms
[thisplace
- 1]->flags
977 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
981 /* Prefer a symbol in the current section if we have multple symbols
982 with the same value, as can occur with overlays or zero size
985 while (min
< max_count
986 && (bfd_asymbol_value (sorted_syms
[min
])
987 == bfd_asymbol_value (sorted_syms
[thisplace
])))
989 if (sorted_syms
[min
]->section
== sec
990 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
997 return sorted_syms
[thisplace
];
1002 /* If the file is relocatable, and the symbol could be from this
1003 section, prefer a symbol from this section over symbols from
1004 others, even if the other symbol's value might be closer.
1006 Note that this may be wrong for some symbol references if the
1007 sections have overlapping memory ranges, but in that case there's
1008 no way to tell what's desired without looking at the relocation
1011 Also give the target a chance to reject symbols. */
1012 want_section
= (aux
->require_sec
1013 || ((abfd
->flags
& HAS_RELOC
) != 0
1014 && vma
>= bfd_get_section_vma (abfd
, sec
)
1015 && vma
< (bfd_get_section_vma (abfd
, sec
)
1016 + bfd_section_size (abfd
, sec
) / opb
)));
1017 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1018 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1021 long newplace
= sorted_symcount
;
1023 for (i
= min
- 1; i
>= 0; i
--)
1025 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1026 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1028 if (newplace
== sorted_symcount
)
1031 if (bfd_asymbol_value (sorted_syms
[i
])
1032 != bfd_asymbol_value (sorted_syms
[newplace
]))
1035 /* Remember this symbol and keep searching until we reach
1036 an earlier address. */
1041 if (newplace
!= sorted_symcount
)
1042 thisplace
= newplace
;
1045 /* We didn't find a good symbol with a smaller value.
1046 Look for one with a larger value. */
1047 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1049 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1050 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1058 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1059 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1060 /* There is no suitable symbol. */
1064 /* If we have not found an exact match for the specified address
1065 and we have dynamic relocations available, then we can produce
1066 a better result by matching a relocation to the address and
1067 using the symbol associated with that relocation. */
1069 && aux
->dynrelbuf
!= NULL
1070 && sorted_syms
[thisplace
]->value
!= vma
1071 /* If we have matched a synthetic symbol, then stick with that. */
1072 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1077 for (rel_count
= aux
->dynrelcount
, rel_pp
= aux
->dynrelbuf
;
1080 arelent
* rel
= rel_pp
[rel_count
];
1082 if (rel
->address
== vma
1083 && rel
->sym_ptr_ptr
!= NULL
1084 /* Absolute relocations do not provide a more helpful symbolic address. */
1085 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1088 * place
= thisplace
;
1089 return * rel
->sym_ptr_ptr
;
1092 /* We are scanning backwards, so if we go below the target address
1094 if (rel_pp
[rel_count
]->address
< vma
)
1102 return sorted_syms
[thisplace
];
1105 /* Print an address and the offset to the nearest symbol. */
1108 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1109 bfd_vma vma
, struct disassemble_info
*inf
,
1110 bfd_boolean skip_zeroes
)
1112 objdump_print_value (vma
, inf
, skip_zeroes
);
1118 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1119 bfd_get_section_name (abfd
, sec
));
1120 secaddr
= bfd_get_section_vma (abfd
, sec
);
1123 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1124 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1126 else if (vma
> secaddr
)
1128 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1129 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1131 (*inf
->fprintf_func
) (inf
->stream
, ">");
1135 (*inf
->fprintf_func
) (inf
->stream
, " <");
1137 objdump_print_symname (abfd
, inf
, sym
);
1139 if (bfd_asymbol_value (sym
) == vma
)
1141 /* Undefined symbols in an executables and dynamic objects do not have
1142 a value associated with them, so it does not make sense to display
1143 an offset relative to them. Normally we would not be provided with
1144 this kind of symbol, but the target backend might choose to do so,
1145 and the code in find_symbol_for_address might return an as yet
1146 unresolved symbol associated with a dynamic reloc. */
1147 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1148 && bfd_is_und_section (sym
->section
))
1150 else if (bfd_asymbol_value (sym
) > vma
)
1152 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1153 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1155 else if (vma
> bfd_asymbol_value (sym
))
1157 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1158 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1161 (*inf
->fprintf_func
) (inf
->stream
, ">");
1164 if (display_file_offsets
)
1165 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1166 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1169 /* Print an address (VMA), symbolically if possible.
1170 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1173 objdump_print_addr (bfd_vma vma
,
1174 struct disassemble_info
*inf
,
1175 bfd_boolean skip_zeroes
)
1177 struct objdump_disasm_info
*aux
;
1178 asymbol
*sym
= NULL
;
1179 bfd_boolean skip_find
= FALSE
;
1181 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1183 if (sorted_symcount
< 1)
1185 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1186 objdump_print_value (vma
, inf
, skip_zeroes
);
1188 if (display_file_offsets
)
1189 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1190 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1194 if (aux
->reloc
!= NULL
1195 && aux
->reloc
->sym_ptr_ptr
!= NULL
1196 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1198 sym
= * aux
->reloc
->sym_ptr_ptr
;
1200 /* Adjust the vma to the reloc. */
1201 vma
+= bfd_asymbol_value (sym
);
1203 if (bfd_is_und_section (bfd_get_section (sym
)))
1208 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1210 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1214 /* Print VMA to INFO. This function is passed to the disassembler
1218 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1220 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1223 /* Determine if the given address has a symbol associated with it. */
1226 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1230 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1232 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1235 /* Hold the last function name and the last line number we displayed
1236 in a disassembly. */
1238 static char *prev_functionname
;
1239 static unsigned int prev_line
;
1240 static unsigned int prev_discriminator
;
1242 /* We keep a list of all files that we have seen when doing a
1243 disassembly with source, so that we know how much of the file to
1244 display. This can be important for inlined functions. */
1246 struct print_file_list
1248 struct print_file_list
*next
;
1249 const char *filename
;
1250 const char *modname
;
1253 const char **linemap
;
1256 unsigned max_printed
;
1260 static struct print_file_list
*print_files
;
1262 /* The number of preceding context lines to show when we start
1263 displaying a file for the first time. */
1265 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1267 /* Read a complete file into memory. */
1270 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1273 int ps
= getpagesize ();
1277 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1281 if (fstat (fd
, fst
) < 0)
1286 *size
= fst
->st_size
;
1288 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1289 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1290 if (map
!= (char *) -1L)
1296 map
= (const char *) malloc (*size
);
1297 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1299 free ((void *) map
);
1306 #define line_map_decrease 5
1308 /* Precompute array of lines for a mapped file. */
1310 static const char **
1311 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1313 const char *p
, *lstart
, *end
;
1314 int chars_per_line
= 45; /* First iteration will use 40. */
1315 unsigned int lineno
;
1316 const char **linemap
= NULL
;
1317 unsigned long line_map_size
= 0;
1323 for (p
= map
; p
< end
; p
++)
1327 if (p
+ 1 < end
&& p
[1] == '\r')
1330 else if (*p
== '\r')
1332 if (p
+ 1 < end
&& p
[1] == '\n')
1338 /* End of line found. */
1340 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1342 unsigned long newsize
;
1344 chars_per_line
-= line_map_decrease
;
1345 if (chars_per_line
<= 1)
1347 line_map_size
= size
/ chars_per_line
+ 1;
1348 if (line_map_size
< lineno
+ 1)
1349 line_map_size
= lineno
+ 1;
1350 newsize
= line_map_size
* sizeof (char *);
1351 linemap
= (const char **) xrealloc (linemap
, newsize
);
1354 linemap
[lineno
++] = lstart
;
1362 /* Tries to open MODNAME, and if successful adds a node to print_files
1363 linked list and returns that node. Returns NULL on failure. */
1365 static struct print_file_list
*
1366 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1368 struct print_file_list
*p
;
1370 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1372 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1379 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1382 p
->filename
= origname
;
1383 p
->modname
= modname
;
1384 p
->next
= print_files
;
1390 /* If the source file, as described in the symtab, is not found
1391 try to locate it in one of the paths specified with -I
1392 If found, add location to print_files linked list. */
1394 static struct print_file_list
*
1395 update_source_path (const char *filename
, bfd
*abfd
)
1397 struct print_file_list
*p
;
1402 p
= try_print_file_open (filename
, filename
, &fst
);
1405 if (include_path_count
== 0)
1408 /* Get the name of the file. */
1409 fname
= lbasename (filename
);
1411 /* If file exists under a new path, we need to add it to the list
1412 so that show_line knows about it. */
1413 for (i
= 0; i
< include_path_count
; i
++)
1415 char *modname
= concat (include_paths
[i
], "/", fname
,
1418 p
= try_print_file_open (filename
, modname
, &fst
);
1428 long mtime
= bfd_get_mtime (abfd
);
1430 if (fst
.st_mtime
> mtime
)
1431 warn (_("source file %s is more recent than object file\n"),
1438 /* Print a source file line. */
1441 print_line (struct print_file_list
*p
, unsigned int linenum
)
1447 if (linenum
>= p
->maxline
)
1449 l
= p
->linemap
[linenum
];
1450 /* Test fwrite return value to quiet glibc warning. */
1451 len
= strcspn (l
, "\n\r");
1452 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1456 /* Print a range of source code lines. */
1459 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1463 while (start
<= end
)
1465 print_line (p
, start
);
1470 /* Show the line number, or the source line, in a disassembly
1474 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1476 const char *filename
;
1477 const char *functionname
;
1478 unsigned int linenumber
;
1479 unsigned int discriminator
;
1483 if (! with_line_numbers
&& ! with_source_code
)
1486 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1487 &filename
, &functionname
,
1488 &linenumber
, &discriminator
))
1491 if (filename
!= NULL
&& *filename
== '\0')
1493 if (functionname
!= NULL
&& *functionname
== '\0')
1494 functionname
= NULL
;
1497 && IS_ABSOLUTE_PATH (filename
)
1501 const char *fname
= filename
;
1503 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1506 memcpy (path
, prefix
, prefix_length
);
1507 path_up
= path
+ prefix_length
;
1509 /* Build relocated filename, stripping off leading directories
1510 from the initial filename if requested. */
1511 if (prefix_strip
> 0)
1516 /* Skip selected directory levels. */
1517 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1518 if (IS_DIR_SEPARATOR(*s
))
1525 /* Update complete filename. */
1526 strncpy (path_up
, fname
, PATH_MAX
);
1527 path_up
[PATH_MAX
] = '\0';
1535 if (with_line_numbers
)
1537 if (functionname
!= NULL
1538 && (prev_functionname
== NULL
1539 || strcmp (functionname
, prev_functionname
) != 0))
1541 printf ("%s():\n", functionname
);
1545 && (linenumber
!= prev_line
1546 || discriminator
!= prev_discriminator
))
1548 if (discriminator
> 0)
1549 printf ("%s:%u (discriminator %u)\n",
1550 filename
== NULL
? "???" : filename
,
1551 linenumber
, discriminator
);
1553 printf ("%s:%u\n", filename
== NULL
? "???" : filename
,
1558 const char *filename2
;
1559 const char *functionname2
;
1562 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1564 printf ("inlined by %s:%u (%s)\n", filename2
, line2
,
1569 if (with_source_code
1573 struct print_file_list
**pp
, *p
;
1576 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1577 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1584 filename
= xstrdup (filename
);
1585 p
= update_source_path (filename
, abfd
);
1588 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1590 if (file_start_context
&& p
->first
)
1594 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1595 if (l
>= linenumber
)
1597 if (p
->max_printed
>= l
)
1599 if (p
->max_printed
< linenumber
)
1600 l
= p
->max_printed
+ 1;
1605 dump_lines (p
, l
, linenumber
);
1606 if (p
->max_printed
< linenumber
)
1607 p
->max_printed
= linenumber
;
1608 p
->last_line
= linenumber
;
1613 if (functionname
!= NULL
1614 && (prev_functionname
== NULL
1615 || strcmp (functionname
, prev_functionname
) != 0))
1617 if (prev_functionname
!= NULL
)
1618 free (prev_functionname
);
1619 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1620 strcpy (prev_functionname
, functionname
);
1623 if (linenumber
> 0 && linenumber
!= prev_line
)
1624 prev_line
= linenumber
;
1626 if (discriminator
!= prev_discriminator
)
1627 prev_discriminator
= discriminator
;
1633 /* Pseudo FILE object for strings. */
1641 /* sprintf to a "stream". */
1643 static int ATTRIBUTE_PRINTF_2
1644 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1651 size_t space
= f
->alloc
- f
->pos
;
1653 va_start (args
, format
);
1654 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1660 f
->alloc
= (f
->alloc
+ n
) * 2;
1661 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1668 /* The number of zeroes we want to see before we start skipping them.
1669 The number is arbitrarily chosen. */
1671 #define DEFAULT_SKIP_ZEROES 8
1673 /* The number of zeroes to skip at the end of a section. If the
1674 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1675 SKIP_ZEROES, they will be disassembled. If there are fewer than
1676 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1677 attempt to avoid disassembling zeroes inserted by section
1680 #define DEFAULT_SKIP_ZEROES_AT_END 3
1682 /* Disassemble some data in memory between given values. */
1685 disassemble_bytes (struct disassemble_info
* inf
,
1686 disassembler_ftype disassemble_fn
,
1689 bfd_vma start_offset
,
1690 bfd_vma stop_offset
,
1693 arelent
** relppend
)
1695 struct objdump_disasm_info
*aux
;
1697 int octets_per_line
;
1698 int skip_addr_chars
;
1699 bfd_vma addr_offset
;
1700 unsigned int opb
= inf
->octets_per_byte
;
1701 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1702 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1706 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1710 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1714 octets_per_line
= insn_width
;
1716 octets_per_line
= 4;
1718 octets_per_line
= 16;
1720 /* Figure out how many characters to skip at the start of an
1721 address, to make the disassembly look nicer. We discard leading
1722 zeroes in chunks of 4, ensuring that there is always a leading
1724 skip_addr_chars
= 0;
1725 if (! prefix_addresses
)
1729 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1731 while (buf
[skip_addr_chars
] == '0')
1734 /* Don't discard zeros on overflow. */
1735 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1736 skip_addr_chars
= 0;
1738 if (skip_addr_chars
!= 0)
1739 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1742 inf
->insn_info_valid
= 0;
1744 addr_offset
= start_offset
;
1745 while (addr_offset
< stop_offset
)
1748 bfd_boolean need_nl
= FALSE
;
1749 int previous_octets
;
1751 /* Remember the length of the previous instruction. */
1752 previous_octets
= octets
;
1755 /* Make sure we don't use relocs from previous instructions. */
1758 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1760 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1763 if (! disassemble_zeroes
1764 && (inf
->insn_info_valid
== 0
1765 || inf
->branch_delay_insns
== 0)
1766 && (z
- addr_offset
* opb
>= skip_zeroes
1767 || (z
== stop_offset
* opb
&&
1768 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1770 /* If there are more nonzero octets to follow, we only skip
1771 zeroes in multiples of 4, to try to avoid running over
1772 the start of an instruction which happens to start with
1774 if (z
!= stop_offset
* opb
)
1775 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1777 octets
= z
- addr_offset
* opb
;
1779 /* If we are going to display more data, and we are displaying
1780 file offsets, then tell the user how many zeroes we skip
1781 and the file offset from where we resume dumping. */
1782 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1783 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1785 (unsigned long) (section
->filepos
1786 + (addr_offset
+ (octets
/ opb
))));
1796 if (with_line_numbers
|| with_source_code
)
1797 show_line (aux
->abfd
, section
, addr_offset
);
1799 if (! prefix_addresses
)
1803 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1804 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1808 printf ("%s:\t", buf
+ skip_addr_chars
);
1812 aux
->require_sec
= TRUE
;
1813 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1814 aux
->require_sec
= FALSE
;
1821 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1822 inf
->stream
= &sfile
;
1823 inf
->bytes_per_line
= 0;
1824 inf
->bytes_per_chunk
= 0;
1825 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1827 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1829 if (inf
->disassembler_needs_relocs
1830 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1831 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1832 && *relppp
< relppend
)
1834 bfd_signed_vma distance_to_rel
;
1836 distance_to_rel
= (**relppp
)->address
1837 - (rel_offset
+ addr_offset
);
1839 /* Check to see if the current reloc is associated with
1840 the instruction that we are about to disassemble. */
1841 if (distance_to_rel
== 0
1842 /* FIXME: This is wrong. We are trying to catch
1843 relocs that are addressed part way through the
1844 current instruction, as might happen with a packed
1845 VLIW instruction. Unfortunately we do not know the
1846 length of the current instruction since we have not
1847 disassembled it yet. Instead we take a guess based
1848 upon the length of the previous instruction. The
1849 proper solution is to have a new target-specific
1850 disassembler function which just returns the length
1851 of an instruction at a given address without trying
1852 to display its disassembly. */
1853 || (distance_to_rel
> 0
1854 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1856 inf
->flags
|= INSN_HAS_RELOC
;
1857 aux
->reloc
= **relppp
;
1861 if (! disassemble_all
1862 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1863 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1864 /* Set a stop_vma so that the disassembler will not read
1865 beyond the next symbol. We assume that symbols appear on
1866 the boundaries between instructions. We only do this when
1867 disassembling code of course, and when -D is in effect. */
1868 inf
->stop_vma
= section
->vma
+ stop_offset
;
1870 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1873 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1874 inf
->stream
= stdout
;
1875 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1876 octets_per_line
= inf
->bytes_per_line
;
1877 if (octets
< (int) opb
)
1880 printf ("%s\n", sfile
.buffer
);
1883 non_fatal (_("disassemble_fn returned length %d"),
1894 octets
= octets_per_line
;
1895 if (addr_offset
+ octets
/ opb
> stop_offset
)
1896 octets
= (stop_offset
- addr_offset
) * opb
;
1898 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1900 if (ISPRINT (data
[j
]))
1901 buf
[j
- addr_offset
* opb
] = data
[j
];
1903 buf
[j
- addr_offset
* opb
] = '.';
1905 buf
[j
- addr_offset
* opb
] = '\0';
1908 if (prefix_addresses
1910 : show_raw_insn
>= 0)
1914 /* If ! prefix_addresses and ! wide_output, we print
1915 octets_per_line octets per line. */
1917 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1918 pb
= octets_per_line
;
1920 if (inf
->bytes_per_chunk
)
1921 bpc
= inf
->bytes_per_chunk
;
1925 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1927 /* PR 21580: Check for a buffer ending early. */
1928 if (j
+ bpc
<= stop_offset
* opb
)
1932 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1934 for (k
= bpc
- 1; k
>= 0; k
--)
1935 printf ("%02x", (unsigned) data
[j
+ k
]);
1939 for (k
= 0; k
< bpc
; k
++)
1940 printf ("%02x", (unsigned) data
[j
+ k
]);
1946 for (; pb
< octets_per_line
; pb
+= bpc
)
1950 for (k
= 0; k
< bpc
; k
++)
1955 /* Separate raw data from instruction by extra space. */
1965 printf ("%s", sfile
.buffer
);
1967 if (prefix_addresses
1969 : show_raw_insn
>= 0)
1977 j
= addr_offset
* opb
+ pb
;
1979 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1980 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1984 printf ("%s:\t", buf
+ skip_addr_chars
);
1986 pb
+= octets_per_line
;
1989 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1991 /* PR 21619: Check for a buffer ending early. */
1992 if (j
+ bpc
<= stop_offset
* opb
)
1996 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1998 for (k
= bpc
- 1; k
>= 0; k
--)
1999 printf ("%02x", (unsigned) data
[j
+ k
]);
2003 for (k
= 0; k
< bpc
; k
++)
2004 printf ("%02x", (unsigned) data
[j
+ k
]);
2018 while ((*relppp
) < relppend
2019 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2021 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2032 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2035 if (q
->howto
== NULL
)
2036 printf (": *unknown*\t");
2037 else if (q
->howto
->name
)
2038 printf (": %s\t", q
->howto
->name
);
2040 printf (": %d\t", q
->howto
->type
);
2042 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2043 printf ("*unknown*");
2046 const char *sym_name
;
2048 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2049 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2050 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2055 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2056 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2057 if (sym_name
== NULL
|| *sym_name
== '\0')
2058 sym_name
= "*unknown*";
2059 printf ("%s", sym_name
);
2065 bfd_signed_vma addend
= q
->addend
;
2073 objdump_print_value (addend
, inf
, TRUE
);
2085 addr_offset
+= octets
/ opb
;
2088 free (sfile
.buffer
);
2092 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2094 const struct elf_backend_data
* bed
;
2095 bfd_vma sign_adjust
= 0;
2096 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2097 struct objdump_disasm_info
* paux
;
2098 unsigned int opb
= pinfo
->octets_per_byte
;
2099 bfd_byte
* data
= NULL
;
2100 bfd_size_type datasize
= 0;
2101 arelent
** rel_pp
= NULL
;
2102 arelent
** rel_ppstart
= NULL
;
2103 arelent
** rel_ppend
;
2104 bfd_vma stop_offset
;
2105 asymbol
* sym
= NULL
;
2109 unsigned long addr_offset
;
2111 /* Sections that do not contain machine
2112 code are not normally disassembled. */
2113 if (! disassemble_all
2114 && only_list
== NULL
2115 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2116 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2119 if (! process_section_p (section
))
2122 datasize
= bfd_get_section_size (section
);
2126 if (start_address
== (bfd_vma
) -1
2127 || start_address
< section
->vma
)
2130 addr_offset
= start_address
- section
->vma
;
2132 if (stop_address
== (bfd_vma
) -1)
2133 stop_offset
= datasize
/ opb
;
2136 if (stop_address
< section
->vma
)
2139 stop_offset
= stop_address
- section
->vma
;
2140 if (stop_offset
> datasize
/ opb
)
2141 stop_offset
= datasize
/ opb
;
2144 if (addr_offset
>= stop_offset
)
2147 /* Decide which set of relocs to use. Load them if necessary. */
2148 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2149 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2151 rel_pp
= paux
->dynrelbuf
;
2152 rel_count
= paux
->dynrelcount
;
2153 /* Dynamic reloc addresses are absolute, non-dynamic are section
2154 relative. REL_OFFSET specifies the reloc address corresponding
2155 to the start of this section. */
2156 rel_offset
= section
->vma
;
2164 if ((section
->flags
& SEC_RELOC
) != 0
2165 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2169 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2171 bfd_fatal (bfd_get_filename (abfd
));
2175 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2176 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2178 bfd_fatal (bfd_get_filename (abfd
));
2180 /* Sort the relocs by address. */
2181 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2185 rel_ppend
= rel_pp
+ rel_count
;
2187 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2189 non_fatal (_("Reading section %s failed because: %s"),
2190 section
->name
, bfd_errmsg (bfd_get_error ()));
2194 paux
->sec
= section
;
2195 pinfo
->buffer
= data
;
2196 pinfo
->buffer_vma
= section
->vma
;
2197 pinfo
->buffer_length
= datasize
;
2198 pinfo
->section
= section
;
2200 /* Skip over the relocs belonging to addresses below the
2202 while (rel_pp
< rel_ppend
2203 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2206 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2208 /* Find the nearest symbol forwards from our current position. */
2209 paux
->require_sec
= TRUE
;
2210 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2211 (struct disassemble_info
*) inf
,
2213 paux
->require_sec
= FALSE
;
2215 /* PR 9774: If the target used signed addresses then we must make
2216 sure that we sign extend the value that we calculate for 'addr'
2217 in the loop below. */
2218 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2219 && (bed
= get_elf_backend_data (abfd
)) != NULL
2220 && bed
->sign_extend_vma
)
2221 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2223 /* Disassemble a block of instructions up to the address associated with
2224 the symbol we have just found. Then print the symbol and find the
2225 next symbol on. Repeat until we have disassembled the entire section
2226 or we have reached the end of the address range we are interested in. */
2227 while (addr_offset
< stop_offset
)
2231 bfd_vma nextstop_offset
;
2234 addr
= section
->vma
+ addr_offset
;
2235 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2237 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2242 (x
< sorted_symcount
2243 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2247 pinfo
->symbols
= sorted_syms
+ place
;
2248 pinfo
->num_symbols
= x
- place
;
2249 pinfo
->symtab_pos
= place
;
2253 pinfo
->symbols
= NULL
;
2254 pinfo
->num_symbols
= 0;
2255 pinfo
->symtab_pos
= -1;
2258 if (! prefix_addresses
)
2260 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2261 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2263 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2266 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2268 else if (sym
== NULL
)
2272 #define is_valid_next_sym(SYM) \
2273 ((SYM)->section == section \
2274 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2275 && pinfo->symbol_is_valid (SYM, pinfo))
2277 /* Search forward for the next appropriate symbol in
2278 SECTION. Note that all the symbols are sorted
2279 together into one big array, and that some sections
2280 may have overlapping addresses. */
2281 while (place
< sorted_symcount
2282 && ! is_valid_next_sym (sorted_syms
[place
]))
2285 if (place
>= sorted_symcount
)
2288 nextsym
= sorted_syms
[place
];
2291 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2292 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2293 else if (nextsym
== NULL
)
2294 nextstop_offset
= stop_offset
;
2296 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2298 if (nextstop_offset
> stop_offset
2299 || nextstop_offset
<= addr_offset
)
2300 nextstop_offset
= stop_offset
;
2302 /* If a symbol is explicitly marked as being an object
2303 rather than a function, just dump the bytes without
2304 disassembling them. */
2307 || sym
->section
!= section
2308 || bfd_asymbol_value (sym
) > addr
2309 || ((sym
->flags
& BSF_OBJECT
) == 0
2310 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2312 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2314 || (sym
->flags
& BSF_FUNCTION
) != 0)
2319 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2320 addr_offset
, nextstop_offset
,
2321 rel_offset
, &rel_pp
, rel_ppend
);
2323 addr_offset
= nextstop_offset
;
2329 if (rel_ppstart
!= NULL
)
2333 /* Disassemble the contents of an object file. */
2336 disassemble_data (bfd
*abfd
)
2338 struct disassemble_info disasm_info
;
2339 struct objdump_disasm_info aux
;
2343 prev_functionname
= NULL
;
2345 prev_discriminator
= 0;
2347 /* We make a copy of syms to sort. We don't want to sort syms
2348 because that will screw up the relocs. */
2349 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2350 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2351 * sizeof (asymbol
*));
2352 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2353 sorted_symcount
* sizeof (asymbol
*));
2355 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2357 for (i
= 0; i
< synthcount
; ++i
)
2359 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2363 /* Sort the symbols into section and symbol order. */
2364 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2366 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2368 disasm_info
.application_data
= (void *) &aux
;
2370 aux
.require_sec
= FALSE
;
2371 aux
.dynrelbuf
= NULL
;
2372 aux
.dynrelcount
= 0;
2375 disasm_info
.print_address_func
= objdump_print_address
;
2376 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2378 if (machine
!= NULL
)
2380 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2383 fatal (_("can't use supplied machine %s"), machine
);
2385 abfd
->arch_info
= inf
;
2388 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2390 struct bfd_target
*xvec
;
2392 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2393 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2394 xvec
->byteorder
= endian
;
2398 /* Use libopcodes to locate a suitable disassembler. */
2399 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2400 bfd_big_endian (abfd
),
2401 bfd_get_mach (abfd
), abfd
);
2402 if (!aux
.disassemble_fn
)
2404 non_fatal (_("can't disassemble for architecture %s\n"),
2405 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2410 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2411 disasm_info
.arch
= bfd_get_arch (abfd
);
2412 disasm_info
.mach
= bfd_get_mach (abfd
);
2413 disasm_info
.disassembler_options
= disassembler_options
;
2414 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2415 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2416 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2417 disasm_info
.disassembler_needs_relocs
= FALSE
;
2419 if (bfd_big_endian (abfd
))
2420 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2421 else if (bfd_little_endian (abfd
))
2422 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2424 /* ??? Aborting here seems too drastic. We could default to big or little
2426 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2428 /* Allow the target to customize the info structure. */
2429 disassemble_init_for_target (& disasm_info
);
2431 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2433 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2435 if (relsize
< 0 && dump_dynamic_reloc_info
)
2436 bfd_fatal (bfd_get_filename (abfd
));
2440 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2441 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2444 if (aux
.dynrelcount
< 0)
2445 bfd_fatal (bfd_get_filename (abfd
));
2447 /* Sort the relocs by address. */
2448 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2452 disasm_info
.symtab
= sorted_syms
;
2453 disasm_info
.symtab_size
= sorted_symcount
;
2455 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2457 if (aux
.dynrelbuf
!= NULL
)
2458 free (aux
.dynrelbuf
);
2463 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2464 asection
*sec
, void *file
)
2466 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2467 bfd
*abfd
= (bfd
*) file
;
2471 if (section
->start
!= NULL
)
2473 /* If it is already loaded, do nothing. */
2474 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2476 free (section
->start
);
2479 section
->filename
= bfd_get_filename (abfd
);
2480 section
->reloc_info
= NULL
;
2481 section
->num_relocs
= 0;
2482 section
->address
= bfd_get_section_vma (abfd
, sec
);
2483 section
->size
= bfd_get_section_size (sec
);
2484 amt
= section
->size
+ 1;
2485 section
->start
= contents
= malloc (amt
);
2486 section
->user_data
= sec
;
2488 || section
->start
== NULL
2489 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2491 free_debug_section (debug
);
2492 printf (_("\nCan't get contents for section '%s'.\n"),
2496 /* Ensure any string section has a terminating NUL. */
2497 section
->start
[section
->size
] = 0;
2499 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2504 bfd_cache_section_contents (sec
, section
->start
);
2506 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2513 free_debug_section (debug
);
2514 printf (_("\nCan't get contents for section '%s'.\n"),
2519 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2522 unsigned long reloc_count
;
2525 relocs
= (arelent
**) xmalloc (reloc_size
);
2527 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2528 if (reloc_count
== 0)
2532 section
->reloc_info
= relocs
;
2533 section
->num_relocs
= reloc_count
;
2542 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2547 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2550 relocs
= (arelent
**) dsec
->reloc_info
;
2552 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2553 if (rp
->address
== offset
)
2560 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2562 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2563 bfd
*abfd
= (bfd
*) file
;
2566 /* If it is already loaded, do nothing. */
2567 if (section
->start
!= NULL
)
2569 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2573 /* Locate the debug section. */
2574 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2576 section
->name
= section
->uncompressed_name
;
2579 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2581 section
->name
= section
->compressed_name
;
2586 return load_specific_debug_section (debug
, sec
, file
);
2590 free_debug_section (enum dwarf_section_display_enum debug
)
2592 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2594 if (section
->start
== NULL
)
2597 /* PR 17512: file: 0f67f69d. */
2598 if (section
->user_data
!= NULL
)
2600 asection
* sec
= (asection
*) section
->user_data
;
2602 /* If we are freeing contents that are also pointed to by the BFD
2603 library's section structure then make sure to update those pointers
2604 too. Otherwise, the next time we try to load data for this section
2605 we can end up using a stale pointer. */
2606 if (section
->start
== sec
->contents
)
2608 sec
->contents
= NULL
;
2609 sec
->flags
&= ~ SEC_IN_MEMORY
;
2610 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2614 free ((char *) section
->start
);
2615 section
->start
= NULL
;
2616 section
->address
= 0;
2621 close_debug_file (void * file
)
2623 bfd
* abfd
= (bfd
*) file
;
2629 open_debug_file (const char * pathname
)
2633 data
= bfd_openr (pathname
, NULL
);
2637 if (! bfd_check_format (data
, bfd_object
))
2644 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2645 void *arg ATTRIBUTE_UNUSED
)
2647 const char *name
= bfd_get_section_name (abfd
, section
);
2651 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2652 match
= ".debug_info";
2656 for (i
= 0; i
< max
; i
++)
2657 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2658 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2659 && debug_displays
[i
].enabled
!= NULL
2660 && *debug_displays
[i
].enabled
)
2662 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2664 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2665 sec
->name
= sec
->uncompressed_name
;
2667 sec
->name
= sec
->compressed_name
;
2668 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2671 debug_displays
[i
].display (sec
, abfd
);
2673 if (i
!= info
&& i
!= abbrev
)
2674 free_debug_section ((enum dwarf_section_display_enum
) i
);
2680 /* Dump the dwarf debugging information. */
2683 dump_dwarf (bfd
*abfd
)
2687 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2689 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2691 if (bfd_big_endian (abfd
))
2692 byte_get
= byte_get_big_endian
;
2693 else if (bfd_little_endian (abfd
))
2694 byte_get
= byte_get_little_endian
;
2696 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2698 warn (_("File %s does not contain any dwarf debug information\n"),
2699 bfd_get_filename (abfd
));
2703 switch (bfd_get_arch (abfd
))
2706 switch (bfd_get_mach (abfd
))
2708 case bfd_mach_x86_64
:
2709 case bfd_mach_x86_64_intel_syntax
:
2710 case bfd_mach_x86_64_nacl
:
2711 case bfd_mach_x64_32
:
2712 case bfd_mach_x64_32_intel_syntax
:
2713 case bfd_mach_x64_32_nacl
:
2714 init_dwarf_regnames_x86_64 ();
2718 init_dwarf_regnames_i386 ();
2723 case bfd_arch_iamcu
:
2724 init_dwarf_regnames_iamcu ();
2727 case bfd_arch_aarch64
:
2728 init_dwarf_regnames_aarch64();
2732 init_dwarf_regnames_s390 ();
2735 case bfd_arch_riscv
:
2736 init_dwarf_regnames_riscv ();
2743 separates
= load_separate_debug_file (abfd
, bfd_get_filename (abfd
));
2745 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2748 bfd_map_over_sections (separates
, dump_dwarf_section
, NULL
);
2750 free_debug_memory ();
2753 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2754 it. Return NULL on failure. */
2757 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2762 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2763 if (stabsect
== NULL
)
2765 printf (_("No %s section present\n\n"), sect_name
);
2769 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2771 non_fatal (_("reading %s section of %s failed: %s"),
2772 sect_name
, bfd_get_filename (abfd
),
2773 bfd_errmsg (bfd_get_error ()));
2779 *size_ptr
= bfd_section_size (abfd
, stabsect
);
2784 /* Stabs entries use a 12 byte format:
2785 4 byte string table index
2787 1 byte stab other field
2788 2 byte stab desc field
2790 FIXME: This will have to change for a 64 bit object format. */
2792 #define STRDXOFF (0)
2794 #define OTHEROFF (5)
2797 #define STABSIZE (12)
2799 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2800 using string table section STRSECT_NAME (in `strtab'). */
2803 print_section_stabs (bfd
*abfd
,
2804 const char *stabsect_name
,
2805 unsigned *string_offset_ptr
)
2808 unsigned file_string_table_offset
= 0;
2809 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2810 bfd_byte
*stabp
, *stabs_end
;
2813 stabs_end
= stabp
+ stab_size
;
2815 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2816 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2818 /* Loop through all symbols and print them.
2820 We start the index at -1 because there is a dummy symbol on
2821 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2822 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2826 unsigned char type
, other
;
2827 unsigned short desc
;
2830 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2831 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2832 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2833 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2834 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2836 printf ("\n%-6d ", i
);
2837 /* Either print the stab name, or, if unnamed, print its number
2838 again (makes consistent formatting for tools like awk). */
2839 name
= bfd_get_stab_name (type
);
2841 printf ("%-6s", name
);
2842 else if (type
== N_UNDF
)
2845 printf ("%-6d", type
);
2846 printf (" %-6d %-6d ", other
, desc
);
2847 bfd_printf_vma (abfd
, value
);
2848 printf (" %-6lu", strx
);
2850 /* Symbols with type == 0 (N_UNDF) specify the length of the
2851 string table associated with this file. We use that info
2852 to know how to relocate the *next* file's string table indices. */
2855 file_string_table_offset
= next_file_string_table_offset
;
2856 next_file_string_table_offset
+= value
;
2860 bfd_size_type amt
= strx
+ file_string_table_offset
;
2862 /* Using the (possibly updated) string table offset, print the
2863 string (if any) associated with this symbol. */
2864 if (amt
< stabstr_size
)
2865 /* PR 17512: file: 079-79389-0.001:0.1. */
2866 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2872 *string_offset_ptr
= next_file_string_table_offset
;
2877 const char * section_name
;
2878 const char * string_section_name
;
2879 unsigned string_offset
;
2884 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2887 stab_section_names
* sought
= (stab_section_names
*) names
;
2889 /* Check for section names for which stabsect_name is a prefix, to
2890 handle .stab.N, etc. */
2891 len
= strlen (sought
->section_name
);
2893 /* If the prefix matches, and the files section name ends with a
2894 nul or a digit, then we match. I.e., we want either an exact
2895 match or a section followed by a number. */
2896 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2897 && (section
->name
[len
] == 0
2898 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2901 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2906 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
2908 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2914 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2916 stab_section_names s
;
2918 s
.section_name
= stabsect_name
;
2919 s
.string_section_name
= strsect_name
;
2920 s
.string_offset
= 0;
2922 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2928 /* Dump the any sections containing stabs debugging information. */
2931 dump_stabs (bfd
*abfd
)
2933 dump_stabs_section (abfd
, ".stab", ".stabstr");
2934 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2935 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2938 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2940 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2944 dump_bfd_header (bfd
*abfd
)
2948 printf (_("architecture: %s, "),
2949 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2950 bfd_get_mach (abfd
)));
2951 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2953 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2954 PF (HAS_RELOC
, "HAS_RELOC");
2955 PF (EXEC_P
, "EXEC_P");
2956 PF (HAS_LINENO
, "HAS_LINENO");
2957 PF (HAS_DEBUG
, "HAS_DEBUG");
2958 PF (HAS_SYMS
, "HAS_SYMS");
2959 PF (HAS_LOCALS
, "HAS_LOCALS");
2960 PF (DYNAMIC
, "DYNAMIC");
2961 PF (WP_TEXT
, "WP_TEXT");
2962 PF (D_PAGED
, "D_PAGED");
2963 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2964 printf (_("\nstart address 0x"));
2965 bfd_printf_vma (abfd
, abfd
->start_address
);
2971 dump_bfd_private_header (bfd
*abfd
)
2973 bfd_print_private_bfd_data (abfd
, stdout
);
2977 dump_target_specific (bfd
*abfd
)
2979 const struct objdump_private_desc
* const *desc
;
2980 struct objdump_private_option
*opt
;
2983 /* Find the desc. */
2984 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2985 if ((*desc
)->filter (abfd
))
2990 non_fatal (_("option -P/--private not supported by this file"));
2994 /* Clear all options. */
2995 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2996 opt
->selected
= FALSE
;
2998 /* Decode options. */
2999 b
= dump_private_options
;
3002 e
= strchr (b
, ',');
3007 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3008 if (strcmp (opt
->name
, b
) == 0)
3010 opt
->selected
= TRUE
;
3013 if (opt
->name
== NULL
)
3014 non_fatal (_("target specific dump '%s' not supported"), b
);
3025 (*desc
)->dump (abfd
);
3028 /* Display a section in hexadecimal format with associated characters.
3029 Each line prefixed by the zero padded address. */
3032 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3034 bfd_byte
*data
= NULL
;
3035 bfd_size_type datasize
;
3036 bfd_vma addr_offset
;
3037 bfd_vma start_offset
;
3038 bfd_vma stop_offset
;
3039 unsigned int opb
= bfd_octets_per_byte (abfd
);
3040 /* Bytes per line. */
3041 const int onaline
= 16;
3046 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3049 if (! process_section_p (section
))
3052 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3055 /* Compute the address range to display. */
3056 if (start_address
== (bfd_vma
) -1
3057 || start_address
< section
->vma
)
3060 start_offset
= start_address
- section
->vma
;
3062 if (stop_address
== (bfd_vma
) -1)
3063 stop_offset
= datasize
/ opb
;
3066 if (stop_address
< section
->vma
)
3069 stop_offset
= stop_address
- section
->vma
;
3071 if (stop_offset
> datasize
/ opb
)
3072 stop_offset
= datasize
/ opb
;
3075 if (start_offset
>= stop_offset
)
3078 printf (_("Contents of section %s:"), section
->name
);
3079 if (display_file_offsets
)
3080 printf (_(" (Starting at file offset: 0x%lx)"),
3081 (unsigned long) (section
->filepos
+ start_offset
));
3084 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3086 non_fatal (_("Reading section %s failed because: %s"),
3087 section
->name
, bfd_errmsg (bfd_get_error ()));
3093 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3094 if (strlen (buf
) >= sizeof (buf
))
3098 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3100 count
= strlen (buf
) - count
;
3104 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3105 if (strlen (buf
) >= sizeof (buf
))
3109 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3111 count
= strlen (buf
) - count
;
3115 for (addr_offset
= start_offset
;
3116 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3120 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3121 count
= strlen (buf
);
3122 if ((size_t) count
>= sizeof (buf
))
3126 while (count
< width
)
3131 fputs (buf
+ count
- width
, stdout
);
3134 for (j
= addr_offset
* opb
;
3135 j
< addr_offset
* opb
+ onaline
; j
++)
3137 if (j
< stop_offset
* opb
)
3138 printf ("%02x", (unsigned) (data
[j
]));
3146 for (j
= addr_offset
* opb
;
3147 j
< addr_offset
* opb
+ onaline
; j
++)
3149 if (j
>= stop_offset
* opb
)
3152 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3159 /* Actually display the various requested regions. */
3162 dump_data (bfd
*abfd
)
3164 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3167 /* Should perhaps share code and display with nm? */
3170 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3179 max_count
= dynsymcount
;
3180 printf ("DYNAMIC SYMBOL TABLE:\n");
3185 max_count
= symcount
;
3186 printf ("SYMBOL TABLE:\n");
3190 printf (_("no symbols\n"));
3192 for (count
= 0; count
< max_count
; count
++)
3196 if (*current
== NULL
)
3197 printf (_("no information for symbol number %ld\n"), count
);
3199 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3200 printf (_("could not determine the type of symbol number %ld\n"),
3203 else if (process_section_p ((* current
)->section
)
3204 && (dump_special_syms
3205 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3207 const char *name
= (*current
)->name
;
3209 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3213 /* If we want to demangle the name, we demangle it
3214 here, and temporarily clobber it while calling
3215 bfd_print_symbol. FIXME: This is a gross hack. */
3216 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3218 (*current
)->name
= alloc
;
3219 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3220 bfd_print_symbol_all
);
3223 (*current
)->name
= name
;
3228 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3229 bfd_print_symbol_all
);
3239 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3242 char *last_filename
, *last_functionname
;
3243 unsigned int last_line
;
3244 unsigned int last_discriminator
;
3246 /* Get column headers lined up reasonably. */
3254 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3255 width
= strlen (buf
) - 7;
3257 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3260 last_filename
= NULL
;
3261 last_functionname
= NULL
;
3263 last_discriminator
= 0;
3265 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3268 const char *filename
, *functionname
;
3269 unsigned int linenumber
;
3270 unsigned int discriminator
;
3271 const char *sym_name
;
3272 const char *section_name
;
3273 bfd_vma addend2
= 0;
3275 if (start_address
!= (bfd_vma
) -1
3276 && q
->address
< start_address
)
3278 if (stop_address
!= (bfd_vma
) -1
3279 && q
->address
> stop_address
)
3282 if (with_line_numbers
3284 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3285 &filename
, &functionname
,
3286 &linenumber
, &discriminator
))
3288 if (functionname
!= NULL
3289 && (last_functionname
== NULL
3290 || strcmp (functionname
, last_functionname
) != 0))
3292 printf ("%s():\n", functionname
);
3293 if (last_functionname
!= NULL
)
3294 free (last_functionname
);
3295 last_functionname
= xstrdup (functionname
);
3299 && (linenumber
!= last_line
3300 || (filename
!= NULL
3301 && last_filename
!= NULL
3302 && filename_cmp (filename
, last_filename
) != 0)
3303 || (discriminator
!= last_discriminator
)))
3305 if (discriminator
> 0)
3306 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3308 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3309 linenumber
, discriminator
);
3310 last_line
= linenumber
;
3311 last_discriminator
= discriminator
;
3312 if (last_filename
!= NULL
)
3313 free (last_filename
);
3314 if (filename
== NULL
)
3315 last_filename
= NULL
;
3317 last_filename
= xstrdup (filename
);
3321 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3323 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3324 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3329 section_name
= NULL
;
3332 bfd_printf_vma (abfd
, q
->address
);
3333 if (q
->howto
== NULL
)
3334 printf (" *unknown* ");
3335 else if (q
->howto
->name
)
3337 const char *name
= q
->howto
->name
;
3339 /* R_SPARC_OLO10 relocations contain two addends.
3340 But because 'arelent' lacks enough storage to
3341 store them both, the 64-bit ELF Sparc backend
3342 records this as two relocations. One R_SPARC_LO10
3343 and one R_SPARC_13, both pointing to the same
3344 address. This is merely so that we have some
3345 place to store both addend fields.
3347 Undo this transformation, otherwise the output
3348 will be confusing. */
3349 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3350 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3352 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3354 arelent
*q2
= *(p
+ 1);
3357 && q
->address
== q2
->address
3358 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3360 name
= "R_SPARC_OLO10";
3361 addend2
= q2
->addend
;
3365 printf (" %-16s ", name
);
3368 printf (" %-16d ", q
->howto
->type
);
3372 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3376 if (section_name
== NULL
)
3377 section_name
= "*unknown*";
3378 printf ("[%s]", section_name
);
3383 bfd_signed_vma addend
= q
->addend
;
3391 bfd_printf_vma (abfd
, addend
);
3396 bfd_printf_vma (abfd
, addend2
);
3402 if (last_filename
!= NULL
)
3403 free (last_filename
);
3404 if (last_functionname
!= NULL
)
3405 free (last_functionname
);
3409 dump_relocs_in_section (bfd
*abfd
,
3411 void *dummy ATTRIBUTE_UNUSED
)
3417 if ( bfd_is_abs_section (section
)
3418 || bfd_is_und_section (section
)
3419 || bfd_is_com_section (section
)
3420 || (! process_section_p (section
))
3421 || ((section
->flags
& SEC_RELOC
) == 0))
3424 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3426 bfd_fatal (bfd_get_filename (abfd
));
3428 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3432 printf (" (none)\n\n");
3436 if ((bfd_get_file_flags (abfd
) & (BFD_IN_MEMORY
| BFD_LINKER_CREATED
)) == 0
3437 && (((ufile_ptr
) relsize
> bfd_get_file_size (abfd
))
3438 /* Also check the section's reloc count since if this is negative
3439 (or very large) the computation in bfd_get_reloc_upper_bound
3440 may have resulted in returning a small, positive integer.
3441 See PR 22508 for a reproducer.
3443 Note - we check against file size rather than section size as
3444 it is possible for there to be more relocs that apply to a
3445 section than there are bytes in that section. */
3446 || (section
->reloc_count
> bfd_get_file_size (abfd
))))
3448 printf (" (too many: 0x%x)\n", section
->reloc_count
);
3449 bfd_set_error (bfd_error_file_truncated
);
3450 bfd_fatal (bfd_get_filename (abfd
));
3453 relpp
= (arelent
**) xmalloc (relsize
);
3454 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3459 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3460 bfd_fatal (_("error message was"));
3462 else if (relcount
== 0)
3463 printf (" (none)\n\n");
3467 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3474 dump_relocs (bfd
*abfd
)
3476 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3480 dump_dynamic_relocs (bfd
*abfd
)
3486 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3488 bfd_fatal (bfd_get_filename (abfd
));
3490 printf ("DYNAMIC RELOCATION RECORDS");
3493 printf (" (none)\n\n");
3496 relpp
= (arelent
**) xmalloc (relsize
);
3497 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3500 bfd_fatal (bfd_get_filename (abfd
));
3501 else if (relcount
== 0)
3502 printf (" (none)\n\n");
3506 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3513 /* Creates a table of paths, to search for source files. */
3516 add_include_path (const char *path
)
3520 include_path_count
++;
3521 include_paths
= (const char **)
3522 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3523 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3524 if (path
[1] == ':' && path
[2] == 0)
3525 path
= concat (path
, ".", (const char *) 0);
3527 include_paths
[include_path_count
- 1] = path
;
3531 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3535 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3537 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3538 section
->vma
+= adjust_section_vma
;
3540 section
->lma
+= adjust_section_vma
;
3544 /* Dump selected contents of ABFD. */
3547 dump_bfd (bfd
*abfd
)
3549 /* If we are adjusting section VMA's, change them all now. Changing
3550 the BFD information is a hack. However, we must do it, or
3551 bfd_find_nearest_line will not do the right thing. */
3552 if (adjust_section_vma
!= 0)
3554 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3555 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3558 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3559 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3562 print_arelt_descr (stdout
, abfd
, TRUE
);
3563 if (dump_file_header
)
3564 dump_bfd_header (abfd
);
3565 if (dump_private_headers
)
3566 dump_bfd_private_header (abfd
);
3567 if (dump_private_options
!= NULL
)
3568 dump_target_specific (abfd
);
3569 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3576 || dump_dwarf_section_info
)
3577 syms
= slurp_symtab (abfd
);
3579 if (dump_section_headers
)
3580 dump_headers (abfd
);
3582 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3583 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3584 dynsyms
= slurp_dynamic_symtab (abfd
);
3587 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3588 dynsymcount
, dynsyms
, &synthsyms
);
3594 dump_symbols (abfd
, FALSE
);
3595 if (dump_dynamic_symtab
)
3596 dump_symbols (abfd
, TRUE
);
3597 if (dump_dwarf_section_info
)
3599 if (dump_stab_section_info
)
3601 if (dump_reloc_info
&& ! disassemble
)
3603 if (dump_dynamic_reloc_info
&& ! disassemble
)
3604 dump_dynamic_relocs (abfd
);
3605 if (dump_section_contents
)
3608 disassemble_data (abfd
);
3614 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3615 if (dhandle
!= NULL
)
3617 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3619 dump_debugging_tags
? TRUE
: FALSE
))
3621 non_fatal (_("%s: printing debugging information failed"),
3622 bfd_get_filename (abfd
));
3626 /* PR 6483: If there was no STABS or IEEE debug
3627 info in the file, try DWARF instead. */
3628 else if (! dump_dwarf_section_info
)
3630 dwarf_select_sections_all ();
3659 display_object_bfd (bfd
*abfd
)
3663 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3669 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3671 nonfatal (bfd_get_filename (abfd
));
3672 list_matching_formats (matching
);
3677 if (bfd_get_error () != bfd_error_file_not_recognized
)
3679 nonfatal (bfd_get_filename (abfd
));
3683 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3689 nonfatal (bfd_get_filename (abfd
));
3691 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3693 list_matching_formats (matching
);
3699 display_any_bfd (bfd
*file
, int level
)
3701 /* Decompress sections unless dumping the section contents. */
3702 if (!dump_section_contents
)
3703 file
->flags
|= BFD_DECOMPRESS
;
3705 /* If the file is an archive, process all of its elements. */
3706 if (bfd_check_format (file
, bfd_archive
))
3709 bfd
*last_arfile
= NULL
;
3712 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3713 else if (level
> 100)
3715 /* Prevent corrupted files from spinning us into an
3716 infinite loop. 100 is an arbitrary heuristic. */
3717 fatal (_("Archive nesting is too deep"));
3721 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3725 bfd_set_error (bfd_error_no_error
);
3727 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3730 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3731 nonfatal (bfd_get_filename (file
));
3735 display_any_bfd (arfile
, level
+ 1);
3737 if (last_arfile
!= NULL
)
3739 bfd_close (last_arfile
);
3740 /* PR 17512: file: ac585d01. */
3741 if (arfile
== last_arfile
)
3747 last_arfile
= arfile
;
3750 if (last_arfile
!= NULL
)
3751 bfd_close (last_arfile
);
3754 display_object_bfd (file
);
3758 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3762 if (get_file_size (filename
) < 1)
3768 file
= bfd_openr (filename
, target
);
3771 nonfatal (filename
);
3775 display_any_bfd (file
, 0);
3777 /* This is an optimization to improve the speed of objdump, especially when
3778 dumping a file with lots of associated debug informatiom. Calling
3779 bfd_close on such a file can take a non-trivial amount of time as there
3780 are lots of lists to walk and buffers to free. This is only really
3781 necessary however if we are about to load another file and we need the
3782 memory back. Otherwise, if we are about to exit, then we can save (a lot
3783 of) time by only doing a quick close, and allowing the OS to reclaim the
3788 bfd_close_all_done (file
);
3792 main (int argc
, char **argv
)
3795 char *target
= default_target
;
3796 bfd_boolean seenflag
= FALSE
;
3798 #if defined (HAVE_SETLOCALE)
3799 #if defined (HAVE_LC_MESSAGES)
3800 setlocale (LC_MESSAGES
, "");
3802 setlocale (LC_CTYPE
, "");
3805 bindtextdomain (PACKAGE
, LOCALEDIR
);
3806 textdomain (PACKAGE
);
3808 program_name
= *argv
;
3809 xmalloc_set_program_name (program_name
);
3810 bfd_set_error_program_name (program_name
);
3812 START_PROGRESS (program_name
, 0);
3814 expandargv (&argc
, &argv
);
3817 set_default_bfd_target ();
3819 while ((c
= getopt_long (argc
, argv
,
3820 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3821 long_options
, (int *) 0))
3827 break; /* We've been given a long option. */
3834 if (disassembler_options
)
3835 /* Ignore potential memory leak for now. */
3836 options
= concat (disassembler_options
, ",",
3837 optarg
, (const char *) NULL
);
3840 disassembler_options
= remove_whitespace_and_extra_commas (options
);
3847 display_file_offsets
= TRUE
;
3850 with_line_numbers
= TRUE
;
3859 enum demangling_styles style
;
3861 style
= cplus_demangle_name_to_style (optarg
);
3862 if (style
== unknown_demangling
)
3863 fatal (_("unknown demangling style `%s'"),
3866 cplus_demangle_set_style (style
);
3870 do_wide
= wide_output
= TRUE
;
3872 case OPTION_ADJUST_VMA
:
3873 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3875 case OPTION_START_ADDRESS
:
3876 start_address
= parse_vma (optarg
, "--start-address");
3877 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3878 fatal (_("error: the start address should be before the end address"));
3880 case OPTION_STOP_ADDRESS
:
3881 stop_address
= parse_vma (optarg
, "--stop-address");
3882 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3883 fatal (_("error: the stop address should be after the start address"));
3887 prefix_length
= strlen (prefix
);
3888 /* Remove an unnecessary trailing '/' */
3889 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3892 case OPTION_PREFIX_STRIP
:
3893 prefix_strip
= atoi (optarg
);
3894 if (prefix_strip
< 0)
3895 fatal (_("error: prefix strip must be non-negative"));
3897 case OPTION_INSN_WIDTH
:
3898 insn_width
= strtoul (optarg
, NULL
, 0);
3899 if (insn_width
<= 0)
3900 fatal (_("error: instruction width must be positive"));
3902 case OPTION_INLINES
:
3903 unwind_inlines
= TRUE
;
3906 if (strcmp (optarg
, "B") == 0)
3907 endian
= BFD_ENDIAN_BIG
;
3908 else if (strcmp (optarg
, "L") == 0)
3909 endian
= BFD_ENDIAN_LITTLE
;
3912 nonfatal (_("unrecognized -E option"));
3917 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3918 endian
= BFD_ENDIAN_BIG
;
3919 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3920 endian
= BFD_ENDIAN_LITTLE
;
3923 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3930 dump_file_header
= TRUE
;
3934 formats_info
= TRUE
;
3938 add_include_path (optarg
);
3941 dump_private_headers
= TRUE
;
3945 dump_private_options
= optarg
;
3949 dump_private_headers
= TRUE
;
3951 dump_reloc_info
= TRUE
;
3952 dump_file_header
= TRUE
;
3953 dump_ar_hdrs
= TRUE
;
3954 dump_section_headers
= TRUE
;
3962 dump_dynamic_symtab
= TRUE
;
3970 disassemble_zeroes
= TRUE
;
3974 disassemble_all
= TRUE
;
3979 with_source_code
= TRUE
;
3988 dump_debugging_tags
= 1;
3993 dump_dwarf_section_info
= TRUE
;
3996 dwarf_select_sections_by_letters (optarg
);
3998 dwarf_select_sections_all ();
4001 dump_dwarf_section_info
= TRUE
;
4004 dwarf_select_sections_by_names (optarg
);
4006 dwarf_select_sections_all ();
4008 case OPTION_DWARF_DEPTH
:
4011 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4014 case OPTION_DWARF_START
:
4017 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4018 suppress_bfd_header
= 1;
4021 case OPTION_DWARF_CHECK
:
4025 dump_stab_section_info
= TRUE
;
4029 dump_section_contents
= TRUE
;
4033 dump_reloc_info
= TRUE
;
4037 dump_dynamic_reloc_info
= TRUE
;
4041 dump_ar_hdrs
= TRUE
;
4045 dump_section_headers
= TRUE
;
4050 show_version
= TRUE
;
4056 /* No need to set seenflag or to break - usage() does not return. */
4063 print_version ("objdump");
4069 exit_status
= display_info ();
4073 display_file ("a.out", target
, TRUE
);
4075 for (; optind
< argc
;)
4077 display_file (argv
[optind
], target
, optind
== argc
- 1);
4084 END_PROGRESS (program_name
);