1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2019 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. */
121 static const char * disasm_sym
; /* Disassembly start symbol. */
123 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
125 /* A structure to record the sections mentioned in -j switches. */
128 const char * name
; /* The name of the section. */
129 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
130 struct only
* next
; /* Pointer to the next structure in the list. */
132 /* Pointer to an array of 'only' structures.
133 This pointer is NULL if the -j switch has not been used. */
134 static struct only
* only_list
= NULL
;
136 /* Variables for handling include file path table. */
137 static const char **include_paths
;
138 static int include_path_count
;
140 /* Extra info to pass to the section disassembler and address printing
142 struct objdump_disasm_info
146 bfd_boolean require_sec
;
147 arelent
** dynrelbuf
;
149 disassembler_ftype disassemble_fn
;
154 /* Architecture to disassemble for, or default if NULL. */
155 static char *machine
= NULL
;
157 /* Target specific options to the disassembler. */
158 static char *disassembler_options
= NULL
;
160 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
161 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
163 /* The symbol table. */
164 static asymbol
**syms
;
166 /* Number of symbols in `syms'. */
167 static long symcount
= 0;
169 /* The sorted symbol table. */
170 static asymbol
**sorted_syms
;
172 /* Number of symbols in `sorted_syms'. */
173 static long sorted_symcount
= 0;
175 /* The dynamic symbol table. */
176 static asymbol
**dynsyms
;
178 /* The synthetic symbol table. */
179 static asymbol
*synthsyms
;
180 static long synthcount
= 0;
182 /* Number of symbols in `dynsyms'. */
183 static long dynsymcount
= 0;
185 static bfd_byte
*stabs
;
186 static bfd_size_type stab_size
;
188 static bfd_byte
*strtab
;
189 static bfd_size_type stabstr_size
;
191 static bfd_boolean is_relocatable
= FALSE
;
193 /* Handlers for -P/--private. */
194 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
196 OBJDUMP_PRIVATE_VECTORS
200 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
202 usage (FILE *stream
, int status
)
204 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
205 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
206 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
207 fprintf (stream
, _("\
208 -a, --archive-headers Display archive header information\n\
209 -f, --file-headers Display the contents of the overall file header\n\
210 -p, --private-headers Display object format specific file header contents\n\
211 -P, --private=OPT,OPT... Display object format specific contents\n\
212 -h, --[section-]headers Display the contents of the section headers\n\
213 -x, --all-headers Display the contents of all headers\n\
214 -d, --disassemble Display assembler contents of executable sections\n\
215 -D, --disassemble-all Display assembler contents of all sections\n\
216 --disassemble=<sym> Display assembler contents from <sym>\n\
217 -S, --source Intermix source code with disassembly\n\
218 -s, --full-contents Display the full contents of all sections requested\n\
219 -g, --debugging Display debug information in object file\n\
220 -e, --debugging-tags Display debug information using ctags style\n\
221 -G, --stabs Display (in raw form) any STABS info in the file\n\
222 -W[lLiaprmfFsoRtUuTgAckK] or\n\
223 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
224 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
225 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
226 =addr,=cu_index,=links,=follow-links]\n\
227 Display DWARF info in the file\n\
228 -t, --syms Display the contents of the symbol table(s)\n\
229 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
230 -r, --reloc Display the relocation entries in the file\n\
231 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
232 @<file> Read options from <file>\n\
233 -v, --version Display this program's version number\n\
234 -i, --info List object formats and architectures supported\n\
235 -H, --help Display this information\n\
239 const struct objdump_private_desc
* const *desc
;
241 fprintf (stream
, _("\n The following switches are optional:\n"));
242 fprintf (stream
, _("\
243 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
244 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
245 -j, --section=NAME Only display information for section NAME\n\
246 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
247 -EB --endian=big Assume big endian format when disassembling\n\
248 -EL --endian=little Assume little endian format when disassembling\n\
249 --file-start-context Include context from start of file (with -S)\n\
250 -I, --include=DIR Add DIR to search list for source files\n\
251 -l, --line-numbers Include line numbers and filenames in output\n\
252 -F, --file-offsets Include file offsets when displaying information\n\
253 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
254 The STYLE, if specified, can be `auto', `gnu',\n\
255 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
257 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
258 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
259 -w, --wide Format output for more than 80 columns\n\
260 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
261 --start-address=ADDR Only process data whose address is >= ADDR\n\
262 --stop-address=ADDR Only process data whose address is <= ADDR\n\
263 --prefix-addresses Print complete address alongside disassembly\n\
264 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
265 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
266 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
267 --special-syms Include special symbols in symbol dumps\n\
268 --inlines Print all inlines for source line (with -l)\n\
269 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
270 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
271 fprintf (stream
, _("\
272 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
273 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
275 --dwarf-check Make additional dwarf internal consistency checks.\
277 list_supported_targets (program_name
, stream
);
278 list_supported_architectures (program_name
, stream
);
280 disassembler_usage (stream
);
282 if (objdump_private_vectors
[0] != NULL
)
285 _("\nOptions supported for -P/--private switch:\n"));
286 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
287 (*desc
)->help (stream
);
290 if (REPORT_BUGS_TO
[0] && status
== 0)
291 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
295 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
299 OPTION_START_ADDRESS
,
309 OPTION_RECURSE_LIMIT
,
310 OPTION_NO_RECURSE_LIMIT
,
314 static struct option long_options
[]=
316 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
317 {"all-headers", no_argument
, NULL
, 'x'},
318 {"private-headers", no_argument
, NULL
, 'p'},
319 {"private", required_argument
, NULL
, 'P'},
320 {"architecture", required_argument
, NULL
, 'm'},
321 {"archive-headers", no_argument
, NULL
, 'a'},
322 {"debugging", no_argument
, NULL
, 'g'},
323 {"debugging-tags", no_argument
, NULL
, 'e'},
324 {"demangle", optional_argument
, NULL
, 'C'},
325 {"disassemble", optional_argument
, NULL
, 'd'},
326 {"disassemble-all", no_argument
, NULL
, 'D'},
327 {"disassembler-options", required_argument
, NULL
, 'M'},
328 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
329 {"dynamic-reloc", no_argument
, NULL
, 'R'},
330 {"dynamic-syms", no_argument
, NULL
, 'T'},
331 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
332 {"file-headers", no_argument
, NULL
, 'f'},
333 {"file-offsets", no_argument
, NULL
, 'F'},
334 {"file-start-context", no_argument
, &file_start_context
, 1},
335 {"full-contents", no_argument
, NULL
, 's'},
336 {"headers", no_argument
, NULL
, 'h'},
337 {"help", no_argument
, NULL
, 'H'},
338 {"info", no_argument
, NULL
, 'i'},
339 {"line-numbers", no_argument
, NULL
, 'l'},
340 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
341 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
342 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
343 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
344 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
345 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
346 {"reloc", no_argument
, NULL
, 'r'},
347 {"section", required_argument
, NULL
, 'j'},
348 {"section-headers", no_argument
, NULL
, 'h'},
349 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
350 {"source", no_argument
, NULL
, 'S'},
351 {"special-syms", no_argument
, &dump_special_syms
, 1},
352 {"include", required_argument
, NULL
, 'I'},
353 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
354 {"stabs", no_argument
, NULL
, 'G'},
355 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
356 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
357 {"syms", no_argument
, NULL
, 't'},
358 {"target", required_argument
, NULL
, 'b'},
359 {"version", no_argument
, NULL
, 'V'},
360 {"wide", no_argument
, NULL
, 'w'},
361 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
362 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
363 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
364 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
365 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
366 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
367 {"inlines", no_argument
, 0, OPTION_INLINES
},
368 {0, no_argument
, 0, 0}
372 nonfatal (const char *msg
)
378 /* Returns a version of IN with any control characters
379 replaced by escape sequences. Uses a static buffer
383 sanitize_string (const char * in
)
385 static char * buffer
= NULL
;
386 static size_t buffer_len
= 0;
387 const char * original
= in
;
394 /* See if any conversion is necessary. In the majority
395 of cases it will not be needed. */
408 /* Copy the input, translating as needed. */
410 if (buffer_len
< (strlen (in
) * 2))
412 free ((void *) buffer
);
413 buffer_len
= strlen (in
) * 2;
414 buffer
= xmalloc (buffer_len
+ 1);
440 /* Returns TRUE if the specified section should be dumped. */
443 process_section_p (asection
* section
)
447 if (only_list
== NULL
)
450 for (only
= only_list
; only
; only
= only
->next
)
451 if (strcmp (only
->name
, section
->name
) == 0)
460 /* Add an entry to the 'only' list. */
463 add_only (char * name
)
467 /* First check to make sure that we do not
468 already have an entry for this name. */
469 for (only
= only_list
; only
; only
= only
->next
)
470 if (strcmp (only
->name
, name
) == 0)
473 only
= xmalloc (sizeof * only
);
476 only
->next
= only_list
;
480 /* Release the memory used by the 'only' list.
481 PR 11225: Issue a warning message for unseen sections.
482 Only do this if none of the sections were seen. This is mainly to support
483 tools like the GAS testsuite where an object file is dumped with a list of
484 generic section names known to be present in a range of different file
488 free_only_list (void)
490 bfd_boolean at_least_one_seen
= FALSE
;
494 if (only_list
== NULL
)
497 for (only
= only_list
; only
; only
= only
->next
)
500 at_least_one_seen
= TRUE
;
504 for (only
= only_list
; only
; only
= next
)
506 if (! at_least_one_seen
)
508 non_fatal (_("section '%s' mentioned in a -j option, "
509 "but not found in any input file"),
520 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
523 unsigned int opb
= bfd_octets_per_byte (abfd
);
524 int longest_section_name
= *((int *) data
);
526 /* Ignore linker created section. See elfNN_ia64_object_p in
528 if (section
->flags
& SEC_LINKER_CREATED
)
531 /* PR 10413: Skip sections that we are ignoring. */
532 if (! process_section_p (section
))
535 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
536 sanitize_string (bfd_get_section_name (abfd
, section
)),
537 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
538 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
540 bfd_printf_vma (abfd
, section
->lma
);
541 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
542 bfd_get_section_alignment (abfd
, section
));
548 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
550 PF (SEC_HAS_CONTENTS
, "CONTENTS");
551 PF (SEC_ALLOC
, "ALLOC");
552 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
553 PF (SEC_LOAD
, "LOAD");
554 PF (SEC_RELOC
, "RELOC");
555 PF (SEC_READONLY
, "READONLY");
556 PF (SEC_CODE
, "CODE");
557 PF (SEC_DATA
, "DATA");
559 PF (SEC_DEBUGGING
, "DEBUGGING");
560 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
561 PF (SEC_EXCLUDE
, "EXCLUDE");
562 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
563 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
565 PF (SEC_TIC54X_BLOCK
, "BLOCK");
566 PF (SEC_TIC54X_CLINK
, "CLINK");
568 PF (SEC_SMALL_DATA
, "SMALL_DATA");
569 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
571 PF (SEC_COFF_SHARED
, "SHARED");
572 PF (SEC_COFF_NOREAD
, "NOREAD");
574 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
575 PF (SEC_ELF_PURECODE
, "PURECODE");
576 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
577 PF (SEC_GROUP
, "GROUP");
578 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
580 PF (SEC_MEP_VLIW
, "VLIW");
583 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
586 struct coff_comdat_info
*comdat
;
588 switch (section
->flags
& SEC_LINK_DUPLICATES
)
592 case SEC_LINK_DUPLICATES_DISCARD
:
593 ls
= "LINK_ONCE_DISCARD";
595 case SEC_LINK_DUPLICATES_ONE_ONLY
:
596 ls
= "LINK_ONCE_ONE_ONLY";
598 case SEC_LINK_DUPLICATES_SAME_SIZE
:
599 ls
= "LINK_ONCE_SAME_SIZE";
601 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
602 ls
= "LINK_ONCE_SAME_CONTENTS";
605 printf ("%s%s", comma
, ls
);
607 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
609 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
618 /* Called on each SECTION in ABFD, update the int variable pointed to by
619 DATA which contains the string length of the longest section name. */
622 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
624 int *longest_so_far
= (int *) data
;
628 /* Ignore linker created section. */
629 if (section
->flags
& SEC_LINKER_CREATED
)
632 /* Skip sections that we are ignoring. */
633 if (! process_section_p (section
))
636 name
= bfd_get_section_name (abfd
, section
);
637 len
= (int) strlen (name
);
638 if (len
> *longest_so_far
)
639 *longest_so_far
= len
;
643 dump_headers (bfd
*abfd
)
645 /* The default width of 13 is just an arbitrary choice. */
646 int max_section_name_length
= 13;
652 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
653 if (bfd_get_arch_size (abfd
) == 32)
659 printf (_("Sections:\n"));
662 bfd_map_over_sections (abfd
, find_longest_section_name
,
663 &max_section_name_length
);
665 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
666 max_section_name_length
, "Name",
667 bfd_vma_width
, "VMA",
668 bfd_vma_width
, "LMA");
671 printf (_(" Flags"));
674 bfd_map_over_sections (abfd
, dump_section_header
,
675 &max_section_name_length
);
679 slurp_symtab (bfd
*abfd
)
684 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
690 storage
= bfd_get_symtab_upper_bound (abfd
);
693 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
694 bfd_fatal (_("error message was"));
697 sy
= (asymbol
**) xmalloc (storage
);
699 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
701 bfd_fatal (bfd_get_filename (abfd
));
705 /* Read in the dynamic symbols. */
708 slurp_dynamic_symtab (bfd
*abfd
)
713 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
716 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
718 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
724 bfd_fatal (bfd_get_filename (abfd
));
727 sy
= (asymbol
**) xmalloc (storage
);
729 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
731 bfd_fatal (bfd_get_filename (abfd
));
735 /* Some symbol names are significant and should be kept in the
736 table of sorted symbol names, even if they are marked as
737 debugging/section symbols. */
740 is_significant_symbol_name (const char * name
)
742 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
745 /* Filter out (in place) symbols that are useless for disassembly.
746 COUNT is the number of elements in SYMBOLS.
747 Return the number of useful symbols. */
750 remove_useless_symbols (asymbol
**symbols
, long count
)
752 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
756 asymbol
*sym
= *in_ptr
++;
758 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
760 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
761 && ! is_significant_symbol_name (sym
->name
))
763 if (bfd_is_und_section (sym
->section
)
764 || bfd_is_com_section (sym
->section
))
769 return out_ptr
- symbols
;
772 /* Sort symbols into value order. */
775 compare_symbols (const void *ap
, const void *bp
)
777 const asymbol
*a
= * (const asymbol
**) ap
;
778 const asymbol
*b
= * (const asymbol
**) bp
;
788 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
790 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
793 if (a
->section
> b
->section
)
795 else if (a
->section
< b
->section
)
798 an
= bfd_asymbol_name (a
);
799 bn
= bfd_asymbol_name (b
);
803 /* The symbols gnu_compiled and gcc2_compiled convey no real
804 information, so put them after other symbols with the same value. */
805 af
= (strstr (an
, "gnu_compiled") != NULL
806 || strstr (an
, "gcc2_compiled") != NULL
);
807 bf
= (strstr (bn
, "gnu_compiled") != NULL
808 || strstr (bn
, "gcc2_compiled") != NULL
);
815 /* We use a heuristic for the file name, to try to sort it after
816 more useful symbols. It may not work on non Unix systems, but it
817 doesn't really matter; the only difference is precisely which
818 symbol names get printed. */
820 #define file_symbol(s, sn, snl) \
821 (((s)->flags & BSF_FILE) != 0 \
822 || ((sn)[(snl) - 2] == '.' \
823 && ((sn)[(snl) - 1] == 'o' \
824 || (sn)[(snl) - 1] == 'a')))
826 af
= file_symbol (a
, an
, anl
);
827 bf
= file_symbol (b
, bn
, bnl
);
834 /* Try to sort global symbols before local symbols before function
835 symbols before debugging symbols. */
840 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
842 if ((aflags
& BSF_DEBUGGING
) != 0)
847 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
849 if ((aflags
& BSF_FUNCTION
) != 0)
854 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
856 if ((aflags
& BSF_LOCAL
) != 0)
861 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
863 if ((aflags
& BSF_GLOBAL
) != 0)
869 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
870 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
875 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
876 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
878 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
879 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
881 return asz
> bsz
? -1 : 1;
884 /* Symbols that start with '.' might be section names, so sort them
885 after symbols that don't start with '.'. */
886 if (an
[0] == '.' && bn
[0] != '.')
888 if (an
[0] != '.' && bn
[0] == '.')
891 /* Finally, if we can't distinguish them in any other way, try to
892 get consistent results by sorting the symbols by name. */
893 return strcmp (an
, bn
);
896 /* Sort relocs into address order. */
899 compare_relocs (const void *ap
, const void *bp
)
901 const arelent
*a
= * (const arelent
**) ap
;
902 const arelent
*b
= * (const arelent
**) bp
;
904 if (a
->address
> b
->address
)
906 else if (a
->address
< b
->address
)
909 /* So that associated relocations tied to the same address show up
910 in the correct order, we don't do any further sorting. */
919 /* Print an address (VMA) to the output stream in INFO.
920 If SKIP_ZEROES is TRUE, omit leading zeroes. */
923 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
924 bfd_boolean skip_zeroes
)
928 struct objdump_disasm_info
*aux
;
930 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
931 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
936 for (p
= buf
; *p
== '0'; ++p
)
941 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
944 /* Print the name of a symbol. */
947 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
951 const char *name
, *version_string
= NULL
;
952 bfd_boolean hidden
= FALSE
;
955 name
= bfd_asymbol_name (sym
);
956 if (do_demangle
&& name
[0] != '\0')
958 /* Demangle the name. */
959 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
964 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
965 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
967 if (bfd_is_und_section (bfd_get_section (sym
)))
970 name
= sanitize_string (name
);
974 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
975 if (version_string
&& *version_string
!= '\0')
976 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
982 if (version_string
&& *version_string
!= '\0')
983 printf (hidden
? "@%s" : "@@%s", version_string
);
990 static inline bfd_boolean
991 sym_ok (bfd_boolean want_section
,
992 bfd
* abfd ATTRIBUTE_UNUSED
,
995 struct disassemble_info
* inf
)
999 /* Note - we cannot just compare section pointers because they could
1000 be different, but the same... Ie the symbol that we are trying to
1001 find could have come from a separate debug info file. Under such
1002 circumstances the symbol will be associated with a section in the
1003 debug info file, whilst the section we want is in a normal file.
1004 So the section pointers will be different, but the section names
1005 will be the same. */
1006 if (strcmp (bfd_section_name (abfd
, sorted_syms
[place
]->section
),
1007 bfd_section_name (abfd
, sec
)) != 0)
1011 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1014 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1015 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1016 require the symbol to be in the section. Returns NULL if there is no
1017 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1018 of the symbol in sorted_syms. */
1021 find_symbol_for_address (bfd_vma vma
,
1022 struct disassemble_info
*inf
,
1025 /* @@ Would it speed things up to cache the last two symbols returned,
1026 and maybe their address ranges? For many processors, only one memory
1027 operand can be present at a time, so the 2-entry cache wouldn't be
1028 constantly churned by code doing heavy memory accesses. */
1030 /* Indices in `sorted_syms'. */
1032 long max_count
= sorted_symcount
;
1034 struct objdump_disasm_info
*aux
;
1038 bfd_boolean want_section
;
1041 if (sorted_symcount
< 1)
1044 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1047 opb
= inf
->octets_per_byte
;
1049 /* Perform a binary search looking for the closest symbol to the
1050 required value. We are searching the range (min, max_count]. */
1051 while (min
+ 1 < max_count
)
1055 thisplace
= (max_count
+ min
) / 2;
1056 sym
= sorted_syms
[thisplace
];
1058 if (bfd_asymbol_value (sym
) > vma
)
1059 max_count
= thisplace
;
1060 else if (bfd_asymbol_value (sym
) < vma
)
1069 /* The symbol we want is now in min, the low end of the range we
1070 were searching. If there are several symbols with the same
1071 value, we want the first (non-section/non-debugging) one. */
1073 while (thisplace
> 0
1074 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1075 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1076 && ((sorted_syms
[thisplace
- 1]->flags
1077 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1081 /* Prefer a symbol in the current section if we have multple symbols
1082 with the same value, as can occur with overlays or zero size
1085 while (min
< max_count
1086 && (bfd_asymbol_value (sorted_syms
[min
])
1087 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1089 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1096 return sorted_syms
[thisplace
];
1101 /* If the file is relocatable, and the symbol could be from this
1102 section, prefer a symbol from this section over symbols from
1103 others, even if the other symbol's value might be closer.
1105 Note that this may be wrong for some symbol references if the
1106 sections have overlapping memory ranges, but in that case there's
1107 no way to tell what's desired without looking at the relocation
1110 Also give the target a chance to reject symbols. */
1111 want_section
= (aux
->require_sec
1112 || ((abfd
->flags
& HAS_RELOC
) != 0
1113 && vma
>= bfd_get_section_vma (abfd
, sec
)
1114 && vma
< (bfd_get_section_vma (abfd
, sec
)
1115 + bfd_section_size (abfd
, sec
) / opb
)));
1117 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1120 long newplace
= sorted_symcount
;
1122 for (i
= min
- 1; i
>= 0; i
--)
1124 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1126 if (newplace
== sorted_symcount
)
1129 if (bfd_asymbol_value (sorted_syms
[i
])
1130 != bfd_asymbol_value (sorted_syms
[newplace
]))
1133 /* Remember this symbol and keep searching until we reach
1134 an earlier address. */
1139 if (newplace
!= sorted_symcount
)
1140 thisplace
= newplace
;
1143 /* We didn't find a good symbol with a smaller value.
1144 Look for one with a larger value. */
1145 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1147 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1155 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1156 /* There is no suitable symbol. */
1160 /* If we have not found an exact match for the specified address
1161 and we have dynamic relocations available, then we can produce
1162 a better result by matching a relocation to the address and
1163 using the symbol associated with that relocation. */
1164 rel_count
= aux
->dynrelcount
;
1166 && sorted_syms
[thisplace
]->value
!= vma
1168 && aux
->dynrelbuf
!= NULL
1169 && aux
->dynrelbuf
[0]->address
<= vma
1170 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1171 /* If we have matched a synthetic symbol, then stick with that. */
1172 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1175 arelent
** rel_high
;
1177 rel_low
= aux
->dynrelbuf
;
1178 rel_high
= rel_low
+ rel_count
- 1;
1179 while (rel_low
<= rel_high
)
1181 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1182 arelent
* rel
= *rel_mid
;
1184 if (rel
->address
== vma
)
1186 /* Absolute relocations do not provide a more helpful
1187 symbolic address. Find a non-absolute relocation
1188 with the same address. */
1189 arelent
**rel_vma
= rel_mid
;
1191 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1195 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1199 if (rel
->sym_ptr_ptr
!= NULL
1200 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1203 * place
= thisplace
;
1204 return * rel
->sym_ptr_ptr
;
1210 if (vma
< rel
->address
)
1212 else if (vma
>= rel_mid
[1]->address
)
1213 rel_low
= rel_mid
+ 1;
1222 return sorted_syms
[thisplace
];
1225 /* Print an address and the offset to the nearest symbol. */
1228 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1229 bfd_vma vma
, struct disassemble_info
*inf
,
1230 bfd_boolean skip_zeroes
)
1232 objdump_print_value (vma
, inf
, skip_zeroes
);
1238 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1239 sanitize_string (bfd_get_section_name (abfd
, sec
)));
1240 secaddr
= bfd_get_section_vma (abfd
, sec
);
1243 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1244 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1246 else if (vma
> secaddr
)
1248 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1249 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1251 (*inf
->fprintf_func
) (inf
->stream
, ">");
1255 (*inf
->fprintf_func
) (inf
->stream
, " <");
1257 objdump_print_symname (abfd
, inf
, sym
);
1259 if (bfd_asymbol_value (sym
) == vma
)
1261 /* Undefined symbols in an executables and dynamic objects do not have
1262 a value associated with them, so it does not make sense to display
1263 an offset relative to them. Normally we would not be provided with
1264 this kind of symbol, but the target backend might choose to do so,
1265 and the code in find_symbol_for_address might return an as yet
1266 unresolved symbol associated with a dynamic reloc. */
1267 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1268 && bfd_is_und_section (sym
->section
))
1270 else if (bfd_asymbol_value (sym
) > vma
)
1272 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1273 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1275 else if (vma
> bfd_asymbol_value (sym
))
1277 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1278 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1281 (*inf
->fprintf_func
) (inf
->stream
, ">");
1284 if (display_file_offsets
)
1285 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1286 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1289 /* Print an address (VMA), symbolically if possible.
1290 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1293 objdump_print_addr (bfd_vma vma
,
1294 struct disassemble_info
*inf
,
1295 bfd_boolean skip_zeroes
)
1297 struct objdump_disasm_info
*aux
;
1298 asymbol
*sym
= NULL
;
1299 bfd_boolean skip_find
= FALSE
;
1301 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1303 if (sorted_symcount
< 1)
1305 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1306 objdump_print_value (vma
, inf
, skip_zeroes
);
1308 if (display_file_offsets
)
1309 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1310 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1314 if (aux
->reloc
!= NULL
1315 && aux
->reloc
->sym_ptr_ptr
!= NULL
1316 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1318 sym
= * aux
->reloc
->sym_ptr_ptr
;
1320 /* Adjust the vma to the reloc. */
1321 vma
+= bfd_asymbol_value (sym
);
1323 if (bfd_is_und_section (bfd_get_section (sym
)))
1328 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1330 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1334 /* Print VMA to INFO. This function is passed to the disassembler
1338 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1340 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1343 /* Determine if the given address has a symbol associated with it. */
1346 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1350 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1352 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1355 /* Hold the last function name and the last line number we displayed
1356 in a disassembly. */
1358 static char *prev_functionname
;
1359 static unsigned int prev_line
;
1360 static unsigned int prev_discriminator
;
1362 /* We keep a list of all files that we have seen when doing a
1363 disassembly with source, so that we know how much of the file to
1364 display. This can be important for inlined functions. */
1366 struct print_file_list
1368 struct print_file_list
*next
;
1369 const char *filename
;
1370 const char *modname
;
1373 const char **linemap
;
1376 unsigned max_printed
;
1380 static struct print_file_list
*print_files
;
1382 /* The number of preceding context lines to show when we start
1383 displaying a file for the first time. */
1385 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1387 /* Read a complete file into memory. */
1390 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1393 int ps
= getpagesize ();
1397 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1401 if (fstat (fd
, fst
) < 0)
1406 *size
= fst
->st_size
;
1408 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1409 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1410 if (map
!= (char *) -1L)
1416 map
= (const char *) malloc (*size
);
1417 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1419 free ((void *) map
);
1426 #define line_map_decrease 5
1428 /* Precompute array of lines for a mapped file. */
1430 static const char **
1431 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1433 const char *p
, *lstart
, *end
;
1434 int chars_per_line
= 45; /* First iteration will use 40. */
1435 unsigned int lineno
;
1436 const char **linemap
= NULL
;
1437 unsigned long line_map_size
= 0;
1443 for (p
= map
; p
< end
; p
++)
1447 if (p
+ 1 < end
&& p
[1] == '\r')
1450 else if (*p
== '\r')
1452 if (p
+ 1 < end
&& p
[1] == '\n')
1458 /* End of line found. */
1460 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1462 unsigned long newsize
;
1464 chars_per_line
-= line_map_decrease
;
1465 if (chars_per_line
<= 1)
1467 line_map_size
= size
/ chars_per_line
+ 1;
1468 if (line_map_size
< lineno
+ 1)
1469 line_map_size
= lineno
+ 1;
1470 newsize
= line_map_size
* sizeof (char *);
1471 linemap
= (const char **) xrealloc (linemap
, newsize
);
1474 linemap
[lineno
++] = lstart
;
1482 /* Tries to open MODNAME, and if successful adds a node to print_files
1483 linked list and returns that node. Returns NULL on failure. */
1485 static struct print_file_list
*
1486 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1488 struct print_file_list
*p
;
1490 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1492 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1499 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1502 p
->filename
= origname
;
1503 p
->modname
= modname
;
1504 p
->next
= print_files
;
1510 /* If the source file, as described in the symtab, is not found
1511 try to locate it in one of the paths specified with -I
1512 If found, add location to print_files linked list. */
1514 static struct print_file_list
*
1515 update_source_path (const char *filename
, bfd
*abfd
)
1517 struct print_file_list
*p
;
1522 p
= try_print_file_open (filename
, filename
, &fst
);
1525 if (include_path_count
== 0)
1528 /* Get the name of the file. */
1529 fname
= lbasename (filename
);
1531 /* If file exists under a new path, we need to add it to the list
1532 so that show_line knows about it. */
1533 for (i
= 0; i
< include_path_count
; i
++)
1535 char *modname
= concat (include_paths
[i
], "/", fname
,
1538 p
= try_print_file_open (filename
, modname
, &fst
);
1548 long mtime
= bfd_get_mtime (abfd
);
1550 if (fst
.st_mtime
> mtime
)
1551 warn (_("source file %s is more recent than object file\n"),
1558 /* Print a source file line. */
1561 print_line (struct print_file_list
*p
, unsigned int linenum
)
1567 if (linenum
>= p
->maxline
)
1569 l
= p
->linemap
[linenum
];
1570 /* Test fwrite return value to quiet glibc warning. */
1571 len
= strcspn (l
, "\n\r");
1572 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1576 /* Print a range of source code lines. */
1579 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1583 while (start
<= end
)
1585 print_line (p
, start
);
1590 /* Show the line number, or the source line, in a disassembly
1594 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1596 const char *filename
;
1597 const char *functionname
;
1598 unsigned int linenumber
;
1599 unsigned int discriminator
;
1603 if (! with_line_numbers
&& ! with_source_code
)
1606 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1607 &filename
, &functionname
,
1608 &linenumber
, &discriminator
))
1611 if (filename
!= NULL
&& *filename
== '\0')
1613 if (functionname
!= NULL
&& *functionname
== '\0')
1614 functionname
= NULL
;
1617 && IS_ABSOLUTE_PATH (filename
)
1621 const char *fname
= filename
;
1623 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1626 memcpy (path
, prefix
, prefix_length
);
1627 path_up
= path
+ prefix_length
;
1629 /* Build relocated filename, stripping off leading directories
1630 from the initial filename if requested. */
1631 if (prefix_strip
> 0)
1636 /* Skip selected directory levels. */
1637 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1638 if (IS_DIR_SEPARATOR(*s
))
1645 /* Update complete filename. */
1646 strncpy (path_up
, fname
, PATH_MAX
);
1647 path_up
[PATH_MAX
] = '\0';
1655 if (with_line_numbers
)
1657 if (functionname
!= NULL
1658 && (prev_functionname
== NULL
1659 || strcmp (functionname
, prev_functionname
) != 0))
1661 printf ("%s():\n", sanitize_string (functionname
));
1665 && (linenumber
!= prev_line
1666 || discriminator
!= prev_discriminator
))
1668 if (discriminator
> 0)
1669 printf ("%s:%u (discriminator %u)\n",
1670 filename
== NULL
? "???" : sanitize_string (filename
),
1671 linenumber
, discriminator
);
1673 printf ("%s:%u\n", filename
== NULL
1674 ? "???" : sanitize_string (filename
),
1679 const char *filename2
;
1680 const char *functionname2
;
1683 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1686 printf ("inlined by %s:%u",
1687 sanitize_string (filename2
), line2
);
1688 printf (" (%s)\n", sanitize_string (functionname2
));
1693 if (with_source_code
1697 struct print_file_list
**pp
, *p
;
1700 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1701 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1708 filename
= xstrdup (filename
);
1709 p
= update_source_path (filename
, abfd
);
1712 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1714 if (file_start_context
&& p
->first
)
1718 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1719 if (l
>= linenumber
)
1721 if (p
->max_printed
>= l
)
1723 if (p
->max_printed
< linenumber
)
1724 l
= p
->max_printed
+ 1;
1729 dump_lines (p
, l
, linenumber
);
1730 if (p
->max_printed
< linenumber
)
1731 p
->max_printed
= linenumber
;
1732 p
->last_line
= linenumber
;
1737 if (functionname
!= NULL
1738 && (prev_functionname
== NULL
1739 || strcmp (functionname
, prev_functionname
) != 0))
1741 if (prev_functionname
!= NULL
)
1742 free (prev_functionname
);
1743 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1744 strcpy (prev_functionname
, functionname
);
1747 if (linenumber
> 0 && linenumber
!= prev_line
)
1748 prev_line
= linenumber
;
1750 if (discriminator
!= prev_discriminator
)
1751 prev_discriminator
= discriminator
;
1757 /* Pseudo FILE object for strings. */
1765 /* sprintf to a "stream". */
1767 static int ATTRIBUTE_PRINTF_2
1768 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1775 size_t space
= f
->alloc
- f
->pos
;
1777 va_start (args
, format
);
1778 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1784 f
->alloc
= (f
->alloc
+ n
) * 2;
1785 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1792 /* The number of zeroes we want to see before we start skipping them.
1793 The number is arbitrarily chosen. */
1795 #define DEFAULT_SKIP_ZEROES 8
1797 /* The number of zeroes to skip at the end of a section. If the
1798 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1799 SKIP_ZEROES, they will be disassembled. If there are fewer than
1800 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1801 attempt to avoid disassembling zeroes inserted by section
1804 #define DEFAULT_SKIP_ZEROES_AT_END 3
1806 /* Disassemble some data in memory between given values. */
1809 disassemble_bytes (struct disassemble_info
* inf
,
1810 disassembler_ftype disassemble_fn
,
1813 bfd_vma start_offset
,
1814 bfd_vma stop_offset
,
1817 arelent
** relppend
)
1819 struct objdump_disasm_info
*aux
;
1821 int octets_per_line
;
1822 int skip_addr_chars
;
1823 bfd_vma addr_offset
;
1824 unsigned int opb
= inf
->octets_per_byte
;
1825 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1826 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1830 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1834 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1838 octets_per_line
= insn_width
;
1840 octets_per_line
= 4;
1842 octets_per_line
= 16;
1844 /* Figure out how many characters to skip at the start of an
1845 address, to make the disassembly look nicer. We discard leading
1846 zeroes in chunks of 4, ensuring that there is always a leading
1848 skip_addr_chars
= 0;
1849 if (! prefix_addresses
)
1853 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1855 while (buf
[skip_addr_chars
] == '0')
1858 /* Don't discard zeros on overflow. */
1859 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1860 skip_addr_chars
= 0;
1862 if (skip_addr_chars
!= 0)
1863 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1866 inf
->insn_info_valid
= 0;
1868 addr_offset
= start_offset
;
1869 while (addr_offset
< stop_offset
)
1872 bfd_boolean need_nl
= FALSE
;
1873 int previous_octets
;
1875 /* Remember the length of the previous instruction. */
1876 previous_octets
= octets
;
1879 /* Make sure we don't use relocs from previous instructions. */
1882 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1884 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1887 if (! disassemble_zeroes
1888 && (inf
->insn_info_valid
== 0
1889 || inf
->branch_delay_insns
== 0)
1890 && (z
- addr_offset
* opb
>= skip_zeroes
1891 || (z
== stop_offset
* opb
&&
1892 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1894 /* If there are more nonzero octets to follow, we only skip
1895 zeroes in multiples of 4, to try to avoid running over
1896 the start of an instruction which happens to start with
1898 if (z
!= stop_offset
* opb
)
1899 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1901 octets
= z
- addr_offset
* opb
;
1903 /* If we are going to display more data, and we are displaying
1904 file offsets, then tell the user how many zeroes we skip
1905 and the file offset from where we resume dumping. */
1906 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1907 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1909 (unsigned long) (section
->filepos
1910 + (addr_offset
+ (octets
/ opb
))));
1920 if (with_line_numbers
|| with_source_code
)
1921 show_line (aux
->abfd
, section
, addr_offset
);
1923 if (! prefix_addresses
)
1927 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1928 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1932 printf ("%s:\t", buf
+ skip_addr_chars
);
1936 aux
->require_sec
= TRUE
;
1937 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1938 aux
->require_sec
= FALSE
;
1945 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1946 inf
->stream
= &sfile
;
1947 inf
->bytes_per_line
= 0;
1948 inf
->bytes_per_chunk
= 0;
1949 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1950 | (wide_output
? WIDE_OUTPUT
: 0));
1952 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1954 if (inf
->disassembler_needs_relocs
1955 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1956 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1957 && *relppp
< relppend
)
1959 bfd_signed_vma distance_to_rel
;
1961 distance_to_rel
= (**relppp
)->address
1962 - (rel_offset
+ addr_offset
);
1964 /* Check to see if the current reloc is associated with
1965 the instruction that we are about to disassemble. */
1966 if (distance_to_rel
== 0
1967 /* FIXME: This is wrong. We are trying to catch
1968 relocs that are addressed part way through the
1969 current instruction, as might happen with a packed
1970 VLIW instruction. Unfortunately we do not know the
1971 length of the current instruction since we have not
1972 disassembled it yet. Instead we take a guess based
1973 upon the length of the previous instruction. The
1974 proper solution is to have a new target-specific
1975 disassembler function which just returns the length
1976 of an instruction at a given address without trying
1977 to display its disassembly. */
1978 || (distance_to_rel
> 0
1979 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1981 inf
->flags
|= INSN_HAS_RELOC
;
1982 aux
->reloc
= **relppp
;
1986 if (! disassemble_all
1987 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1988 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1989 /* Set a stop_vma so that the disassembler will not read
1990 beyond the next symbol. We assume that symbols appear on
1991 the boundaries between instructions. We only do this when
1992 disassembling code of course, and when -D is in effect. */
1993 inf
->stop_vma
= section
->vma
+ stop_offset
;
1995 inf
->stop_offset
= stop_offset
;
1996 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1999 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2000 inf
->stream
= stdout
;
2001 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2002 octets_per_line
= inf
->bytes_per_line
;
2003 if (octets
< (int) opb
)
2006 printf ("%s\n", sfile
.buffer
);
2009 non_fatal (_("disassemble_fn returned length %d"),
2020 octets
= octets_per_line
;
2021 if (addr_offset
+ octets
/ opb
> stop_offset
)
2022 octets
= (stop_offset
- addr_offset
) * opb
;
2024 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2026 if (ISPRINT (data
[j
]))
2027 buf
[j
- addr_offset
* opb
] = data
[j
];
2029 buf
[j
- addr_offset
* opb
] = '.';
2031 buf
[j
- addr_offset
* opb
] = '\0';
2034 if (prefix_addresses
2036 : show_raw_insn
>= 0)
2040 /* If ! prefix_addresses and ! wide_output, we print
2041 octets_per_line octets per line. */
2043 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2044 pb
= octets_per_line
;
2046 if (inf
->bytes_per_chunk
)
2047 bpc
= inf
->bytes_per_chunk
;
2051 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2053 /* PR 21580: Check for a buffer ending early. */
2054 if (j
+ bpc
<= stop_offset
* opb
)
2058 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2060 for (k
= bpc
- 1; k
>= 0; k
--)
2061 printf ("%02x", (unsigned) data
[j
+ k
]);
2065 for (k
= 0; k
< bpc
; k
++)
2066 printf ("%02x", (unsigned) data
[j
+ k
]);
2072 for (; pb
< octets_per_line
; pb
+= bpc
)
2076 for (k
= 0; k
< bpc
; k
++)
2081 /* Separate raw data from instruction by extra space. */
2091 printf ("%s", sfile
.buffer
);
2093 if (prefix_addresses
2095 : show_raw_insn
>= 0)
2103 j
= addr_offset
* opb
+ pb
;
2105 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2106 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2110 printf ("%s:\t", buf
+ skip_addr_chars
);
2112 pb
+= octets_per_line
;
2115 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2117 /* PR 21619: Check for a buffer ending early. */
2118 if (j
+ bpc
<= stop_offset
* opb
)
2122 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2124 for (k
= bpc
- 1; k
>= 0; k
--)
2125 printf ("%02x", (unsigned) data
[j
+ k
]);
2129 for (k
= 0; k
< bpc
; k
++)
2130 printf ("%02x", (unsigned) data
[j
+ k
]);
2144 while ((*relppp
) < relppend
2145 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2147 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2158 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2161 if (q
->howto
== NULL
)
2162 printf (": *unknown*\t");
2163 else if (q
->howto
->name
)
2164 printf (": %s\t", q
->howto
->name
);
2166 printf (": %d\t", q
->howto
->type
);
2168 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2169 printf ("*unknown*");
2172 const char *sym_name
;
2174 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2175 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2176 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2181 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2182 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2183 if (sym_name
== NULL
|| *sym_name
== '\0')
2184 sym_name
= "*unknown*";
2185 printf ("%s", sanitize_string (sym_name
));
2191 bfd_signed_vma addend
= q
->addend
;
2199 objdump_print_value (addend
, inf
, TRUE
);
2211 addr_offset
+= octets
/ opb
;
2214 free (sfile
.buffer
);
2218 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2220 const struct elf_backend_data
* bed
;
2221 bfd_vma sign_adjust
= 0;
2222 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2223 struct objdump_disasm_info
* paux
;
2224 unsigned int opb
= pinfo
->octets_per_byte
;
2225 bfd_byte
* data
= NULL
;
2226 bfd_size_type datasize
= 0;
2227 arelent
** rel_pp
= NULL
;
2228 arelent
** rel_ppstart
= NULL
;
2229 arelent
** rel_ppend
;
2230 bfd_vma stop_offset
;
2231 asymbol
* sym
= NULL
;
2235 unsigned long addr_offset
;
2236 bfd_boolean do_print
;
2239 stop_offset_reached
,
2244 /* Sections that do not contain machine
2245 code are not normally disassembled. */
2246 if (! disassemble_all
2247 && only_list
== NULL
2248 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2249 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2252 if (! process_section_p (section
))
2255 datasize
= bfd_get_section_size (section
);
2259 if (start_address
== (bfd_vma
) -1
2260 || start_address
< section
->vma
)
2263 addr_offset
= start_address
- section
->vma
;
2265 if (stop_address
== (bfd_vma
) -1)
2266 stop_offset
= datasize
/ opb
;
2269 if (stop_address
< section
->vma
)
2272 stop_offset
= stop_address
- section
->vma
;
2273 if (stop_offset
> datasize
/ opb
)
2274 stop_offset
= datasize
/ opb
;
2277 if (addr_offset
>= stop_offset
)
2280 /* Decide which set of relocs to use. Load them if necessary. */
2281 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2282 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2284 rel_pp
= paux
->dynrelbuf
;
2285 rel_count
= paux
->dynrelcount
;
2286 /* Dynamic reloc addresses are absolute, non-dynamic are section
2287 relative. REL_OFFSET specifies the reloc address corresponding
2288 to the start of this section. */
2289 rel_offset
= section
->vma
;
2297 if ((section
->flags
& SEC_RELOC
) != 0
2298 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2302 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2304 bfd_fatal (bfd_get_filename (abfd
));
2308 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2309 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2311 bfd_fatal (bfd_get_filename (abfd
));
2313 /* Sort the relocs by address. */
2314 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2318 rel_ppend
= rel_pp
+ rel_count
;
2320 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2322 non_fatal (_("Reading section %s failed because: %s"),
2323 section
->name
, bfd_errmsg (bfd_get_error ()));
2327 paux
->sec
= section
;
2328 pinfo
->buffer
= data
;
2329 pinfo
->buffer_vma
= section
->vma
;
2330 pinfo
->buffer_length
= datasize
;
2331 pinfo
->section
= section
;
2333 /* Skip over the relocs belonging to addresses below the
2335 while (rel_pp
< rel_ppend
2336 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2339 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2341 /* Find the nearest symbol forwards from our current position. */
2342 paux
->require_sec
= TRUE
;
2343 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2344 (struct disassemble_info
*) inf
,
2346 paux
->require_sec
= FALSE
;
2348 /* PR 9774: If the target used signed addresses then we must make
2349 sure that we sign extend the value that we calculate for 'addr'
2350 in the loop below. */
2351 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2352 && (bed
= get_elf_backend_data (abfd
)) != NULL
2353 && bed
->sign_extend_vma
)
2354 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2356 /* Disassemble a block of instructions up to the address associated with
2357 the symbol we have just found. Then print the symbol and find the
2358 next symbol on. Repeat until we have disassembled the entire section
2359 or we have reached the end of the address range we are interested in. */
2360 do_print
= paux
->symbol
== NULL
;
2361 loop_until
= stop_offset_reached
;
2363 while (addr_offset
< stop_offset
)
2367 bfd_vma nextstop_offset
;
2370 addr
= section
->vma
+ addr_offset
;
2371 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2373 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2378 (x
< sorted_symcount
2379 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2383 pinfo
->symbols
= sorted_syms
+ place
;
2384 pinfo
->num_symbols
= x
- place
;
2385 pinfo
->symtab_pos
= place
;
2389 pinfo
->symbols
= NULL
;
2390 pinfo
->num_symbols
= 0;
2391 pinfo
->symtab_pos
= -1;
2394 /* If we are only disassembling from a specific symbol,
2395 check to see if we should start or stop displaying. */
2396 if (sym
&& paux
->symbol
)
2400 /* See if we should stop printing. */
2404 if (sym
->flags
& BSF_FUNCTION
)
2408 case stop_offset_reached
:
2409 /* Handled by the while loop. */
2413 /* FIXME: There is an implicit assumption here
2414 that the name of sym is different from
2416 if (! bfd_is_local_label (abfd
, sym
))
2423 const char * name
= bfd_asymbol_name (sym
);
2424 char * alloc
= NULL
;
2426 if (do_demangle
&& name
[0] != '\0')
2428 /* Demangle the name. */
2429 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2434 /* We are not currently printing. Check to see
2435 if the current symbol matches the requested symbol. */
2436 if (streq (name
, paux
->symbol
))
2440 if (sym
->flags
& BSF_FUNCTION
)
2442 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2443 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2445 /* Sym is a function symbol with a size associated
2446 with it. Turn on automatic disassembly for the
2447 next VALUE bytes. */
2448 stop_offset
= addr_offset
2449 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2450 loop_until
= stop_offset_reached
;
2454 /* Otherwise we need to tell the loop heuristic to
2455 loop until the next function symbol is encountered. */
2456 loop_until
= function_sym
;
2461 /* Otherwise loop until the next symbol is encountered. */
2462 loop_until
= next_sym
;
2470 if (! prefix_addresses
&& do_print
)
2472 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2473 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2475 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2478 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2480 else if (sym
== NULL
)
2484 #define is_valid_next_sym(SYM) \
2485 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2486 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2487 && pinfo->symbol_is_valid (SYM, pinfo))
2489 /* Search forward for the next appropriate symbol in
2490 SECTION. Note that all the symbols are sorted
2491 together into one big array, and that some sections
2492 may have overlapping addresses. */
2493 while (place
< sorted_symcount
2494 && ! is_valid_next_sym (sorted_syms
[place
]))
2497 if (place
>= sorted_symcount
)
2500 nextsym
= sorted_syms
[place
];
2503 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2504 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2505 else if (nextsym
== NULL
)
2506 nextstop_offset
= stop_offset
;
2508 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2510 if (nextstop_offset
> stop_offset
2511 || nextstop_offset
<= addr_offset
)
2512 nextstop_offset
= stop_offset
;
2514 /* If a symbol is explicitly marked as being an object
2515 rather than a function, just dump the bytes without
2516 disassembling them. */
2519 || sym
->section
!= section
2520 || bfd_asymbol_value (sym
) > addr
2521 || ((sym
->flags
& BSF_OBJECT
) == 0
2522 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2524 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2526 || (sym
->flags
& BSF_FUNCTION
) != 0)
2532 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2533 addr_offset
, nextstop_offset
,
2534 rel_offset
, &rel_pp
, rel_ppend
);
2536 addr_offset
= nextstop_offset
;
2542 if (rel_ppstart
!= NULL
)
2546 /* Disassemble the contents of an object file. */
2549 disassemble_data (bfd
*abfd
)
2551 struct disassemble_info disasm_info
;
2552 struct objdump_disasm_info aux
;
2556 prev_functionname
= NULL
;
2558 prev_discriminator
= 0;
2560 /* We make a copy of syms to sort. We don't want to sort syms
2561 because that will screw up the relocs. */
2562 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2563 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2564 * sizeof (asymbol
*));
2565 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2566 sorted_symcount
* sizeof (asymbol
*));
2568 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2570 for (i
= 0; i
< synthcount
; ++i
)
2572 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2576 /* Sort the symbols into section and symbol order. */
2577 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2579 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2581 disasm_info
.application_data
= (void *) &aux
;
2583 aux
.require_sec
= FALSE
;
2584 aux
.dynrelbuf
= NULL
;
2585 aux
.dynrelcount
= 0;
2587 aux
.symbol
= disasm_sym
;
2589 disasm_info
.print_address_func
= objdump_print_address
;
2590 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2592 if (machine
!= NULL
)
2594 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2597 fatal (_("can't use supplied machine %s"), machine
);
2599 abfd
->arch_info
= inf
;
2602 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2604 struct bfd_target
*xvec
;
2606 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2607 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2608 xvec
->byteorder
= endian
;
2612 /* Use libopcodes to locate a suitable disassembler. */
2613 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2614 bfd_big_endian (abfd
),
2615 bfd_get_mach (abfd
), abfd
);
2616 if (!aux
.disassemble_fn
)
2618 non_fatal (_("can't disassemble for architecture %s\n"),
2619 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2624 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2625 disasm_info
.arch
= bfd_get_arch (abfd
);
2626 disasm_info
.mach
= bfd_get_mach (abfd
);
2627 disasm_info
.disassembler_options
= disassembler_options
;
2628 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2629 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2630 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2631 disasm_info
.disassembler_needs_relocs
= FALSE
;
2633 if (bfd_big_endian (abfd
))
2634 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2635 else if (bfd_little_endian (abfd
))
2636 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2638 /* ??? Aborting here seems too drastic. We could default to big or little
2640 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2642 /* Allow the target to customize the info structure. */
2643 disassemble_init_for_target (& disasm_info
);
2645 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2647 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2649 if (relsize
< 0 && dump_dynamic_reloc_info
)
2650 bfd_fatal (bfd_get_filename (abfd
));
2654 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2655 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2658 if (aux
.dynrelcount
< 0)
2659 bfd_fatal (bfd_get_filename (abfd
));
2661 /* Sort the relocs by address. */
2662 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2666 disasm_info
.symtab
= sorted_syms
;
2667 disasm_info
.symtab_size
= sorted_symcount
;
2669 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2671 if (aux
.dynrelbuf
!= NULL
)
2672 free (aux
.dynrelbuf
);
2677 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2678 asection
*sec
, void *file
)
2680 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2681 bfd
*abfd
= (bfd
*) file
;
2686 if (section
->start
!= NULL
)
2688 /* If it is already loaded, do nothing. */
2689 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2691 free (section
->start
);
2694 section
->filename
= bfd_get_filename (abfd
);
2695 section
->reloc_info
= NULL
;
2696 section
->num_relocs
= 0;
2697 section
->address
= bfd_get_section_vma (abfd
, sec
);
2698 section
->user_data
= sec
;
2699 section
->size
= bfd_get_section_size (sec
);
2700 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2701 alloced
= amt
= section
->size
+ 1;
2702 if (alloced
!= amt
|| alloced
== 0)
2704 section
->start
= NULL
;
2705 free_debug_section (debug
);
2706 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2707 sanitize_string (section
->name
),
2708 (unsigned long long) section
->size
);
2711 section
->start
= contents
= malloc (alloced
);
2712 if (section
->start
== NULL
2713 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2715 free_debug_section (debug
);
2716 printf (_("\nCan't get contents for section '%s'.\n"),
2717 sanitize_string (section
->name
));
2720 /* Ensure any string section has a terminating NUL. */
2721 section
->start
[section
->size
] = 0;
2723 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2728 bfd_cache_section_contents (sec
, section
->start
);
2730 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2737 free_debug_section (debug
);
2738 printf (_("\nCan't get contents for section '%s'.\n"),
2739 sanitize_string (section
->name
));
2743 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2746 unsigned long reloc_count
;
2749 relocs
= (arelent
**) xmalloc (reloc_size
);
2751 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2752 if (reloc_count
== 0)
2756 section
->reloc_info
= relocs
;
2757 section
->num_relocs
= reloc_count
;
2766 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2771 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2774 relocs
= (arelent
**) dsec
->reloc_info
;
2776 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2777 if (rp
->address
== offset
)
2784 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2786 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2787 bfd
*abfd
= (bfd
*) file
;
2790 /* If it is already loaded, do nothing. */
2791 if (section
->start
!= NULL
)
2793 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2797 /* Locate the debug section. */
2798 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2800 section
->name
= section
->uncompressed_name
;
2803 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2805 section
->name
= section
->compressed_name
;
2810 return load_specific_debug_section (debug
, sec
, file
);
2814 free_debug_section (enum dwarf_section_display_enum debug
)
2816 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2818 if (section
->start
== NULL
)
2821 /* PR 17512: file: 0f67f69d. */
2822 if (section
->user_data
!= NULL
)
2824 asection
* sec
= (asection
*) section
->user_data
;
2826 /* If we are freeing contents that are also pointed to by the BFD
2827 library's section structure then make sure to update those pointers
2828 too. Otherwise, the next time we try to load data for this section
2829 we can end up using a stale pointer. */
2830 if (section
->start
== sec
->contents
)
2832 sec
->contents
= NULL
;
2833 sec
->flags
&= ~ SEC_IN_MEMORY
;
2834 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2838 free ((char *) section
->start
);
2839 section
->start
= NULL
;
2840 section
->address
= 0;
2845 close_debug_file (void * file
)
2847 bfd
* abfd
= (bfd
*) file
;
2853 open_debug_file (const char * pathname
)
2857 data
= bfd_openr (pathname
, NULL
);
2861 if (! bfd_check_format (data
, bfd_object
))
2868 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2869 void *arg ATTRIBUTE_UNUSED
)
2871 const char *name
= bfd_get_section_name (abfd
, section
);
2875 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2876 match
= ".debug_info";
2880 for (i
= 0; i
< max
; i
++)
2881 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2882 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2883 && debug_displays
[i
].enabled
!= NULL
2884 && *debug_displays
[i
].enabled
)
2886 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2888 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2889 sec
->name
= sec
->uncompressed_name
;
2891 sec
->name
= sec
->compressed_name
;
2892 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2895 debug_displays
[i
].display (sec
, abfd
);
2897 if (i
!= info
&& i
!= abbrev
)
2898 free_debug_section ((enum dwarf_section_display_enum
) i
);
2904 /* Dump the dwarf debugging information. */
2907 dump_dwarf (bfd
*abfd
)
2909 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2910 if (byte_get
== NULL
)
2912 warn (_("File %s does not contain any dwarf debug information\n"),
2913 bfd_get_filename (abfd
));
2917 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2919 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2921 switch (bfd_get_arch (abfd
))
2924 switch (bfd_get_mach (abfd
))
2926 case bfd_mach_x86_64
:
2927 case bfd_mach_x86_64_intel_syntax
:
2928 case bfd_mach_x86_64_nacl
:
2929 case bfd_mach_x64_32
:
2930 case bfd_mach_x64_32_intel_syntax
:
2931 case bfd_mach_x64_32_nacl
:
2932 init_dwarf_regnames_x86_64 ();
2936 init_dwarf_regnames_i386 ();
2941 case bfd_arch_iamcu
:
2942 init_dwarf_regnames_iamcu ();
2945 case bfd_arch_aarch64
:
2946 init_dwarf_regnames_aarch64();
2950 init_dwarf_regnames_s390 ();
2953 case bfd_arch_riscv
:
2954 init_dwarf_regnames_riscv ();
2958 /* S12Z has a 24 bit address space. But the only known
2959 producer of dwarf_info encodes addresses into 32 bits. */
2967 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2970 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2971 it. Return NULL on failure. */
2974 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2979 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2980 if (stabsect
== NULL
)
2982 printf (_("No %s section present\n\n"),
2983 sanitize_string (sect_name
));
2987 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2989 non_fatal (_("reading %s section of %s failed: %s"),
2990 sect_name
, bfd_get_filename (abfd
),
2991 bfd_errmsg (bfd_get_error ()));
2997 *size_ptr
= bfd_section_size (abfd
, stabsect
);
3002 /* Stabs entries use a 12 byte format:
3003 4 byte string table index
3005 1 byte stab other field
3006 2 byte stab desc field
3008 FIXME: This will have to change for a 64 bit object format. */
3010 #define STRDXOFF (0)
3012 #define OTHEROFF (5)
3015 #define STABSIZE (12)
3017 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3018 using string table section STRSECT_NAME (in `strtab'). */
3021 print_section_stabs (bfd
*abfd
,
3022 const char *stabsect_name
,
3023 unsigned *string_offset_ptr
)
3026 unsigned file_string_table_offset
= 0;
3027 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3028 bfd_byte
*stabp
, *stabs_end
;
3031 stabs_end
= stabp
+ stab_size
;
3033 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3034 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3036 /* Loop through all symbols and print them.
3038 We start the index at -1 because there is a dummy symbol on
3039 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3040 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3044 unsigned char type
, other
;
3045 unsigned short desc
;
3048 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3049 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3050 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3051 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3052 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3054 printf ("\n%-6d ", i
);
3055 /* Either print the stab name, or, if unnamed, print its number
3056 again (makes consistent formatting for tools like awk). */
3057 name
= bfd_get_stab_name (type
);
3059 printf ("%-6s", sanitize_string (name
));
3060 else if (type
== N_UNDF
)
3063 printf ("%-6d", type
);
3064 printf (" %-6d %-6d ", other
, desc
);
3065 bfd_printf_vma (abfd
, value
);
3066 printf (" %-6lu", strx
);
3068 /* Symbols with type == 0 (N_UNDF) specify the length of the
3069 string table associated with this file. We use that info
3070 to know how to relocate the *next* file's string table indices. */
3073 file_string_table_offset
= next_file_string_table_offset
;
3074 next_file_string_table_offset
+= value
;
3078 bfd_size_type amt
= strx
+ file_string_table_offset
;
3080 /* Using the (possibly updated) string table offset, print the
3081 string (if any) associated with this symbol. */
3082 if (amt
< stabstr_size
)
3083 /* PR 17512: file: 079-79389-0.001:0.1.
3084 FIXME: May need to sanitize this string before displaying. */
3085 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3091 *string_offset_ptr
= next_file_string_table_offset
;
3096 const char * section_name
;
3097 const char * string_section_name
;
3098 unsigned string_offset
;
3103 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3106 stab_section_names
* sought
= (stab_section_names
*) names
;
3108 /* Check for section names for which stabsect_name is a prefix, to
3109 handle .stab.N, etc. */
3110 len
= strlen (sought
->section_name
);
3112 /* If the prefix matches, and the files section name ends with a
3113 nul or a digit, then we match. I.e., we want either an exact
3114 match or a section followed by a number. */
3115 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3116 && (section
->name
[len
] == 0
3117 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3120 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3125 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
3127 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3133 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3135 stab_section_names s
;
3137 s
.section_name
= stabsect_name
;
3138 s
.string_section_name
= strsect_name
;
3139 s
.string_offset
= 0;
3141 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3147 /* Dump the any sections containing stabs debugging information. */
3150 dump_stabs (bfd
*abfd
)
3152 dump_stabs_section (abfd
, ".stab", ".stabstr");
3153 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3154 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3157 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3159 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3163 dump_bfd_header (bfd
*abfd
)
3167 printf (_("architecture: %s, "),
3168 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3169 bfd_get_mach (abfd
)));
3170 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3172 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3173 PF (HAS_RELOC
, "HAS_RELOC");
3174 PF (EXEC_P
, "EXEC_P");
3175 PF (HAS_LINENO
, "HAS_LINENO");
3176 PF (HAS_DEBUG
, "HAS_DEBUG");
3177 PF (HAS_SYMS
, "HAS_SYMS");
3178 PF (HAS_LOCALS
, "HAS_LOCALS");
3179 PF (DYNAMIC
, "DYNAMIC");
3180 PF (WP_TEXT
, "WP_TEXT");
3181 PF (D_PAGED
, "D_PAGED");
3182 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3183 printf (_("\nstart address 0x"));
3184 bfd_printf_vma (abfd
, abfd
->start_address
);
3190 dump_bfd_private_header (bfd
*abfd
)
3192 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3193 non_fatal (_("warning: private headers incomplete: %s"),
3194 bfd_errmsg (bfd_get_error ()));
3198 dump_target_specific (bfd
*abfd
)
3200 const struct objdump_private_desc
* const *desc
;
3201 struct objdump_private_option
*opt
;
3204 /* Find the desc. */
3205 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3206 if ((*desc
)->filter (abfd
))
3211 non_fatal (_("option -P/--private not supported by this file"));
3215 /* Clear all options. */
3216 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3217 opt
->selected
= FALSE
;
3219 /* Decode options. */
3220 b
= dump_private_options
;
3223 e
= strchr (b
, ',');
3228 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3229 if (strcmp (opt
->name
, b
) == 0)
3231 opt
->selected
= TRUE
;
3234 if (opt
->name
== NULL
)
3235 non_fatal (_("target specific dump '%s' not supported"), b
);
3246 (*desc
)->dump (abfd
);
3249 /* Display a section in hexadecimal format with associated characters.
3250 Each line prefixed by the zero padded address. */
3253 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3255 bfd_byte
*data
= NULL
;
3256 bfd_size_type datasize
;
3257 bfd_vma addr_offset
;
3258 bfd_vma start_offset
;
3259 bfd_vma stop_offset
;
3260 unsigned int opb
= bfd_octets_per_byte (abfd
);
3261 /* Bytes per line. */
3262 const int onaline
= 16;
3267 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3270 if (! process_section_p (section
))
3273 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3276 /* Compute the address range to display. */
3277 if (start_address
== (bfd_vma
) -1
3278 || start_address
< section
->vma
)
3281 start_offset
= start_address
- section
->vma
;
3283 if (stop_address
== (bfd_vma
) -1)
3284 stop_offset
= datasize
/ opb
;
3287 if (stop_address
< section
->vma
)
3290 stop_offset
= stop_address
- section
->vma
;
3292 if (stop_offset
> datasize
/ opb
)
3293 stop_offset
= datasize
/ opb
;
3296 if (start_offset
>= stop_offset
)
3299 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3300 if (display_file_offsets
)
3301 printf (_(" (Starting at file offset: 0x%lx)"),
3302 (unsigned long) (section
->filepos
+ start_offset
));
3305 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3307 non_fatal (_("Reading section %s failed because: %s"),
3308 section
->name
, bfd_errmsg (bfd_get_error ()));
3314 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3315 if (strlen (buf
) >= sizeof (buf
))
3319 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3321 count
= strlen (buf
) - count
;
3325 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3326 if (strlen (buf
) >= sizeof (buf
))
3330 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3332 count
= strlen (buf
) - count
;
3336 for (addr_offset
= start_offset
;
3337 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3341 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3342 count
= strlen (buf
);
3343 if ((size_t) count
>= sizeof (buf
))
3347 while (count
< width
)
3352 fputs (buf
+ count
- width
, stdout
);
3355 for (j
= addr_offset
* opb
;
3356 j
< addr_offset
* opb
+ onaline
; j
++)
3358 if (j
< stop_offset
* opb
)
3359 printf ("%02x", (unsigned) (data
[j
]));
3367 for (j
= addr_offset
* opb
;
3368 j
< addr_offset
* opb
+ onaline
; j
++)
3370 if (j
>= stop_offset
* opb
)
3373 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3380 /* Actually display the various requested regions. */
3383 dump_data (bfd
*abfd
)
3385 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3388 /* Should perhaps share code and display with nm? */
3391 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3400 max_count
= dynsymcount
;
3401 printf ("DYNAMIC SYMBOL TABLE:\n");
3406 max_count
= symcount
;
3407 printf ("SYMBOL TABLE:\n");
3411 printf (_("no symbols\n"));
3413 for (count
= 0; count
< max_count
; count
++)
3417 if (*current
== NULL
)
3418 printf (_("no information for symbol number %ld\n"), count
);
3420 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3421 printf (_("could not determine the type of symbol number %ld\n"),
3424 else if (process_section_p ((* current
)->section
)
3425 && (dump_special_syms
3426 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3428 const char *name
= (*current
)->name
;
3430 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3434 /* If we want to demangle the name, we demangle it
3435 here, and temporarily clobber it while calling
3436 bfd_print_symbol. FIXME: This is a gross hack. */
3437 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3439 (*current
)->name
= alloc
;
3440 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3441 bfd_print_symbol_all
);
3444 (*current
)->name
= name
;
3449 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3450 bfd_print_symbol_all
);
3460 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3463 char *last_filename
, *last_functionname
;
3464 unsigned int last_line
;
3465 unsigned int last_discriminator
;
3467 /* Get column headers lined up reasonably. */
3475 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3476 width
= strlen (buf
) - 7;
3478 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3481 last_filename
= NULL
;
3482 last_functionname
= NULL
;
3484 last_discriminator
= 0;
3486 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3489 const char *filename
, *functionname
;
3490 unsigned int linenumber
;
3491 unsigned int discriminator
;
3492 const char *sym_name
;
3493 const char *section_name
;
3494 bfd_vma addend2
= 0;
3496 if (start_address
!= (bfd_vma
) -1
3497 && q
->address
< start_address
)
3499 if (stop_address
!= (bfd_vma
) -1
3500 && q
->address
> stop_address
)
3503 if (with_line_numbers
3505 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3506 &filename
, &functionname
,
3507 &linenumber
, &discriminator
))
3509 if (functionname
!= NULL
3510 && (last_functionname
== NULL
3511 || strcmp (functionname
, last_functionname
) != 0))
3513 printf ("%s():\n", sanitize_string (functionname
));
3514 if (last_functionname
!= NULL
)
3515 free (last_functionname
);
3516 last_functionname
= xstrdup (functionname
);
3520 && (linenumber
!= last_line
3521 || (filename
!= NULL
3522 && last_filename
!= NULL
3523 && filename_cmp (filename
, last_filename
) != 0)
3524 || (discriminator
!= last_discriminator
)))
3526 if (discriminator
> 0)
3527 printf ("%s:%u\n", filename
== NULL
? "???" :
3528 sanitize_string (filename
), linenumber
);
3530 printf ("%s:%u (discriminator %u)\n",
3531 filename
== NULL
? "???" : sanitize_string (filename
),
3532 linenumber
, discriminator
);
3533 last_line
= linenumber
;
3534 last_discriminator
= discriminator
;
3535 if (last_filename
!= NULL
)
3536 free (last_filename
);
3537 if (filename
== NULL
)
3538 last_filename
= NULL
;
3540 last_filename
= xstrdup (filename
);
3544 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3546 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3547 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3552 section_name
= NULL
;
3555 bfd_printf_vma (abfd
, q
->address
);
3556 if (q
->howto
== NULL
)
3557 printf (" *unknown* ");
3558 else if (q
->howto
->name
)
3560 const char *name
= q
->howto
->name
;
3562 /* R_SPARC_OLO10 relocations contain two addends.
3563 But because 'arelent' lacks enough storage to
3564 store them both, the 64-bit ELF Sparc backend
3565 records this as two relocations. One R_SPARC_LO10
3566 and one R_SPARC_13, both pointing to the same
3567 address. This is merely so that we have some
3568 place to store both addend fields.
3570 Undo this transformation, otherwise the output
3571 will be confusing. */
3572 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3573 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3575 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3577 arelent
*q2
= *(p
+ 1);
3580 && q
->address
== q2
->address
3581 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3583 name
= "R_SPARC_OLO10";
3584 addend2
= q2
->addend
;
3588 printf (" %-16s ", name
);
3591 printf (" %-16d ", q
->howto
->type
);
3595 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3599 if (section_name
== NULL
)
3600 section_name
= "*unknown*";
3601 printf ("[%s]", sanitize_string (section_name
));
3606 bfd_signed_vma addend
= q
->addend
;
3614 bfd_printf_vma (abfd
, addend
);
3619 bfd_printf_vma (abfd
, addend2
);
3625 if (last_filename
!= NULL
)
3626 free (last_filename
);
3627 if (last_functionname
!= NULL
)
3628 free (last_functionname
);
3632 dump_relocs_in_section (bfd
*abfd
,
3634 void *dummy ATTRIBUTE_UNUSED
)
3636 arelent
**relpp
= NULL
;
3640 if ( bfd_is_abs_section (section
)
3641 || bfd_is_und_section (section
)
3642 || bfd_is_com_section (section
)
3643 || (! process_section_p (section
))
3644 || ((section
->flags
& SEC_RELOC
) == 0))
3647 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3649 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3652 printf (" (none)\n\n");
3660 relpp
= (arelent
**) xmalloc (relsize
);
3661 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3667 non_fatal (_("failed to read relocs in: %s"),
3668 sanitize_string (bfd_get_filename (abfd
)));
3669 bfd_fatal (_("error message was"));
3671 else if (relcount
== 0)
3672 printf (" (none)\n\n");
3676 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3683 dump_relocs (bfd
*abfd
)
3685 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3689 dump_dynamic_relocs (bfd
*abfd
)
3695 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3697 bfd_fatal (bfd_get_filename (abfd
));
3699 printf ("DYNAMIC RELOCATION RECORDS");
3702 printf (" (none)\n\n");
3705 relpp
= (arelent
**) xmalloc (relsize
);
3706 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3709 bfd_fatal (bfd_get_filename (abfd
));
3710 else if (relcount
== 0)
3711 printf (" (none)\n\n");
3715 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3722 /* Creates a table of paths, to search for source files. */
3725 add_include_path (const char *path
)
3729 include_path_count
++;
3730 include_paths
= (const char **)
3731 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3732 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3733 if (path
[1] == ':' && path
[2] == 0)
3734 path
= concat (path
, ".", (const char *) 0);
3736 include_paths
[include_path_count
- 1] = path
;
3740 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3744 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3746 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3747 section
->vma
+= adjust_section_vma
;
3749 section
->lma
+= adjust_section_vma
;
3753 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3756 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3761 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3762 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3765 /* Dump selected contents of ABFD. */
3768 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3770 const struct elf_backend_data
* bed
;
3772 if (bfd_big_endian (abfd
))
3773 byte_get
= byte_get_big_endian
;
3774 else if (bfd_little_endian (abfd
))
3775 byte_get
= byte_get_little_endian
;
3779 /* Load any separate debug information files.
3780 We do this now and without checking do_follow_links because separate
3781 debug info files may contain symbol tables that we will need when
3782 displaying information about the main file. Any memory allocated by
3783 load_separate_debug_files will be released when we call
3784 free_debug_memory below.
3786 The test on is_mainfile is there because the chain of separate debug
3787 info files is a global variable shared by all invocations of dump_bfd. */
3790 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3792 /* If asked to do so, recursively dump the separate files. */
3793 if (do_follow_links
)
3797 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3798 dump_bfd (i
->handle
, FALSE
);
3802 /* Adjust user-specified start and stop limits for targets that use
3803 signed addresses. */
3804 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3805 && (bed
= get_elf_backend_data (abfd
)) != NULL
3806 && bed
->sign_extend_vma
)
3808 start_address
= sign_extend_address (abfd
, start_address
,
3810 stop_address
= sign_extend_address (abfd
, stop_address
,
3814 /* If we are adjusting section VMA's, change them all now. Changing
3815 the BFD information is a hack. However, we must do it, or
3816 bfd_find_nearest_line will not do the right thing. */
3817 if (adjust_section_vma
!= 0)
3819 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3820 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3823 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3824 printf (_("\n%s: file format %s\n"),
3825 sanitize_string (bfd_get_filename (abfd
)),
3828 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3829 if (dump_file_header
)
3830 dump_bfd_header (abfd
);
3831 if (dump_private_headers
)
3832 dump_bfd_private_header (abfd
);
3833 if (dump_private_options
!= NULL
)
3834 dump_target_specific (abfd
);
3835 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3842 || dump_dwarf_section_info
)
3844 syms
= slurp_symtab (abfd
);
3846 /* If following links, load any symbol tables from the linked files as well. */
3847 if (do_follow_links
&& is_mainfile
)
3851 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3853 asymbol
** extra_syms
;
3854 long old_symcount
= symcount
;
3856 extra_syms
= slurp_symtab (i
->handle
);
3860 if (old_symcount
== 0)
3866 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
3867 memcpy (syms
+ old_symcount
,
3869 symcount
* sizeof (asymbol
*));
3873 symcount
+= old_symcount
;
3878 if (dump_section_headers
)
3879 dump_headers (abfd
);
3881 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3882 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3883 dynsyms
= slurp_dynamic_symtab (abfd
);
3887 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3888 dynsymcount
, dynsyms
, &synthsyms
);
3894 dump_symbols (abfd
, FALSE
);
3895 if (dump_dynamic_symtab
)
3896 dump_symbols (abfd
, TRUE
);
3897 if (dump_dwarf_section_info
)
3899 if (dump_stab_section_info
)
3901 if (dump_reloc_info
&& ! disassemble
)
3903 if (dump_dynamic_reloc_info
&& ! disassemble
)
3904 dump_dynamic_relocs (abfd
);
3905 if (dump_section_contents
)
3908 disassemble_data (abfd
);
3914 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3915 if (dhandle
!= NULL
)
3917 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3919 dump_debugging_tags
? TRUE
: FALSE
))
3921 non_fatal (_("%s: printing debugging information failed"),
3922 bfd_get_filename (abfd
));
3928 /* PR 6483: If there was no STABS debug info in the file, try
3930 else if (! dump_dwarf_section_info
)
3932 dwarf_select_sections_all ();
3960 free_debug_memory ();
3964 display_object_bfd (bfd
*abfd
)
3968 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3970 dump_bfd (abfd
, TRUE
);
3974 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3976 nonfatal (bfd_get_filename (abfd
));
3977 list_matching_formats (matching
);
3982 if (bfd_get_error () != bfd_error_file_not_recognized
)
3984 nonfatal (bfd_get_filename (abfd
));
3988 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3990 dump_bfd (abfd
, TRUE
);
3994 nonfatal (bfd_get_filename (abfd
));
3996 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3998 list_matching_formats (matching
);
4004 display_any_bfd (bfd
*file
, int level
)
4006 /* Decompress sections unless dumping the section contents. */
4007 if (!dump_section_contents
)
4008 file
->flags
|= BFD_DECOMPRESS
;
4010 /* If the file is an archive, process all of its elements. */
4011 if (bfd_check_format (file
, bfd_archive
))
4014 bfd
*last_arfile
= NULL
;
4017 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4018 else if (level
> 100)
4020 /* Prevent corrupted files from spinning us into an
4021 infinite loop. 100 is an arbitrary heuristic. */
4022 fatal (_("Archive nesting is too deep"));
4026 printf (_("In nested archive %s:\n"),
4027 sanitize_string (bfd_get_filename (file
)));
4031 bfd_set_error (bfd_error_no_error
);
4033 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4036 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4037 nonfatal (bfd_get_filename (file
));
4041 display_any_bfd (arfile
, level
+ 1);
4043 if (last_arfile
!= NULL
)
4045 bfd_close (last_arfile
);
4046 /* PR 17512: file: ac585d01. */
4047 if (arfile
== last_arfile
)
4053 last_arfile
= arfile
;
4056 if (last_arfile
!= NULL
)
4057 bfd_close (last_arfile
);
4060 display_object_bfd (file
);
4064 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4068 if (get_file_size (filename
) < 1)
4074 file
= bfd_openr (filename
, target
);
4077 nonfatal (filename
);
4081 display_any_bfd (file
, 0);
4083 /* This is an optimization to improve the speed of objdump, especially when
4084 dumping a file with lots of associated debug informatiom. Calling
4085 bfd_close on such a file can take a non-trivial amount of time as there
4086 are lots of lists to walk and buffers to free. This is only really
4087 necessary however if we are about to load another file and we need the
4088 memory back. Otherwise, if we are about to exit, then we can save (a lot
4089 of) time by only doing a quick close, and allowing the OS to reclaim the
4094 bfd_close_all_done (file
);
4098 main (int argc
, char **argv
)
4101 char *target
= default_target
;
4102 bfd_boolean seenflag
= FALSE
;
4104 #if defined (HAVE_SETLOCALE)
4105 #if defined (HAVE_LC_MESSAGES)
4106 setlocale (LC_MESSAGES
, "");
4108 setlocale (LC_CTYPE
, "");
4111 bindtextdomain (PACKAGE
, LOCALEDIR
);
4112 textdomain (PACKAGE
);
4114 program_name
= *argv
;
4115 xmalloc_set_program_name (program_name
);
4116 bfd_set_error_program_name (program_name
);
4118 START_PROGRESS (program_name
, 0);
4120 expandargv (&argc
, &argv
);
4122 if (bfd_init () != BFD_INIT_MAGIC
)
4123 fatal (_("fatal error: libbfd ABI mismatch"));
4124 set_default_bfd_target ();
4126 while ((c
= getopt_long (argc
, argv
,
4127 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4128 long_options
, (int *) 0))
4134 break; /* We've been given a long option. */
4141 if (disassembler_options
)
4142 /* Ignore potential memory leak for now. */
4143 options
= concat (disassembler_options
, ",",
4144 optarg
, (const char *) NULL
);
4147 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4154 display_file_offsets
= TRUE
;
4157 with_line_numbers
= TRUE
;
4166 enum demangling_styles style
;
4168 style
= cplus_demangle_name_to_style (optarg
);
4169 if (style
== unknown_demangling
)
4170 fatal (_("unknown demangling style `%s'"),
4173 cplus_demangle_set_style (style
);
4176 case OPTION_RECURSE_LIMIT
:
4177 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4179 case OPTION_NO_RECURSE_LIMIT
:
4180 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4183 do_wide
= wide_output
= TRUE
;
4185 case OPTION_ADJUST_VMA
:
4186 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4188 case OPTION_START_ADDRESS
:
4189 start_address
= parse_vma (optarg
, "--start-address");
4190 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4191 fatal (_("error: the start address should be before the end address"));
4193 case OPTION_STOP_ADDRESS
:
4194 stop_address
= parse_vma (optarg
, "--stop-address");
4195 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4196 fatal (_("error: the stop address should be after the start address"));
4200 prefix_length
= strlen (prefix
);
4201 /* Remove an unnecessary trailing '/' */
4202 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4205 case OPTION_PREFIX_STRIP
:
4206 prefix_strip
= atoi (optarg
);
4207 if (prefix_strip
< 0)
4208 fatal (_("error: prefix strip must be non-negative"));
4210 case OPTION_INSN_WIDTH
:
4211 insn_width
= strtoul (optarg
, NULL
, 0);
4212 if (insn_width
<= 0)
4213 fatal (_("error: instruction width must be positive"));
4215 case OPTION_INLINES
:
4216 unwind_inlines
= TRUE
;
4219 if (strcmp (optarg
, "B") == 0)
4220 endian
= BFD_ENDIAN_BIG
;
4221 else if (strcmp (optarg
, "L") == 0)
4222 endian
= BFD_ENDIAN_LITTLE
;
4225 nonfatal (_("unrecognized -E option"));
4230 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4231 endian
= BFD_ENDIAN_BIG
;
4232 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4233 endian
= BFD_ENDIAN_LITTLE
;
4236 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4243 dump_file_header
= TRUE
;
4247 formats_info
= TRUE
;
4251 add_include_path (optarg
);
4254 dump_private_headers
= TRUE
;
4258 dump_private_options
= optarg
;
4262 dump_private_headers
= TRUE
;
4264 dump_reloc_info
= TRUE
;
4265 dump_file_header
= TRUE
;
4266 dump_ar_hdrs
= TRUE
;
4267 dump_section_headers
= TRUE
;
4275 dump_dynamic_symtab
= TRUE
;
4281 disasm_sym
= optarg
;
4284 disassemble_zeroes
= TRUE
;
4288 disassemble_all
= TRUE
;
4293 with_source_code
= TRUE
;
4302 dump_debugging_tags
= 1;
4307 dump_dwarf_section_info
= TRUE
;
4310 dwarf_select_sections_by_letters (optarg
);
4312 dwarf_select_sections_all ();
4315 dump_dwarf_section_info
= TRUE
;
4318 dwarf_select_sections_by_names (optarg
);
4320 dwarf_select_sections_all ();
4322 case OPTION_DWARF_DEPTH
:
4325 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4328 case OPTION_DWARF_START
:
4331 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4332 suppress_bfd_header
= 1;
4335 case OPTION_DWARF_CHECK
:
4339 dump_stab_section_info
= TRUE
;
4343 dump_section_contents
= TRUE
;
4347 dump_reloc_info
= TRUE
;
4351 dump_dynamic_reloc_info
= TRUE
;
4355 dump_ar_hdrs
= TRUE
;
4359 dump_section_headers
= TRUE
;
4364 show_version
= TRUE
;
4370 /* No need to set seenflag or to break - usage() does not return. */
4377 print_version ("objdump");
4383 exit_status
= display_info ();
4387 display_file ("a.out", target
, TRUE
);
4389 for (; optind
< argc
;)
4391 display_file (argv
[optind
], target
, optind
== argc
- 1);
4398 END_PROGRESS (program_name
);