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 strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
670 /* Filter out (in place) symbols that are useless for disassembly.
671 COUNT is the number of elements in SYMBOLS.
672 Return the number of useful symbols. */
675 remove_useless_symbols (asymbol
**symbols
, long count
)
677 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
681 asymbol
*sym
= *in_ptr
++;
683 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
685 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
686 && ! is_significant_symbol_name (sym
->name
))
688 if (bfd_is_und_section (sym
->section
)
689 || bfd_is_com_section (sym
->section
))
694 return out_ptr
- symbols
;
697 /* Sort symbols into value order. */
700 compare_symbols (const void *ap
, const void *bp
)
702 const asymbol
*a
= * (const asymbol
**) ap
;
703 const asymbol
*b
= * (const asymbol
**) bp
;
713 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
715 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
718 if (a
->section
> b
->section
)
720 else if (a
->section
< b
->section
)
723 an
= bfd_asymbol_name (a
);
724 bn
= bfd_asymbol_name (b
);
728 /* The symbols gnu_compiled and gcc2_compiled convey no real
729 information, so put them after other symbols with the same value. */
730 af
= (strstr (an
, "gnu_compiled") != NULL
731 || strstr (an
, "gcc2_compiled") != NULL
);
732 bf
= (strstr (bn
, "gnu_compiled") != NULL
733 || strstr (bn
, "gcc2_compiled") != NULL
);
740 /* We use a heuristic for the file name, to try to sort it after
741 more useful symbols. It may not work on non Unix systems, but it
742 doesn't really matter; the only difference is precisely which
743 symbol names get printed. */
745 #define file_symbol(s, sn, snl) \
746 (((s)->flags & BSF_FILE) != 0 \
747 || ((sn)[(snl) - 2] == '.' \
748 && ((sn)[(snl) - 1] == 'o' \
749 || (sn)[(snl) - 1] == 'a')))
751 af
= file_symbol (a
, an
, anl
);
752 bf
= file_symbol (b
, bn
, bnl
);
759 /* Try to sort global symbols before local symbols before function
760 symbols before debugging symbols. */
765 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
767 if ((aflags
& BSF_DEBUGGING
) != 0)
772 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
774 if ((aflags
& BSF_FUNCTION
) != 0)
779 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
781 if ((aflags
& BSF_LOCAL
) != 0)
786 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
788 if ((aflags
& BSF_GLOBAL
) != 0)
794 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
795 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
800 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
801 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
803 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
804 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
806 return asz
> bsz
? -1 : 1;
809 /* Symbols that start with '.' might be section names, so sort them
810 after symbols that don't start with '.'. */
811 if (an
[0] == '.' && bn
[0] != '.')
813 if (an
[0] != '.' && bn
[0] == '.')
816 /* Finally, if we can't distinguish them in any other way, try to
817 get consistent results by sorting the symbols by name. */
818 return strcmp (an
, bn
);
821 /* Sort relocs into address order. */
824 compare_relocs (const void *ap
, const void *bp
)
826 const arelent
*a
= * (const arelent
**) ap
;
827 const arelent
*b
= * (const arelent
**) bp
;
829 if (a
->address
> b
->address
)
831 else if (a
->address
< b
->address
)
834 /* So that associated relocations tied to the same address show up
835 in the correct order, we don't do any further sorting. */
844 /* Print an address (VMA) to the output stream in INFO.
845 If SKIP_ZEROES is TRUE, omit leading zeroes. */
848 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
849 bfd_boolean skip_zeroes
)
853 struct objdump_disasm_info
*aux
;
855 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
856 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
861 for (p
= buf
; *p
== '0'; ++p
)
866 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
869 /* Print the name of a symbol. */
872 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
876 const char *name
, *version_string
= NULL
;
877 bfd_boolean hidden
= FALSE
;
880 name
= bfd_asymbol_name (sym
);
881 if (do_demangle
&& name
[0] != '\0')
883 /* Demangle the name. */
884 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
889 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
890 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
892 if (bfd_is_und_section (bfd_get_section (sym
)))
897 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
898 if (version_string
&& *version_string
!= '\0')
899 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
905 if (version_string
&& *version_string
!= '\0')
906 printf (hidden
? "@%s" : "@@%s", version_string
);
913 /* Locate a symbol given a bfd and a section (from INFO->application_data),
914 and a VMA. If INFO->application_data->require_sec is TRUE, then always
915 require the symbol to be in the section. Returns NULL if there is no
916 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
917 of the symbol in sorted_syms. */
920 find_symbol_for_address (bfd_vma vma
,
921 struct disassemble_info
*inf
,
924 /* @@ Would it speed things up to cache the last two symbols returned,
925 and maybe their address ranges? For many processors, only one memory
926 operand can be present at a time, so the 2-entry cache wouldn't be
927 constantly churned by code doing heavy memory accesses. */
929 /* Indices in `sorted_syms'. */
931 long max_count
= sorted_symcount
;
933 struct objdump_disasm_info
*aux
;
937 bfd_boolean want_section
;
940 if (sorted_symcount
< 1)
943 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
946 opb
= inf
->octets_per_byte
;
948 /* Perform a binary search looking for the closest symbol to the
949 required value. We are searching the range (min, max_count]. */
950 while (min
+ 1 < max_count
)
954 thisplace
= (max_count
+ min
) / 2;
955 sym
= sorted_syms
[thisplace
];
957 if (bfd_asymbol_value (sym
) > vma
)
958 max_count
= thisplace
;
959 else if (bfd_asymbol_value (sym
) < vma
)
968 /* The symbol we want is now in min, the low end of the range we
969 were searching. If there are several symbols with the same
970 value, we want the first (non-section/non-debugging) one. */
973 && (bfd_asymbol_value (sorted_syms
[thisplace
])
974 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
975 && ((sorted_syms
[thisplace
- 1]->flags
976 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
980 /* Prefer a symbol in the current section if we have multple symbols
981 with the same value, as can occur with overlays or zero size
984 while (min
< max_count
985 && (bfd_asymbol_value (sorted_syms
[min
])
986 == bfd_asymbol_value (sorted_syms
[thisplace
])))
988 if (sorted_syms
[min
]->section
== sec
989 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
996 return sorted_syms
[thisplace
];
1001 /* If the file is relocatable, and the symbol could be from this
1002 section, prefer a symbol from this section over symbols from
1003 others, even if the other symbol's value might be closer.
1005 Note that this may be wrong for some symbol references if the
1006 sections have overlapping memory ranges, but in that case there's
1007 no way to tell what's desired without looking at the relocation
1010 Also give the target a chance to reject symbols. */
1011 want_section
= (aux
->require_sec
1012 || ((abfd
->flags
& HAS_RELOC
) != 0
1013 && vma
>= bfd_get_section_vma (abfd
, sec
)
1014 && vma
< (bfd_get_section_vma (abfd
, sec
)
1015 + bfd_section_size (abfd
, sec
) / opb
)));
1016 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1017 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1020 long newplace
= sorted_symcount
;
1022 for (i
= min
- 1; i
>= 0; i
--)
1024 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1025 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1027 if (newplace
== sorted_symcount
)
1030 if (bfd_asymbol_value (sorted_syms
[i
])
1031 != bfd_asymbol_value (sorted_syms
[newplace
]))
1034 /* Remember this symbol and keep searching until we reach
1035 an earlier address. */
1040 if (newplace
!= sorted_symcount
)
1041 thisplace
= newplace
;
1044 /* We didn't find a good symbol with a smaller value.
1045 Look for one with a larger value. */
1046 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1048 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1049 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1057 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1058 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1059 /* There is no suitable symbol. */
1063 /* If we have not found an exact match for the specified address
1064 and we have dynamic relocations available, then we can produce
1065 a better result by matching a relocation to the address and
1066 using the symbol associated with that relocation. */
1067 rel_count
= aux
->dynrelcount
;
1069 && sorted_syms
[thisplace
]->value
!= vma
1071 && aux
->dynrelbuf
!= NULL
1072 && aux
->dynrelbuf
[0]->address
<= vma
1073 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1074 /* If we have matched a synthetic symbol, then stick with that. */
1075 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1078 arelent
** rel_high
;
1080 rel_low
= aux
->dynrelbuf
;
1081 rel_high
= rel_low
+ rel_count
- 1;
1082 while (rel_low
<= rel_high
)
1084 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1085 arelent
* rel
= *rel_mid
;
1087 if (rel
->address
== vma
)
1089 /* Absolute relocations do not provide a more helpful
1090 symbolic address. Find a non-absolute relocation
1091 with the same address. */
1092 arelent
**rel_vma
= rel_mid
;
1094 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1098 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1102 if (rel
->sym_ptr_ptr
!= NULL
1103 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1106 * place
= thisplace
;
1107 return * rel
->sym_ptr_ptr
;
1113 if (vma
< rel
->address
)
1115 else if (vma
>= rel_mid
[1]->address
)
1116 rel_low
= rel_mid
+ 1;
1125 return sorted_syms
[thisplace
];
1128 /* Print an address and the offset to the nearest symbol. */
1131 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1132 bfd_vma vma
, struct disassemble_info
*inf
,
1133 bfd_boolean skip_zeroes
)
1135 objdump_print_value (vma
, inf
, skip_zeroes
);
1141 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1142 bfd_get_section_name (abfd
, sec
));
1143 secaddr
= bfd_get_section_vma (abfd
, sec
);
1146 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1147 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1149 else if (vma
> secaddr
)
1151 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1152 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1154 (*inf
->fprintf_func
) (inf
->stream
, ">");
1158 (*inf
->fprintf_func
) (inf
->stream
, " <");
1160 objdump_print_symname (abfd
, inf
, sym
);
1162 if (bfd_asymbol_value (sym
) == vma
)
1164 /* Undefined symbols in an executables and dynamic objects do not have
1165 a value associated with them, so it does not make sense to display
1166 an offset relative to them. Normally we would not be provided with
1167 this kind of symbol, but the target backend might choose to do so,
1168 and the code in find_symbol_for_address might return an as yet
1169 unresolved symbol associated with a dynamic reloc. */
1170 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1171 && bfd_is_und_section (sym
->section
))
1173 else if (bfd_asymbol_value (sym
) > vma
)
1175 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1176 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1178 else if (vma
> bfd_asymbol_value (sym
))
1180 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1181 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1184 (*inf
->fprintf_func
) (inf
->stream
, ">");
1187 if (display_file_offsets
)
1188 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1189 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1192 /* Print an address (VMA), symbolically if possible.
1193 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1196 objdump_print_addr (bfd_vma vma
,
1197 struct disassemble_info
*inf
,
1198 bfd_boolean skip_zeroes
)
1200 struct objdump_disasm_info
*aux
;
1201 asymbol
*sym
= NULL
;
1202 bfd_boolean skip_find
= FALSE
;
1204 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1206 if (sorted_symcount
< 1)
1208 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1209 objdump_print_value (vma
, inf
, skip_zeroes
);
1211 if (display_file_offsets
)
1212 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1213 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1217 if (aux
->reloc
!= NULL
1218 && aux
->reloc
->sym_ptr_ptr
!= NULL
1219 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1221 sym
= * aux
->reloc
->sym_ptr_ptr
;
1223 /* Adjust the vma to the reloc. */
1224 vma
+= bfd_asymbol_value (sym
);
1226 if (bfd_is_und_section (bfd_get_section (sym
)))
1231 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1233 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1237 /* Print VMA to INFO. This function is passed to the disassembler
1241 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1243 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1246 /* Determine if the given address has a symbol associated with it. */
1249 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1253 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1255 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1258 /* Hold the last function name and the last line number we displayed
1259 in a disassembly. */
1261 static char *prev_functionname
;
1262 static unsigned int prev_line
;
1263 static unsigned int prev_discriminator
;
1265 /* We keep a list of all files that we have seen when doing a
1266 disassembly with source, so that we know how much of the file to
1267 display. This can be important for inlined functions. */
1269 struct print_file_list
1271 struct print_file_list
*next
;
1272 const char *filename
;
1273 const char *modname
;
1276 const char **linemap
;
1279 unsigned max_printed
;
1283 static struct print_file_list
*print_files
;
1285 /* The number of preceding context lines to show when we start
1286 displaying a file for the first time. */
1288 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1290 /* Read a complete file into memory. */
1293 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1296 int ps
= getpagesize ();
1300 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1304 if (fstat (fd
, fst
) < 0)
1309 *size
= fst
->st_size
;
1311 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1312 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1313 if (map
!= (char *) -1L)
1319 map
= (const char *) malloc (*size
);
1320 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1322 free ((void *) map
);
1329 #define line_map_decrease 5
1331 /* Precompute array of lines for a mapped file. */
1333 static const char **
1334 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1336 const char *p
, *lstart
, *end
;
1337 int chars_per_line
= 45; /* First iteration will use 40. */
1338 unsigned int lineno
;
1339 const char **linemap
= NULL
;
1340 unsigned long line_map_size
= 0;
1346 for (p
= map
; p
< end
; p
++)
1350 if (p
+ 1 < end
&& p
[1] == '\r')
1353 else if (*p
== '\r')
1355 if (p
+ 1 < end
&& p
[1] == '\n')
1361 /* End of line found. */
1363 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1365 unsigned long newsize
;
1367 chars_per_line
-= line_map_decrease
;
1368 if (chars_per_line
<= 1)
1370 line_map_size
= size
/ chars_per_line
+ 1;
1371 if (line_map_size
< lineno
+ 1)
1372 line_map_size
= lineno
+ 1;
1373 newsize
= line_map_size
* sizeof (char *);
1374 linemap
= (const char **) xrealloc (linemap
, newsize
);
1377 linemap
[lineno
++] = lstart
;
1385 /* Tries to open MODNAME, and if successful adds a node to print_files
1386 linked list and returns that node. Returns NULL on failure. */
1388 static struct print_file_list
*
1389 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1391 struct print_file_list
*p
;
1393 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1395 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1402 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1405 p
->filename
= origname
;
1406 p
->modname
= modname
;
1407 p
->next
= print_files
;
1413 /* If the source file, as described in the symtab, is not found
1414 try to locate it in one of the paths specified with -I
1415 If found, add location to print_files linked list. */
1417 static struct print_file_list
*
1418 update_source_path (const char *filename
, bfd
*abfd
)
1420 struct print_file_list
*p
;
1425 p
= try_print_file_open (filename
, filename
, &fst
);
1428 if (include_path_count
== 0)
1431 /* Get the name of the file. */
1432 fname
= lbasename (filename
);
1434 /* If file exists under a new path, we need to add it to the list
1435 so that show_line knows about it. */
1436 for (i
= 0; i
< include_path_count
; i
++)
1438 char *modname
= concat (include_paths
[i
], "/", fname
,
1441 p
= try_print_file_open (filename
, modname
, &fst
);
1451 long mtime
= bfd_get_mtime (abfd
);
1453 if (fst
.st_mtime
> mtime
)
1454 warn (_("source file %s is more recent than object file\n"),
1461 /* Print a source file line. */
1464 print_line (struct print_file_list
*p
, unsigned int linenum
)
1470 if (linenum
>= p
->maxline
)
1472 l
= p
->linemap
[linenum
];
1473 /* Test fwrite return value to quiet glibc warning. */
1474 len
= strcspn (l
, "\n\r");
1475 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1479 /* Print a range of source code lines. */
1482 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1486 while (start
<= end
)
1488 print_line (p
, start
);
1493 /* Show the line number, or the source line, in a disassembly
1497 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1499 const char *filename
;
1500 const char *functionname
;
1501 unsigned int linenumber
;
1502 unsigned int discriminator
;
1506 if (! with_line_numbers
&& ! with_source_code
)
1509 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1510 &filename
, &functionname
,
1511 &linenumber
, &discriminator
))
1514 if (filename
!= NULL
&& *filename
== '\0')
1516 if (functionname
!= NULL
&& *functionname
== '\0')
1517 functionname
= NULL
;
1520 && IS_ABSOLUTE_PATH (filename
)
1524 const char *fname
= filename
;
1526 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1529 memcpy (path
, prefix
, prefix_length
);
1530 path_up
= path
+ prefix_length
;
1532 /* Build relocated filename, stripping off leading directories
1533 from the initial filename if requested. */
1534 if (prefix_strip
> 0)
1539 /* Skip selected directory levels. */
1540 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1541 if (IS_DIR_SEPARATOR(*s
))
1548 /* Update complete filename. */
1549 strncpy (path_up
, fname
, PATH_MAX
);
1550 path_up
[PATH_MAX
] = '\0';
1558 if (with_line_numbers
)
1560 if (functionname
!= NULL
1561 && (prev_functionname
== NULL
1562 || strcmp (functionname
, prev_functionname
) != 0))
1564 printf ("%s():\n", functionname
);
1568 && (linenumber
!= prev_line
1569 || discriminator
!= prev_discriminator
))
1571 if (discriminator
> 0)
1572 printf ("%s:%u (discriminator %u)\n",
1573 filename
== NULL
? "???" : filename
,
1574 linenumber
, discriminator
);
1576 printf ("%s:%u\n", filename
== NULL
? "???" : filename
,
1581 const char *filename2
;
1582 const char *functionname2
;
1585 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1587 printf ("inlined by %s:%u (%s)\n", filename2
, line2
,
1592 if (with_source_code
1596 struct print_file_list
**pp
, *p
;
1599 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1600 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1607 filename
= xstrdup (filename
);
1608 p
= update_source_path (filename
, abfd
);
1611 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1613 if (file_start_context
&& p
->first
)
1617 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1618 if (l
>= linenumber
)
1620 if (p
->max_printed
>= l
)
1622 if (p
->max_printed
< linenumber
)
1623 l
= p
->max_printed
+ 1;
1628 dump_lines (p
, l
, linenumber
);
1629 if (p
->max_printed
< linenumber
)
1630 p
->max_printed
= linenumber
;
1631 p
->last_line
= linenumber
;
1636 if (functionname
!= NULL
1637 && (prev_functionname
== NULL
1638 || strcmp (functionname
, prev_functionname
) != 0))
1640 if (prev_functionname
!= NULL
)
1641 free (prev_functionname
);
1642 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1643 strcpy (prev_functionname
, functionname
);
1646 if (linenumber
> 0 && linenumber
!= prev_line
)
1647 prev_line
= linenumber
;
1649 if (discriminator
!= prev_discriminator
)
1650 prev_discriminator
= discriminator
;
1656 /* Pseudo FILE object for strings. */
1664 /* sprintf to a "stream". */
1666 static int ATTRIBUTE_PRINTF_2
1667 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1674 size_t space
= f
->alloc
- f
->pos
;
1676 va_start (args
, format
);
1677 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1683 f
->alloc
= (f
->alloc
+ n
) * 2;
1684 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1691 /* The number of zeroes we want to see before we start skipping them.
1692 The number is arbitrarily chosen. */
1694 #define DEFAULT_SKIP_ZEROES 8
1696 /* The number of zeroes to skip at the end of a section. If the
1697 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1698 SKIP_ZEROES, they will be disassembled. If there are fewer than
1699 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1700 attempt to avoid disassembling zeroes inserted by section
1703 #define DEFAULT_SKIP_ZEROES_AT_END 3
1705 /* Disassemble some data in memory between given values. */
1708 disassemble_bytes (struct disassemble_info
* inf
,
1709 disassembler_ftype disassemble_fn
,
1712 bfd_vma start_offset
,
1713 bfd_vma stop_offset
,
1716 arelent
** relppend
)
1718 struct objdump_disasm_info
*aux
;
1720 int octets_per_line
;
1721 int skip_addr_chars
;
1722 bfd_vma addr_offset
;
1723 unsigned int opb
= inf
->octets_per_byte
;
1724 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1725 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1729 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1733 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1737 octets_per_line
= insn_width
;
1739 octets_per_line
= 4;
1741 octets_per_line
= 16;
1743 /* Figure out how many characters to skip at the start of an
1744 address, to make the disassembly look nicer. We discard leading
1745 zeroes in chunks of 4, ensuring that there is always a leading
1747 skip_addr_chars
= 0;
1748 if (! prefix_addresses
)
1752 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1754 while (buf
[skip_addr_chars
] == '0')
1757 /* Don't discard zeros on overflow. */
1758 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1759 skip_addr_chars
= 0;
1761 if (skip_addr_chars
!= 0)
1762 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1765 inf
->insn_info_valid
= 0;
1767 addr_offset
= start_offset
;
1768 while (addr_offset
< stop_offset
)
1771 bfd_boolean need_nl
= FALSE
;
1772 int previous_octets
;
1774 /* Remember the length of the previous instruction. */
1775 previous_octets
= octets
;
1778 /* Make sure we don't use relocs from previous instructions. */
1781 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1783 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1786 if (! disassemble_zeroes
1787 && (inf
->insn_info_valid
== 0
1788 || inf
->branch_delay_insns
== 0)
1789 && (z
- addr_offset
* opb
>= skip_zeroes
1790 || (z
== stop_offset
* opb
&&
1791 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1793 /* If there are more nonzero octets to follow, we only skip
1794 zeroes in multiples of 4, to try to avoid running over
1795 the start of an instruction which happens to start with
1797 if (z
!= stop_offset
* opb
)
1798 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1800 octets
= z
- addr_offset
* opb
;
1802 /* If we are going to display more data, and we are displaying
1803 file offsets, then tell the user how many zeroes we skip
1804 and the file offset from where we resume dumping. */
1805 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1806 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1808 (unsigned long) (section
->filepos
1809 + (addr_offset
+ (octets
/ opb
))));
1819 if (with_line_numbers
|| with_source_code
)
1820 show_line (aux
->abfd
, section
, addr_offset
);
1822 if (! prefix_addresses
)
1826 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1827 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1831 printf ("%s:\t", buf
+ skip_addr_chars
);
1835 aux
->require_sec
= TRUE
;
1836 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1837 aux
->require_sec
= FALSE
;
1844 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1845 inf
->stream
= &sfile
;
1846 inf
->bytes_per_line
= 0;
1847 inf
->bytes_per_chunk
= 0;
1848 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1850 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1852 if (inf
->disassembler_needs_relocs
1853 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1854 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1855 && *relppp
< relppend
)
1857 bfd_signed_vma distance_to_rel
;
1859 distance_to_rel
= (**relppp
)->address
1860 - (rel_offset
+ addr_offset
);
1862 /* Check to see if the current reloc is associated with
1863 the instruction that we are about to disassemble. */
1864 if (distance_to_rel
== 0
1865 /* FIXME: This is wrong. We are trying to catch
1866 relocs that are addressed part way through the
1867 current instruction, as might happen with a packed
1868 VLIW instruction. Unfortunately we do not know the
1869 length of the current instruction since we have not
1870 disassembled it yet. Instead we take a guess based
1871 upon the length of the previous instruction. The
1872 proper solution is to have a new target-specific
1873 disassembler function which just returns the length
1874 of an instruction at a given address without trying
1875 to display its disassembly. */
1876 || (distance_to_rel
> 0
1877 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1879 inf
->flags
|= INSN_HAS_RELOC
;
1880 aux
->reloc
= **relppp
;
1884 if (! disassemble_all
1885 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1886 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1887 /* Set a stop_vma so that the disassembler will not read
1888 beyond the next symbol. We assume that symbols appear on
1889 the boundaries between instructions. We only do this when
1890 disassembling code of course, and when -D is in effect. */
1891 inf
->stop_vma
= section
->vma
+ stop_offset
;
1893 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1896 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1897 inf
->stream
= stdout
;
1898 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1899 octets_per_line
= inf
->bytes_per_line
;
1900 if (octets
< (int) opb
)
1903 printf ("%s\n", sfile
.buffer
);
1906 non_fatal (_("disassemble_fn returned length %d"),
1917 octets
= octets_per_line
;
1918 if (addr_offset
+ octets
/ opb
> stop_offset
)
1919 octets
= (stop_offset
- addr_offset
) * opb
;
1921 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1923 if (ISPRINT (data
[j
]))
1924 buf
[j
- addr_offset
* opb
] = data
[j
];
1926 buf
[j
- addr_offset
* opb
] = '.';
1928 buf
[j
- addr_offset
* opb
] = '\0';
1931 if (prefix_addresses
1933 : show_raw_insn
>= 0)
1937 /* If ! prefix_addresses and ! wide_output, we print
1938 octets_per_line octets per line. */
1940 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1941 pb
= octets_per_line
;
1943 if (inf
->bytes_per_chunk
)
1944 bpc
= inf
->bytes_per_chunk
;
1948 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1950 /* PR 21580: Check for a buffer ending early. */
1951 if (j
+ bpc
<= stop_offset
* opb
)
1955 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1957 for (k
= bpc
- 1; k
>= 0; k
--)
1958 printf ("%02x", (unsigned) data
[j
+ k
]);
1962 for (k
= 0; k
< bpc
; k
++)
1963 printf ("%02x", (unsigned) data
[j
+ k
]);
1969 for (; pb
< octets_per_line
; pb
+= bpc
)
1973 for (k
= 0; k
< bpc
; k
++)
1978 /* Separate raw data from instruction by extra space. */
1988 printf ("%s", sfile
.buffer
);
1990 if (prefix_addresses
1992 : show_raw_insn
>= 0)
2000 j
= addr_offset
* opb
+ pb
;
2002 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2003 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2007 printf ("%s:\t", buf
+ skip_addr_chars
);
2009 pb
+= octets_per_line
;
2012 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2014 /* PR 21619: Check for a buffer ending early. */
2015 if (j
+ bpc
<= stop_offset
* opb
)
2019 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2021 for (k
= bpc
- 1; k
>= 0; k
--)
2022 printf ("%02x", (unsigned) data
[j
+ k
]);
2026 for (k
= 0; k
< bpc
; k
++)
2027 printf ("%02x", (unsigned) data
[j
+ k
]);
2041 while ((*relppp
) < relppend
2042 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2044 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2055 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2058 if (q
->howto
== NULL
)
2059 printf (": *unknown*\t");
2060 else if (q
->howto
->name
)
2061 printf (": %s\t", q
->howto
->name
);
2063 printf (": %d\t", q
->howto
->type
);
2065 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2066 printf ("*unknown*");
2069 const char *sym_name
;
2071 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2072 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2073 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2078 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2079 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2080 if (sym_name
== NULL
|| *sym_name
== '\0')
2081 sym_name
= "*unknown*";
2082 printf ("%s", sym_name
);
2088 bfd_signed_vma addend
= q
->addend
;
2096 objdump_print_value (addend
, inf
, TRUE
);
2108 addr_offset
+= octets
/ opb
;
2111 free (sfile
.buffer
);
2115 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2117 const struct elf_backend_data
* bed
;
2118 bfd_vma sign_adjust
= 0;
2119 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2120 struct objdump_disasm_info
* paux
;
2121 unsigned int opb
= pinfo
->octets_per_byte
;
2122 bfd_byte
* data
= NULL
;
2123 bfd_size_type datasize
= 0;
2124 arelent
** rel_pp
= NULL
;
2125 arelent
** rel_ppstart
= NULL
;
2126 arelent
** rel_ppend
;
2127 bfd_vma stop_offset
;
2128 asymbol
* sym
= NULL
;
2132 unsigned long addr_offset
;
2134 /* Sections that do not contain machine
2135 code are not normally disassembled. */
2136 if (! disassemble_all
2137 && only_list
== NULL
2138 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2139 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2142 if (! process_section_p (section
))
2145 datasize
= bfd_get_section_size (section
);
2149 if (start_address
== (bfd_vma
) -1
2150 || start_address
< section
->vma
)
2153 addr_offset
= start_address
- section
->vma
;
2155 if (stop_address
== (bfd_vma
) -1)
2156 stop_offset
= datasize
/ opb
;
2159 if (stop_address
< section
->vma
)
2162 stop_offset
= stop_address
- section
->vma
;
2163 if (stop_offset
> datasize
/ opb
)
2164 stop_offset
= datasize
/ opb
;
2167 if (addr_offset
>= stop_offset
)
2170 /* Decide which set of relocs to use. Load them if necessary. */
2171 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2172 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2174 rel_pp
= paux
->dynrelbuf
;
2175 rel_count
= paux
->dynrelcount
;
2176 /* Dynamic reloc addresses are absolute, non-dynamic are section
2177 relative. REL_OFFSET specifies the reloc address corresponding
2178 to the start of this section. */
2179 rel_offset
= section
->vma
;
2187 if ((section
->flags
& SEC_RELOC
) != 0
2188 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2192 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2194 bfd_fatal (bfd_get_filename (abfd
));
2198 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2199 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2201 bfd_fatal (bfd_get_filename (abfd
));
2203 /* Sort the relocs by address. */
2204 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2208 rel_ppend
= rel_pp
+ rel_count
;
2210 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2212 non_fatal (_("Reading section %s failed because: %s"),
2213 section
->name
, bfd_errmsg (bfd_get_error ()));
2217 paux
->sec
= section
;
2218 pinfo
->buffer
= data
;
2219 pinfo
->buffer_vma
= section
->vma
;
2220 pinfo
->buffer_length
= datasize
;
2221 pinfo
->section
= section
;
2223 /* Skip over the relocs belonging to addresses below the
2225 while (rel_pp
< rel_ppend
2226 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2229 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2231 /* Find the nearest symbol forwards from our current position. */
2232 paux
->require_sec
= TRUE
;
2233 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2234 (struct disassemble_info
*) inf
,
2236 paux
->require_sec
= FALSE
;
2238 /* PR 9774: If the target used signed addresses then we must make
2239 sure that we sign extend the value that we calculate for 'addr'
2240 in the loop below. */
2241 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2242 && (bed
= get_elf_backend_data (abfd
)) != NULL
2243 && bed
->sign_extend_vma
)
2244 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2246 /* Disassemble a block of instructions up to the address associated with
2247 the symbol we have just found. Then print the symbol and find the
2248 next symbol on. Repeat until we have disassembled the entire section
2249 or we have reached the end of the address range we are interested in. */
2250 while (addr_offset
< stop_offset
)
2254 bfd_vma nextstop_offset
;
2257 addr
= section
->vma
+ addr_offset
;
2258 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2260 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2265 (x
< sorted_symcount
2266 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2270 pinfo
->symbols
= sorted_syms
+ place
;
2271 pinfo
->num_symbols
= x
- place
;
2272 pinfo
->symtab_pos
= place
;
2276 pinfo
->symbols
= NULL
;
2277 pinfo
->num_symbols
= 0;
2278 pinfo
->symtab_pos
= -1;
2281 if (! prefix_addresses
)
2283 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2284 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2286 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2289 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2291 else if (sym
== NULL
)
2295 #define is_valid_next_sym(SYM) \
2296 ((SYM)->section == section \
2297 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2298 && pinfo->symbol_is_valid (SYM, pinfo))
2300 /* Search forward for the next appropriate symbol in
2301 SECTION. Note that all the symbols are sorted
2302 together into one big array, and that some sections
2303 may have overlapping addresses. */
2304 while (place
< sorted_symcount
2305 && ! is_valid_next_sym (sorted_syms
[place
]))
2308 if (place
>= sorted_symcount
)
2311 nextsym
= sorted_syms
[place
];
2314 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2315 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2316 else if (nextsym
== NULL
)
2317 nextstop_offset
= stop_offset
;
2319 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2321 if (nextstop_offset
> stop_offset
2322 || nextstop_offset
<= addr_offset
)
2323 nextstop_offset
= stop_offset
;
2325 /* If a symbol is explicitly marked as being an object
2326 rather than a function, just dump the bytes without
2327 disassembling them. */
2330 || sym
->section
!= section
2331 || bfd_asymbol_value (sym
) > addr
2332 || ((sym
->flags
& BSF_OBJECT
) == 0
2333 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2335 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2337 || (sym
->flags
& BSF_FUNCTION
) != 0)
2342 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2343 addr_offset
, nextstop_offset
,
2344 rel_offset
, &rel_pp
, rel_ppend
);
2346 addr_offset
= nextstop_offset
;
2352 if (rel_ppstart
!= NULL
)
2356 /* Disassemble the contents of an object file. */
2359 disassemble_data (bfd
*abfd
)
2361 struct disassemble_info disasm_info
;
2362 struct objdump_disasm_info aux
;
2366 prev_functionname
= NULL
;
2368 prev_discriminator
= 0;
2370 /* We make a copy of syms to sort. We don't want to sort syms
2371 because that will screw up the relocs. */
2372 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2373 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2374 * sizeof (asymbol
*));
2375 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2376 sorted_symcount
* sizeof (asymbol
*));
2378 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2380 for (i
= 0; i
< synthcount
; ++i
)
2382 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2386 /* Sort the symbols into section and symbol order. */
2387 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2389 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2391 disasm_info
.application_data
= (void *) &aux
;
2393 aux
.require_sec
= FALSE
;
2394 aux
.dynrelbuf
= NULL
;
2395 aux
.dynrelcount
= 0;
2398 disasm_info
.print_address_func
= objdump_print_address
;
2399 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2401 if (machine
!= NULL
)
2403 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2406 fatal (_("can't use supplied machine %s"), machine
);
2408 abfd
->arch_info
= inf
;
2411 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2413 struct bfd_target
*xvec
;
2415 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2416 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2417 xvec
->byteorder
= endian
;
2421 /* Use libopcodes to locate a suitable disassembler. */
2422 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2423 bfd_big_endian (abfd
),
2424 bfd_get_mach (abfd
), abfd
);
2425 if (!aux
.disassemble_fn
)
2427 non_fatal (_("can't disassemble for architecture %s\n"),
2428 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2433 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2434 disasm_info
.arch
= bfd_get_arch (abfd
);
2435 disasm_info
.mach
= bfd_get_mach (abfd
);
2436 disasm_info
.disassembler_options
= disassembler_options
;
2437 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2438 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2439 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2440 disasm_info
.disassembler_needs_relocs
= FALSE
;
2442 if (bfd_big_endian (abfd
))
2443 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2444 else if (bfd_little_endian (abfd
))
2445 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2447 /* ??? Aborting here seems too drastic. We could default to big or little
2449 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2451 /* Allow the target to customize the info structure. */
2452 disassemble_init_for_target (& disasm_info
);
2454 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2456 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2458 if (relsize
< 0 && dump_dynamic_reloc_info
)
2459 bfd_fatal (bfd_get_filename (abfd
));
2463 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2464 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2467 if (aux
.dynrelcount
< 0)
2468 bfd_fatal (bfd_get_filename (abfd
));
2470 /* Sort the relocs by address. */
2471 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2475 disasm_info
.symtab
= sorted_syms
;
2476 disasm_info
.symtab_size
= sorted_symcount
;
2478 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2480 if (aux
.dynrelbuf
!= NULL
)
2481 free (aux
.dynrelbuf
);
2486 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2487 asection
*sec
, void *file
)
2489 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2490 bfd
*abfd
= (bfd
*) file
;
2494 if (section
->start
!= NULL
)
2496 /* If it is already loaded, do nothing. */
2497 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2499 free (section
->start
);
2502 section
->filename
= bfd_get_filename (abfd
);
2503 section
->reloc_info
= NULL
;
2504 section
->num_relocs
= 0;
2505 section
->address
= bfd_get_section_vma (abfd
, sec
);
2506 section
->size
= bfd_get_section_size (sec
);
2507 amt
= section
->size
+ 1;
2508 section
->start
= contents
= malloc (amt
);
2509 section
->user_data
= sec
;
2511 || section
->start
== NULL
2512 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2514 free_debug_section (debug
);
2515 printf (_("\nCan't get contents for section '%s'.\n"),
2519 /* Ensure any string section has a terminating NUL. */
2520 section
->start
[section
->size
] = 0;
2522 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2527 bfd_cache_section_contents (sec
, section
->start
);
2529 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2536 free_debug_section (debug
);
2537 printf (_("\nCan't get contents for section '%s'.\n"),
2542 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2545 unsigned long reloc_count
;
2548 relocs
= (arelent
**) xmalloc (reloc_size
);
2550 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2551 if (reloc_count
== 0)
2555 section
->reloc_info
= relocs
;
2556 section
->num_relocs
= reloc_count
;
2565 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2570 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2573 relocs
= (arelent
**) dsec
->reloc_info
;
2575 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2576 if (rp
->address
== offset
)
2583 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2585 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2586 bfd
*abfd
= (bfd
*) file
;
2589 /* If it is already loaded, do nothing. */
2590 if (section
->start
!= NULL
)
2592 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2596 /* Locate the debug section. */
2597 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2599 section
->name
= section
->uncompressed_name
;
2602 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2604 section
->name
= section
->compressed_name
;
2609 return load_specific_debug_section (debug
, sec
, file
);
2613 free_debug_section (enum dwarf_section_display_enum debug
)
2615 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2617 if (section
->start
== NULL
)
2620 /* PR 17512: file: 0f67f69d. */
2621 if (section
->user_data
!= NULL
)
2623 asection
* sec
= (asection
*) section
->user_data
;
2625 /* If we are freeing contents that are also pointed to by the BFD
2626 library's section structure then make sure to update those pointers
2627 too. Otherwise, the next time we try to load data for this section
2628 we can end up using a stale pointer. */
2629 if (section
->start
== sec
->contents
)
2631 sec
->contents
= NULL
;
2632 sec
->flags
&= ~ SEC_IN_MEMORY
;
2633 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2637 free ((char *) section
->start
);
2638 section
->start
= NULL
;
2639 section
->address
= 0;
2644 close_debug_file (void * file
)
2646 bfd
* abfd
= (bfd
*) file
;
2652 open_debug_file (const char * pathname
)
2656 data
= bfd_openr (pathname
, NULL
);
2660 if (! bfd_check_format (data
, bfd_object
))
2667 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2668 void *arg ATTRIBUTE_UNUSED
)
2670 const char *name
= bfd_get_section_name (abfd
, section
);
2674 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2675 match
= ".debug_info";
2679 for (i
= 0; i
< max
; i
++)
2680 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2681 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2682 && debug_displays
[i
].enabled
!= NULL
2683 && *debug_displays
[i
].enabled
)
2685 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2687 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2688 sec
->name
= sec
->uncompressed_name
;
2690 sec
->name
= sec
->compressed_name
;
2691 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2694 debug_displays
[i
].display (sec
, abfd
);
2696 if (i
!= info
&& i
!= abbrev
)
2697 free_debug_section ((enum dwarf_section_display_enum
) i
);
2703 /* Dump the dwarf debugging information. */
2706 dump_dwarf (bfd
*abfd
)
2710 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2712 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2714 if (bfd_big_endian (abfd
))
2715 byte_get
= byte_get_big_endian
;
2716 else if (bfd_little_endian (abfd
))
2717 byte_get
= byte_get_little_endian
;
2719 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2721 warn (_("File %s does not contain any dwarf debug information\n"),
2722 bfd_get_filename (abfd
));
2726 switch (bfd_get_arch (abfd
))
2729 switch (bfd_get_mach (abfd
))
2731 case bfd_mach_x86_64
:
2732 case bfd_mach_x86_64_intel_syntax
:
2733 case bfd_mach_x86_64_nacl
:
2734 case bfd_mach_x64_32
:
2735 case bfd_mach_x64_32_intel_syntax
:
2736 case bfd_mach_x64_32_nacl
:
2737 init_dwarf_regnames_x86_64 ();
2741 init_dwarf_regnames_i386 ();
2746 case bfd_arch_iamcu
:
2747 init_dwarf_regnames_iamcu ();
2750 case bfd_arch_aarch64
:
2751 init_dwarf_regnames_aarch64();
2755 init_dwarf_regnames_s390 ();
2758 case bfd_arch_riscv
:
2759 init_dwarf_regnames_riscv ();
2763 /* S12Z has a 24 bit address space. But the only known
2764 producer of dwarf_info encodes addresses into 32 bits. */
2772 separates
= load_separate_debug_file (abfd
, bfd_get_filename (abfd
));
2774 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2777 bfd_map_over_sections (separates
, dump_dwarf_section
, NULL
);
2779 free_debug_memory ();
2782 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2783 it. Return NULL on failure. */
2786 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2791 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2792 if (stabsect
== NULL
)
2794 printf (_("No %s section present\n\n"), sect_name
);
2798 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2800 non_fatal (_("reading %s section of %s failed: %s"),
2801 sect_name
, bfd_get_filename (abfd
),
2802 bfd_errmsg (bfd_get_error ()));
2808 *size_ptr
= bfd_section_size (abfd
, stabsect
);
2813 /* Stabs entries use a 12 byte format:
2814 4 byte string table index
2816 1 byte stab other field
2817 2 byte stab desc field
2819 FIXME: This will have to change for a 64 bit object format. */
2821 #define STRDXOFF (0)
2823 #define OTHEROFF (5)
2826 #define STABSIZE (12)
2828 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2829 using string table section STRSECT_NAME (in `strtab'). */
2832 print_section_stabs (bfd
*abfd
,
2833 const char *stabsect_name
,
2834 unsigned *string_offset_ptr
)
2837 unsigned file_string_table_offset
= 0;
2838 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2839 bfd_byte
*stabp
, *stabs_end
;
2842 stabs_end
= stabp
+ stab_size
;
2844 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2845 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2847 /* Loop through all symbols and print them.
2849 We start the index at -1 because there is a dummy symbol on
2850 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2851 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2855 unsigned char type
, other
;
2856 unsigned short desc
;
2859 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2860 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2861 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2862 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2863 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2865 printf ("\n%-6d ", i
);
2866 /* Either print the stab name, or, if unnamed, print its number
2867 again (makes consistent formatting for tools like awk). */
2868 name
= bfd_get_stab_name (type
);
2870 printf ("%-6s", name
);
2871 else if (type
== N_UNDF
)
2874 printf ("%-6d", type
);
2875 printf (" %-6d %-6d ", other
, desc
);
2876 bfd_printf_vma (abfd
, value
);
2877 printf (" %-6lu", strx
);
2879 /* Symbols with type == 0 (N_UNDF) specify the length of the
2880 string table associated with this file. We use that info
2881 to know how to relocate the *next* file's string table indices. */
2884 file_string_table_offset
= next_file_string_table_offset
;
2885 next_file_string_table_offset
+= value
;
2889 bfd_size_type amt
= strx
+ file_string_table_offset
;
2891 /* Using the (possibly updated) string table offset, print the
2892 string (if any) associated with this symbol. */
2893 if (amt
< stabstr_size
)
2894 /* PR 17512: file: 079-79389-0.001:0.1. */
2895 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2901 *string_offset_ptr
= next_file_string_table_offset
;
2906 const char * section_name
;
2907 const char * string_section_name
;
2908 unsigned string_offset
;
2913 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2916 stab_section_names
* sought
= (stab_section_names
*) names
;
2918 /* Check for section names for which stabsect_name is a prefix, to
2919 handle .stab.N, etc. */
2920 len
= strlen (sought
->section_name
);
2922 /* If the prefix matches, and the files section name ends with a
2923 nul or a digit, then we match. I.e., we want either an exact
2924 match or a section followed by a number. */
2925 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2926 && (section
->name
[len
] == 0
2927 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2930 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2935 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
2937 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2943 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2945 stab_section_names s
;
2947 s
.section_name
= stabsect_name
;
2948 s
.string_section_name
= strsect_name
;
2949 s
.string_offset
= 0;
2951 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2957 /* Dump the any sections containing stabs debugging information. */
2960 dump_stabs (bfd
*abfd
)
2962 dump_stabs_section (abfd
, ".stab", ".stabstr");
2963 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2964 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2967 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2969 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2973 dump_bfd_header (bfd
*abfd
)
2977 printf (_("architecture: %s, "),
2978 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2979 bfd_get_mach (abfd
)));
2980 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2982 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2983 PF (HAS_RELOC
, "HAS_RELOC");
2984 PF (EXEC_P
, "EXEC_P");
2985 PF (HAS_LINENO
, "HAS_LINENO");
2986 PF (HAS_DEBUG
, "HAS_DEBUG");
2987 PF (HAS_SYMS
, "HAS_SYMS");
2988 PF (HAS_LOCALS
, "HAS_LOCALS");
2989 PF (DYNAMIC
, "DYNAMIC");
2990 PF (WP_TEXT
, "WP_TEXT");
2991 PF (D_PAGED
, "D_PAGED");
2992 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2993 printf (_("\nstart address 0x"));
2994 bfd_printf_vma (abfd
, abfd
->start_address
);
3000 dump_bfd_private_header (bfd
*abfd
)
3002 bfd_print_private_bfd_data (abfd
, stdout
);
3006 dump_target_specific (bfd
*abfd
)
3008 const struct objdump_private_desc
* const *desc
;
3009 struct objdump_private_option
*opt
;
3012 /* Find the desc. */
3013 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3014 if ((*desc
)->filter (abfd
))
3019 non_fatal (_("option -P/--private not supported by this file"));
3023 /* Clear all options. */
3024 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3025 opt
->selected
= FALSE
;
3027 /* Decode options. */
3028 b
= dump_private_options
;
3031 e
= strchr (b
, ',');
3036 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3037 if (strcmp (opt
->name
, b
) == 0)
3039 opt
->selected
= TRUE
;
3042 if (opt
->name
== NULL
)
3043 non_fatal (_("target specific dump '%s' not supported"), b
);
3054 (*desc
)->dump (abfd
);
3057 /* Display a section in hexadecimal format with associated characters.
3058 Each line prefixed by the zero padded address. */
3061 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3063 bfd_byte
*data
= NULL
;
3064 bfd_size_type datasize
;
3065 bfd_vma addr_offset
;
3066 bfd_vma start_offset
;
3067 bfd_vma stop_offset
;
3068 unsigned int opb
= bfd_octets_per_byte (abfd
);
3069 /* Bytes per line. */
3070 const int onaline
= 16;
3075 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3078 if (! process_section_p (section
))
3081 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3084 /* Compute the address range to display. */
3085 if (start_address
== (bfd_vma
) -1
3086 || start_address
< section
->vma
)
3089 start_offset
= start_address
- section
->vma
;
3091 if (stop_address
== (bfd_vma
) -1)
3092 stop_offset
= datasize
/ opb
;
3095 if (stop_address
< section
->vma
)
3098 stop_offset
= stop_address
- section
->vma
;
3100 if (stop_offset
> datasize
/ opb
)
3101 stop_offset
= datasize
/ opb
;
3104 if (start_offset
>= stop_offset
)
3107 printf (_("Contents of section %s:"), section
->name
);
3108 if (display_file_offsets
)
3109 printf (_(" (Starting at file offset: 0x%lx)"),
3110 (unsigned long) (section
->filepos
+ start_offset
));
3113 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3115 non_fatal (_("Reading section %s failed because: %s"),
3116 section
->name
, bfd_errmsg (bfd_get_error ()));
3122 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3123 if (strlen (buf
) >= sizeof (buf
))
3127 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3129 count
= strlen (buf
) - count
;
3133 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3134 if (strlen (buf
) >= sizeof (buf
))
3138 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3140 count
= strlen (buf
) - count
;
3144 for (addr_offset
= start_offset
;
3145 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3149 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3150 count
= strlen (buf
);
3151 if ((size_t) count
>= sizeof (buf
))
3155 while (count
< width
)
3160 fputs (buf
+ count
- width
, stdout
);
3163 for (j
= addr_offset
* opb
;
3164 j
< addr_offset
* opb
+ onaline
; j
++)
3166 if (j
< stop_offset
* opb
)
3167 printf ("%02x", (unsigned) (data
[j
]));
3175 for (j
= addr_offset
* opb
;
3176 j
< addr_offset
* opb
+ onaline
; j
++)
3178 if (j
>= stop_offset
* opb
)
3181 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3188 /* Actually display the various requested regions. */
3191 dump_data (bfd
*abfd
)
3193 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3196 /* Should perhaps share code and display with nm? */
3199 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3208 max_count
= dynsymcount
;
3209 printf ("DYNAMIC SYMBOL TABLE:\n");
3214 max_count
= symcount
;
3215 printf ("SYMBOL TABLE:\n");
3219 printf (_("no symbols\n"));
3221 for (count
= 0; count
< max_count
; count
++)
3225 if (*current
== NULL
)
3226 printf (_("no information for symbol number %ld\n"), count
);
3228 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3229 printf (_("could not determine the type of symbol number %ld\n"),
3232 else if (process_section_p ((* current
)->section
)
3233 && (dump_special_syms
3234 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3236 const char *name
= (*current
)->name
;
3238 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3242 /* If we want to demangle the name, we demangle it
3243 here, and temporarily clobber it while calling
3244 bfd_print_symbol. FIXME: This is a gross hack. */
3245 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3247 (*current
)->name
= alloc
;
3248 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3249 bfd_print_symbol_all
);
3252 (*current
)->name
= name
;
3257 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3258 bfd_print_symbol_all
);
3268 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3271 char *last_filename
, *last_functionname
;
3272 unsigned int last_line
;
3273 unsigned int last_discriminator
;
3275 /* Get column headers lined up reasonably. */
3283 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3284 width
= strlen (buf
) - 7;
3286 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3289 last_filename
= NULL
;
3290 last_functionname
= NULL
;
3292 last_discriminator
= 0;
3294 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3297 const char *filename
, *functionname
;
3298 unsigned int linenumber
;
3299 unsigned int discriminator
;
3300 const char *sym_name
;
3301 const char *section_name
;
3302 bfd_vma addend2
= 0;
3304 if (start_address
!= (bfd_vma
) -1
3305 && q
->address
< start_address
)
3307 if (stop_address
!= (bfd_vma
) -1
3308 && q
->address
> stop_address
)
3311 if (with_line_numbers
3313 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3314 &filename
, &functionname
,
3315 &linenumber
, &discriminator
))
3317 if (functionname
!= NULL
3318 && (last_functionname
== NULL
3319 || strcmp (functionname
, last_functionname
) != 0))
3321 printf ("%s():\n", functionname
);
3322 if (last_functionname
!= NULL
)
3323 free (last_functionname
);
3324 last_functionname
= xstrdup (functionname
);
3328 && (linenumber
!= last_line
3329 || (filename
!= NULL
3330 && last_filename
!= NULL
3331 && filename_cmp (filename
, last_filename
) != 0)
3332 || (discriminator
!= last_discriminator
)))
3334 if (discriminator
> 0)
3335 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3337 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3338 linenumber
, discriminator
);
3339 last_line
= linenumber
;
3340 last_discriminator
= discriminator
;
3341 if (last_filename
!= NULL
)
3342 free (last_filename
);
3343 if (filename
== NULL
)
3344 last_filename
= NULL
;
3346 last_filename
= xstrdup (filename
);
3350 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3352 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3353 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3358 section_name
= NULL
;
3361 bfd_printf_vma (abfd
, q
->address
);
3362 if (q
->howto
== NULL
)
3363 printf (" *unknown* ");
3364 else if (q
->howto
->name
)
3366 const char *name
= q
->howto
->name
;
3368 /* R_SPARC_OLO10 relocations contain two addends.
3369 But because 'arelent' lacks enough storage to
3370 store them both, the 64-bit ELF Sparc backend
3371 records this as two relocations. One R_SPARC_LO10
3372 and one R_SPARC_13, both pointing to the same
3373 address. This is merely so that we have some
3374 place to store both addend fields.
3376 Undo this transformation, otherwise the output
3377 will be confusing. */
3378 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3379 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3381 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3383 arelent
*q2
= *(p
+ 1);
3386 && q
->address
== q2
->address
3387 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3389 name
= "R_SPARC_OLO10";
3390 addend2
= q2
->addend
;
3394 printf (" %-16s ", name
);
3397 printf (" %-16d ", q
->howto
->type
);
3401 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3405 if (section_name
== NULL
)
3406 section_name
= "*unknown*";
3407 printf ("[%s]", section_name
);
3412 bfd_signed_vma addend
= q
->addend
;
3420 bfd_printf_vma (abfd
, addend
);
3425 bfd_printf_vma (abfd
, addend2
);
3431 if (last_filename
!= NULL
)
3432 free (last_filename
);
3433 if (last_functionname
!= NULL
)
3434 free (last_functionname
);
3438 dump_relocs_in_section (bfd
*abfd
,
3440 void *dummy ATTRIBUTE_UNUSED
)
3446 if ( bfd_is_abs_section (section
)
3447 || bfd_is_und_section (section
)
3448 || bfd_is_com_section (section
)
3449 || (! process_section_p (section
))
3450 || ((section
->flags
& SEC_RELOC
) == 0))
3453 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3455 bfd_fatal (bfd_get_filename (abfd
));
3457 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3461 printf (" (none)\n\n");
3465 if ((bfd_get_file_flags (abfd
) & (BFD_IN_MEMORY
| BFD_LINKER_CREATED
)) == 0
3466 && (((ufile_ptr
) relsize
> bfd_get_file_size (abfd
))
3467 /* Also check the section's reloc count since if this is negative
3468 (or very large) the computation in bfd_get_reloc_upper_bound
3469 may have resulted in returning a small, positive integer.
3470 See PR 22508 for a reproducer.
3472 Note - we check against file size rather than section size as
3473 it is possible for there to be more relocs that apply to a
3474 section than there are bytes in that section. */
3475 || (section
->reloc_count
> bfd_get_file_size (abfd
))))
3477 printf (" (too many: 0x%x)\n", section
->reloc_count
);
3478 bfd_set_error (bfd_error_file_truncated
);
3479 bfd_fatal (bfd_get_filename (abfd
));
3482 relpp
= (arelent
**) xmalloc (relsize
);
3483 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3488 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3489 bfd_fatal (_("error message was"));
3491 else if (relcount
== 0)
3492 printf (" (none)\n\n");
3496 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3503 dump_relocs (bfd
*abfd
)
3505 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3509 dump_dynamic_relocs (bfd
*abfd
)
3515 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3517 bfd_fatal (bfd_get_filename (abfd
));
3519 printf ("DYNAMIC RELOCATION RECORDS");
3522 printf (" (none)\n\n");
3525 relpp
= (arelent
**) xmalloc (relsize
);
3526 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3529 bfd_fatal (bfd_get_filename (abfd
));
3530 else if (relcount
== 0)
3531 printf (" (none)\n\n");
3535 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3542 /* Creates a table of paths, to search for source files. */
3545 add_include_path (const char *path
)
3549 include_path_count
++;
3550 include_paths
= (const char **)
3551 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3552 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3553 if (path
[1] == ':' && path
[2] == 0)
3554 path
= concat (path
, ".", (const char *) 0);
3556 include_paths
[include_path_count
- 1] = path
;
3560 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3564 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3566 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3567 section
->vma
+= adjust_section_vma
;
3569 section
->lma
+= adjust_section_vma
;
3573 /* Dump selected contents of ABFD. */
3576 dump_bfd (bfd
*abfd
)
3578 /* If we are adjusting section VMA's, change them all now. Changing
3579 the BFD information is a hack. However, we must do it, or
3580 bfd_find_nearest_line will not do the right thing. */
3581 if (adjust_section_vma
!= 0)
3583 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3584 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3587 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3588 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3591 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3592 if (dump_file_header
)
3593 dump_bfd_header (abfd
);
3594 if (dump_private_headers
)
3595 dump_bfd_private_header (abfd
);
3596 if (dump_private_options
!= NULL
)
3597 dump_target_specific (abfd
);
3598 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3605 || dump_dwarf_section_info
)
3606 syms
= slurp_symtab (abfd
);
3608 if (dump_section_headers
)
3609 dump_headers (abfd
);
3611 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3612 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3613 dynsyms
= slurp_dynamic_symtab (abfd
);
3616 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3617 dynsymcount
, dynsyms
, &synthsyms
);
3623 dump_symbols (abfd
, FALSE
);
3624 if (dump_dynamic_symtab
)
3625 dump_symbols (abfd
, TRUE
);
3626 if (dump_dwarf_section_info
)
3628 if (dump_stab_section_info
)
3630 if (dump_reloc_info
&& ! disassemble
)
3632 if (dump_dynamic_reloc_info
&& ! disassemble
)
3633 dump_dynamic_relocs (abfd
);
3634 if (dump_section_contents
)
3637 disassemble_data (abfd
);
3643 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3644 if (dhandle
!= NULL
)
3646 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3648 dump_debugging_tags
? TRUE
: FALSE
))
3650 non_fatal (_("%s: printing debugging information failed"),
3651 bfd_get_filename (abfd
));
3655 /* PR 6483: If there was no STABS debug info in the file, try
3657 else if (! dump_dwarf_section_info
)
3659 dwarf_select_sections_all ();
3688 display_object_bfd (bfd
*abfd
)
3692 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3698 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3700 nonfatal (bfd_get_filename (abfd
));
3701 list_matching_formats (matching
);
3706 if (bfd_get_error () != bfd_error_file_not_recognized
)
3708 nonfatal (bfd_get_filename (abfd
));
3712 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3718 nonfatal (bfd_get_filename (abfd
));
3720 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3722 list_matching_formats (matching
);
3728 display_any_bfd (bfd
*file
, int level
)
3730 /* Decompress sections unless dumping the section contents. */
3731 if (!dump_section_contents
)
3732 file
->flags
|= BFD_DECOMPRESS
;
3734 /* If the file is an archive, process all of its elements. */
3735 if (bfd_check_format (file
, bfd_archive
))
3738 bfd
*last_arfile
= NULL
;
3741 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3742 else if (level
> 100)
3744 /* Prevent corrupted files from spinning us into an
3745 infinite loop. 100 is an arbitrary heuristic. */
3746 fatal (_("Archive nesting is too deep"));
3750 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3754 bfd_set_error (bfd_error_no_error
);
3756 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3759 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3760 nonfatal (bfd_get_filename (file
));
3764 display_any_bfd (arfile
, level
+ 1);
3766 if (last_arfile
!= NULL
)
3768 bfd_close (last_arfile
);
3769 /* PR 17512: file: ac585d01. */
3770 if (arfile
== last_arfile
)
3776 last_arfile
= arfile
;
3779 if (last_arfile
!= NULL
)
3780 bfd_close (last_arfile
);
3783 display_object_bfd (file
);
3787 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3791 if (get_file_size (filename
) < 1)
3797 file
= bfd_openr (filename
, target
);
3800 nonfatal (filename
);
3804 display_any_bfd (file
, 0);
3806 /* This is an optimization to improve the speed of objdump, especially when
3807 dumping a file with lots of associated debug informatiom. Calling
3808 bfd_close on such a file can take a non-trivial amount of time as there
3809 are lots of lists to walk and buffers to free. This is only really
3810 necessary however if we are about to load another file and we need the
3811 memory back. Otherwise, if we are about to exit, then we can save (a lot
3812 of) time by only doing a quick close, and allowing the OS to reclaim the
3817 bfd_close_all_done (file
);
3821 main (int argc
, char **argv
)
3824 char *target
= default_target
;
3825 bfd_boolean seenflag
= FALSE
;
3827 #if defined (HAVE_SETLOCALE)
3828 #if defined (HAVE_LC_MESSAGES)
3829 setlocale (LC_MESSAGES
, "");
3831 setlocale (LC_CTYPE
, "");
3834 bindtextdomain (PACKAGE
, LOCALEDIR
);
3835 textdomain (PACKAGE
);
3837 program_name
= *argv
;
3838 xmalloc_set_program_name (program_name
);
3839 bfd_set_error_program_name (program_name
);
3841 START_PROGRESS (program_name
, 0);
3843 expandargv (&argc
, &argv
);
3846 set_default_bfd_target ();
3848 while ((c
= getopt_long (argc
, argv
,
3849 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3850 long_options
, (int *) 0))
3856 break; /* We've been given a long option. */
3863 if (disassembler_options
)
3864 /* Ignore potential memory leak for now. */
3865 options
= concat (disassembler_options
, ",",
3866 optarg
, (const char *) NULL
);
3869 disassembler_options
= remove_whitespace_and_extra_commas (options
);
3876 display_file_offsets
= TRUE
;
3879 with_line_numbers
= TRUE
;
3888 enum demangling_styles style
;
3890 style
= cplus_demangle_name_to_style (optarg
);
3891 if (style
== unknown_demangling
)
3892 fatal (_("unknown demangling style `%s'"),
3895 cplus_demangle_set_style (style
);
3899 do_wide
= wide_output
= TRUE
;
3901 case OPTION_ADJUST_VMA
:
3902 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3904 case OPTION_START_ADDRESS
:
3905 start_address
= parse_vma (optarg
, "--start-address");
3906 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3907 fatal (_("error: the start address should be before the end address"));
3909 case OPTION_STOP_ADDRESS
:
3910 stop_address
= parse_vma (optarg
, "--stop-address");
3911 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3912 fatal (_("error: the stop address should be after the start address"));
3916 prefix_length
= strlen (prefix
);
3917 /* Remove an unnecessary trailing '/' */
3918 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3921 case OPTION_PREFIX_STRIP
:
3922 prefix_strip
= atoi (optarg
);
3923 if (prefix_strip
< 0)
3924 fatal (_("error: prefix strip must be non-negative"));
3926 case OPTION_INSN_WIDTH
:
3927 insn_width
= strtoul (optarg
, NULL
, 0);
3928 if (insn_width
<= 0)
3929 fatal (_("error: instruction width must be positive"));
3931 case OPTION_INLINES
:
3932 unwind_inlines
= TRUE
;
3935 if (strcmp (optarg
, "B") == 0)
3936 endian
= BFD_ENDIAN_BIG
;
3937 else if (strcmp (optarg
, "L") == 0)
3938 endian
= BFD_ENDIAN_LITTLE
;
3941 nonfatal (_("unrecognized -E option"));
3946 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3947 endian
= BFD_ENDIAN_BIG
;
3948 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3949 endian
= BFD_ENDIAN_LITTLE
;
3952 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3959 dump_file_header
= TRUE
;
3963 formats_info
= TRUE
;
3967 add_include_path (optarg
);
3970 dump_private_headers
= TRUE
;
3974 dump_private_options
= optarg
;
3978 dump_private_headers
= TRUE
;
3980 dump_reloc_info
= TRUE
;
3981 dump_file_header
= TRUE
;
3982 dump_ar_hdrs
= TRUE
;
3983 dump_section_headers
= TRUE
;
3991 dump_dynamic_symtab
= TRUE
;
3999 disassemble_zeroes
= TRUE
;
4003 disassemble_all
= TRUE
;
4008 with_source_code
= TRUE
;
4017 dump_debugging_tags
= 1;
4022 dump_dwarf_section_info
= TRUE
;
4025 dwarf_select_sections_by_letters (optarg
);
4027 dwarf_select_sections_all ();
4030 dump_dwarf_section_info
= TRUE
;
4033 dwarf_select_sections_by_names (optarg
);
4035 dwarf_select_sections_all ();
4037 case OPTION_DWARF_DEPTH
:
4040 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4043 case OPTION_DWARF_START
:
4046 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4047 suppress_bfd_header
= 1;
4050 case OPTION_DWARF_CHECK
:
4054 dump_stab_section_info
= TRUE
;
4058 dump_section_contents
= TRUE
;
4062 dump_reloc_info
= TRUE
;
4066 dump_dynamic_reloc_info
= TRUE
;
4070 dump_ar_hdrs
= TRUE
;
4074 dump_section_headers
= TRUE
;
4079 show_version
= TRUE
;
4085 /* No need to set seenflag or to break - usage() does not return. */
4092 print_version ("objdump");
4098 exit_status
= display_info ();
4102 display_file ("a.out", target
, TRUE
);
4104 for (; optind
< argc
;)
4106 display_file (argv
[optind
], target
, optind
== argc
- 1);
4113 END_PROGRESS (program_name
);