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;
1951 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1953 if (inf
->disassembler_needs_relocs
1954 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1955 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1956 && *relppp
< relppend
)
1958 bfd_signed_vma distance_to_rel
;
1960 distance_to_rel
= (**relppp
)->address
1961 - (rel_offset
+ addr_offset
);
1963 /* Check to see if the current reloc is associated with
1964 the instruction that we are about to disassemble. */
1965 if (distance_to_rel
== 0
1966 /* FIXME: This is wrong. We are trying to catch
1967 relocs that are addressed part way through the
1968 current instruction, as might happen with a packed
1969 VLIW instruction. Unfortunately we do not know the
1970 length of the current instruction since we have not
1971 disassembled it yet. Instead we take a guess based
1972 upon the length of the previous instruction. The
1973 proper solution is to have a new target-specific
1974 disassembler function which just returns the length
1975 of an instruction at a given address without trying
1976 to display its disassembly. */
1977 || (distance_to_rel
> 0
1978 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1980 inf
->flags
|= INSN_HAS_RELOC
;
1981 aux
->reloc
= **relppp
;
1985 if (! disassemble_all
1986 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1987 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1988 /* Set a stop_vma so that the disassembler will not read
1989 beyond the next symbol. We assume that symbols appear on
1990 the boundaries between instructions. We only do this when
1991 disassembling code of course, and when -D is in effect. */
1992 inf
->stop_vma
= section
->vma
+ stop_offset
;
1994 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1997 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1998 inf
->stream
= stdout
;
1999 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2000 octets_per_line
= inf
->bytes_per_line
;
2001 if (octets
< (int) opb
)
2004 printf ("%s\n", sfile
.buffer
);
2007 non_fatal (_("disassemble_fn returned length %d"),
2018 octets
= octets_per_line
;
2019 if (addr_offset
+ octets
/ opb
> stop_offset
)
2020 octets
= (stop_offset
- addr_offset
) * opb
;
2022 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2024 if (ISPRINT (data
[j
]))
2025 buf
[j
- addr_offset
* opb
] = data
[j
];
2027 buf
[j
- addr_offset
* opb
] = '.';
2029 buf
[j
- addr_offset
* opb
] = '\0';
2032 if (prefix_addresses
2034 : show_raw_insn
>= 0)
2038 /* If ! prefix_addresses and ! wide_output, we print
2039 octets_per_line octets per line. */
2041 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2042 pb
= octets_per_line
;
2044 if (inf
->bytes_per_chunk
)
2045 bpc
= inf
->bytes_per_chunk
;
2049 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2051 /* PR 21580: Check for a buffer ending early. */
2052 if (j
+ bpc
<= stop_offset
* opb
)
2056 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2058 for (k
= bpc
- 1; k
>= 0; k
--)
2059 printf ("%02x", (unsigned) data
[j
+ k
]);
2063 for (k
= 0; k
< bpc
; k
++)
2064 printf ("%02x", (unsigned) data
[j
+ k
]);
2070 for (; pb
< octets_per_line
; pb
+= bpc
)
2074 for (k
= 0; k
< bpc
; k
++)
2079 /* Separate raw data from instruction by extra space. */
2089 printf ("%s", sfile
.buffer
);
2091 if (prefix_addresses
2093 : show_raw_insn
>= 0)
2101 j
= addr_offset
* opb
+ pb
;
2103 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2104 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2108 printf ("%s:\t", buf
+ skip_addr_chars
);
2110 pb
+= octets_per_line
;
2113 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2115 /* PR 21619: Check for a buffer ending early. */
2116 if (j
+ bpc
<= stop_offset
* opb
)
2120 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2122 for (k
= bpc
- 1; k
>= 0; k
--)
2123 printf ("%02x", (unsigned) data
[j
+ k
]);
2127 for (k
= 0; k
< bpc
; k
++)
2128 printf ("%02x", (unsigned) data
[j
+ k
]);
2142 while ((*relppp
) < relppend
2143 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2145 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2156 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2159 if (q
->howto
== NULL
)
2160 printf (": *unknown*\t");
2161 else if (q
->howto
->name
)
2162 printf (": %s\t", q
->howto
->name
);
2164 printf (": %d\t", q
->howto
->type
);
2166 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2167 printf ("*unknown*");
2170 const char *sym_name
;
2172 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2173 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2174 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2179 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2180 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2181 if (sym_name
== NULL
|| *sym_name
== '\0')
2182 sym_name
= "*unknown*";
2183 printf ("%s", sanitize_string (sym_name
));
2189 bfd_signed_vma addend
= q
->addend
;
2197 objdump_print_value (addend
, inf
, TRUE
);
2209 addr_offset
+= octets
/ opb
;
2212 free (sfile
.buffer
);
2216 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2218 const struct elf_backend_data
* bed
;
2219 bfd_vma sign_adjust
= 0;
2220 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2221 struct objdump_disasm_info
* paux
;
2222 unsigned int opb
= pinfo
->octets_per_byte
;
2223 bfd_byte
* data
= NULL
;
2224 bfd_size_type datasize
= 0;
2225 arelent
** rel_pp
= NULL
;
2226 arelent
** rel_ppstart
= NULL
;
2227 arelent
** rel_ppend
;
2228 bfd_vma stop_offset
;
2229 asymbol
* sym
= NULL
;
2233 unsigned long addr_offset
;
2234 bfd_boolean do_print
;
2237 stop_offset_reached
,
2242 /* Sections that do not contain machine
2243 code are not normally disassembled. */
2244 if (! disassemble_all
2245 && only_list
== NULL
2246 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2247 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2250 if (! process_section_p (section
))
2253 datasize
= bfd_get_section_size (section
);
2257 if (start_address
== (bfd_vma
) -1
2258 || start_address
< section
->vma
)
2261 addr_offset
= start_address
- section
->vma
;
2263 if (stop_address
== (bfd_vma
) -1)
2264 stop_offset
= datasize
/ opb
;
2267 if (stop_address
< section
->vma
)
2270 stop_offset
= stop_address
- section
->vma
;
2271 if (stop_offset
> datasize
/ opb
)
2272 stop_offset
= datasize
/ opb
;
2275 if (addr_offset
>= stop_offset
)
2278 /* Decide which set of relocs to use. Load them if necessary. */
2279 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2280 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2282 rel_pp
= paux
->dynrelbuf
;
2283 rel_count
= paux
->dynrelcount
;
2284 /* Dynamic reloc addresses are absolute, non-dynamic are section
2285 relative. REL_OFFSET specifies the reloc address corresponding
2286 to the start of this section. */
2287 rel_offset
= section
->vma
;
2295 if ((section
->flags
& SEC_RELOC
) != 0
2296 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2300 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2302 bfd_fatal (bfd_get_filename (abfd
));
2306 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2307 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2309 bfd_fatal (bfd_get_filename (abfd
));
2311 /* Sort the relocs by address. */
2312 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2316 rel_ppend
= rel_pp
+ rel_count
;
2318 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2320 non_fatal (_("Reading section %s failed because: %s"),
2321 section
->name
, bfd_errmsg (bfd_get_error ()));
2325 paux
->sec
= section
;
2326 pinfo
->buffer
= data
;
2327 pinfo
->buffer_vma
= section
->vma
;
2328 pinfo
->buffer_length
= datasize
;
2329 pinfo
->section
= section
;
2331 /* Skip over the relocs belonging to addresses below the
2333 while (rel_pp
< rel_ppend
2334 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2337 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2339 /* Find the nearest symbol forwards from our current position. */
2340 paux
->require_sec
= TRUE
;
2341 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2342 (struct disassemble_info
*) inf
,
2344 paux
->require_sec
= FALSE
;
2346 /* PR 9774: If the target used signed addresses then we must make
2347 sure that we sign extend the value that we calculate for 'addr'
2348 in the loop below. */
2349 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2350 && (bed
= get_elf_backend_data (abfd
)) != NULL
2351 && bed
->sign_extend_vma
)
2352 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2354 /* Disassemble a block of instructions up to the address associated with
2355 the symbol we have just found. Then print the symbol and find the
2356 next symbol on. Repeat until we have disassembled the entire section
2357 or we have reached the end of the address range we are interested in. */
2358 do_print
= paux
->symbol
== NULL
;
2359 loop_until
= stop_offset_reached
;
2361 while (addr_offset
< stop_offset
)
2365 bfd_vma nextstop_offset
;
2368 addr
= section
->vma
+ addr_offset
;
2369 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2371 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2376 (x
< sorted_symcount
2377 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2381 pinfo
->symbols
= sorted_syms
+ place
;
2382 pinfo
->num_symbols
= x
- place
;
2383 pinfo
->symtab_pos
= place
;
2387 pinfo
->symbols
= NULL
;
2388 pinfo
->num_symbols
= 0;
2389 pinfo
->symtab_pos
= -1;
2392 /* If we are only disassembling from a specific symbol,
2393 check to see if we should start or stop displaying. */
2394 if (sym
&& paux
->symbol
)
2398 /* See if we should stop printing. */
2402 if (sym
->flags
& BSF_FUNCTION
)
2406 case stop_offset_reached
:
2407 /* Handled by the while loop. */
2411 /* FIXME: There is an implicit assumption here
2412 that the name of sym is different from
2414 if (! bfd_is_local_label (abfd
, sym
))
2421 const char * name
= bfd_asymbol_name (sym
);
2422 char * alloc
= NULL
;
2424 if (do_demangle
&& name
[0] != '\0')
2426 /* Demangle the name. */
2427 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2432 /* We are not currently printing. Check to see
2433 if the current symbol matches the requested symbol. */
2434 if (streq (name
, paux
->symbol
))
2438 if (sym
->flags
& BSF_FUNCTION
)
2440 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2441 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2443 /* Sym is a function symbol with a size associated
2444 with it. Turn on automatic disassembly for the
2445 next VALUE bytes. */
2446 stop_offset
= addr_offset
2447 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2448 loop_until
= stop_offset_reached
;
2452 /* Otherwise we need to tell the loop heuristic to
2453 loop until the next function symbol is encountered. */
2454 loop_until
= function_sym
;
2459 /* Otherwise loop until the next symbol is encountered. */
2460 loop_until
= next_sym
;
2468 if (! prefix_addresses
&& do_print
)
2470 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2471 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2473 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2476 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2478 else if (sym
== NULL
)
2482 #define is_valid_next_sym(SYM) \
2483 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2484 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2485 && pinfo->symbol_is_valid (SYM, pinfo))
2487 /* Search forward for the next appropriate symbol in
2488 SECTION. Note that all the symbols are sorted
2489 together into one big array, and that some sections
2490 may have overlapping addresses. */
2491 while (place
< sorted_symcount
2492 && ! is_valid_next_sym (sorted_syms
[place
]))
2495 if (place
>= sorted_symcount
)
2498 nextsym
= sorted_syms
[place
];
2501 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2502 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2503 else if (nextsym
== NULL
)
2504 nextstop_offset
= stop_offset
;
2506 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2508 if (nextstop_offset
> stop_offset
2509 || nextstop_offset
<= addr_offset
)
2510 nextstop_offset
= stop_offset
;
2512 /* If a symbol is explicitly marked as being an object
2513 rather than a function, just dump the bytes without
2514 disassembling them. */
2517 || sym
->section
!= section
2518 || bfd_asymbol_value (sym
) > addr
2519 || ((sym
->flags
& BSF_OBJECT
) == 0
2520 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2522 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2524 || (sym
->flags
& BSF_FUNCTION
) != 0)
2530 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2531 addr_offset
, nextstop_offset
,
2532 rel_offset
, &rel_pp
, rel_ppend
);
2534 addr_offset
= nextstop_offset
;
2540 if (rel_ppstart
!= NULL
)
2544 /* Disassemble the contents of an object file. */
2547 disassemble_data (bfd
*abfd
)
2549 struct disassemble_info disasm_info
;
2550 struct objdump_disasm_info aux
;
2554 prev_functionname
= NULL
;
2556 prev_discriminator
= 0;
2558 /* We make a copy of syms to sort. We don't want to sort syms
2559 because that will screw up the relocs. */
2560 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2561 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2562 * sizeof (asymbol
*));
2563 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2564 sorted_symcount
* sizeof (asymbol
*));
2566 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2568 for (i
= 0; i
< synthcount
; ++i
)
2570 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2574 /* Sort the symbols into section and symbol order. */
2575 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2577 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2579 disasm_info
.application_data
= (void *) &aux
;
2581 aux
.require_sec
= FALSE
;
2582 aux
.dynrelbuf
= NULL
;
2583 aux
.dynrelcount
= 0;
2585 aux
.symbol
= disasm_sym
;
2587 disasm_info
.print_address_func
= objdump_print_address
;
2588 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2590 if (machine
!= NULL
)
2592 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2595 fatal (_("can't use supplied machine %s"), machine
);
2597 abfd
->arch_info
= inf
;
2600 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2602 struct bfd_target
*xvec
;
2604 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2605 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2606 xvec
->byteorder
= endian
;
2610 /* Use libopcodes to locate a suitable disassembler. */
2611 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2612 bfd_big_endian (abfd
),
2613 bfd_get_mach (abfd
), abfd
);
2614 if (!aux
.disassemble_fn
)
2616 non_fatal (_("can't disassemble for architecture %s\n"),
2617 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2622 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2623 disasm_info
.arch
= bfd_get_arch (abfd
);
2624 disasm_info
.mach
= bfd_get_mach (abfd
);
2625 disasm_info
.disassembler_options
= disassembler_options
;
2626 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2627 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2628 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2629 disasm_info
.disassembler_needs_relocs
= FALSE
;
2631 if (bfd_big_endian (abfd
))
2632 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2633 else if (bfd_little_endian (abfd
))
2634 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2636 /* ??? Aborting here seems too drastic. We could default to big or little
2638 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2640 /* Allow the target to customize the info structure. */
2641 disassemble_init_for_target (& disasm_info
);
2643 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2645 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2647 if (relsize
< 0 && dump_dynamic_reloc_info
)
2648 bfd_fatal (bfd_get_filename (abfd
));
2652 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2653 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2656 if (aux
.dynrelcount
< 0)
2657 bfd_fatal (bfd_get_filename (abfd
));
2659 /* Sort the relocs by address. */
2660 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2664 disasm_info
.symtab
= sorted_syms
;
2665 disasm_info
.symtab_size
= sorted_symcount
;
2667 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2669 if (aux
.dynrelbuf
!= NULL
)
2670 free (aux
.dynrelbuf
);
2675 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2676 asection
*sec
, void *file
)
2678 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2679 bfd
*abfd
= (bfd
*) file
;
2684 if (section
->start
!= NULL
)
2686 /* If it is already loaded, do nothing. */
2687 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2689 free (section
->start
);
2692 section
->filename
= bfd_get_filename (abfd
);
2693 section
->reloc_info
= NULL
;
2694 section
->num_relocs
= 0;
2695 section
->address
= bfd_get_section_vma (abfd
, sec
);
2696 section
->user_data
= sec
;
2697 section
->size
= bfd_get_section_size (sec
);
2698 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2699 alloced
= amt
= section
->size
+ 1;
2700 if (alloced
!= amt
|| alloced
== 0)
2702 section
->start
= NULL
;
2703 free_debug_section (debug
);
2704 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2705 sanitize_string (section
->name
),
2706 (unsigned long long) section
->size
);
2709 section
->start
= contents
= malloc (alloced
);
2710 if (section
->start
== NULL
2711 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2713 free_debug_section (debug
);
2714 printf (_("\nCan't get contents for section '%s'.\n"),
2715 sanitize_string (section
->name
));
2718 /* Ensure any string section has a terminating NUL. */
2719 section
->start
[section
->size
] = 0;
2721 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2726 bfd_cache_section_contents (sec
, section
->start
);
2728 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2735 free_debug_section (debug
);
2736 printf (_("\nCan't get contents for section '%s'.\n"),
2737 sanitize_string (section
->name
));
2741 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2744 unsigned long reloc_count
;
2747 relocs
= (arelent
**) xmalloc (reloc_size
);
2749 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2750 if (reloc_count
== 0)
2754 section
->reloc_info
= relocs
;
2755 section
->num_relocs
= reloc_count
;
2764 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2769 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2772 relocs
= (arelent
**) dsec
->reloc_info
;
2774 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2775 if (rp
->address
== offset
)
2782 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2784 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2785 bfd
*abfd
= (bfd
*) file
;
2788 /* If it is already loaded, do nothing. */
2789 if (section
->start
!= NULL
)
2791 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2795 /* Locate the debug section. */
2796 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2798 section
->name
= section
->uncompressed_name
;
2801 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2803 section
->name
= section
->compressed_name
;
2808 return load_specific_debug_section (debug
, sec
, file
);
2812 free_debug_section (enum dwarf_section_display_enum debug
)
2814 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2816 if (section
->start
== NULL
)
2819 /* PR 17512: file: 0f67f69d. */
2820 if (section
->user_data
!= NULL
)
2822 asection
* sec
= (asection
*) section
->user_data
;
2824 /* If we are freeing contents that are also pointed to by the BFD
2825 library's section structure then make sure to update those pointers
2826 too. Otherwise, the next time we try to load data for this section
2827 we can end up using a stale pointer. */
2828 if (section
->start
== sec
->contents
)
2830 sec
->contents
= NULL
;
2831 sec
->flags
&= ~ SEC_IN_MEMORY
;
2832 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2836 free ((char *) section
->start
);
2837 section
->start
= NULL
;
2838 section
->address
= 0;
2843 close_debug_file (void * file
)
2845 bfd
* abfd
= (bfd
*) file
;
2851 open_debug_file (const char * pathname
)
2855 data
= bfd_openr (pathname
, NULL
);
2859 if (! bfd_check_format (data
, bfd_object
))
2866 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2867 void *arg ATTRIBUTE_UNUSED
)
2869 const char *name
= bfd_get_section_name (abfd
, section
);
2873 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2874 match
= ".debug_info";
2878 for (i
= 0; i
< max
; i
++)
2879 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2880 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2881 && debug_displays
[i
].enabled
!= NULL
2882 && *debug_displays
[i
].enabled
)
2884 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2886 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2887 sec
->name
= sec
->uncompressed_name
;
2889 sec
->name
= sec
->compressed_name
;
2890 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2893 debug_displays
[i
].display (sec
, abfd
);
2895 if (i
!= info
&& i
!= abbrev
)
2896 free_debug_section ((enum dwarf_section_display_enum
) i
);
2902 /* Dump the dwarf debugging information. */
2905 dump_dwarf (bfd
*abfd
)
2907 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2908 if (byte_get
== NULL
)
2910 warn (_("File %s does not contain any dwarf debug information\n"),
2911 bfd_get_filename (abfd
));
2915 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2917 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2919 switch (bfd_get_arch (abfd
))
2922 switch (bfd_get_mach (abfd
))
2924 case bfd_mach_x86_64
:
2925 case bfd_mach_x86_64_intel_syntax
:
2926 case bfd_mach_x86_64_nacl
:
2927 case bfd_mach_x64_32
:
2928 case bfd_mach_x64_32_intel_syntax
:
2929 case bfd_mach_x64_32_nacl
:
2930 init_dwarf_regnames_x86_64 ();
2934 init_dwarf_regnames_i386 ();
2939 case bfd_arch_iamcu
:
2940 init_dwarf_regnames_iamcu ();
2943 case bfd_arch_aarch64
:
2944 init_dwarf_regnames_aarch64();
2948 init_dwarf_regnames_s390 ();
2951 case bfd_arch_riscv
:
2952 init_dwarf_regnames_riscv ();
2956 /* S12Z has a 24 bit address space. But the only known
2957 producer of dwarf_info encodes addresses into 32 bits. */
2965 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2968 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2969 it. Return NULL on failure. */
2972 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2977 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2978 if (stabsect
== NULL
)
2980 printf (_("No %s section present\n\n"),
2981 sanitize_string (sect_name
));
2985 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2987 non_fatal (_("reading %s section of %s failed: %s"),
2988 sect_name
, bfd_get_filename (abfd
),
2989 bfd_errmsg (bfd_get_error ()));
2995 *size_ptr
= bfd_section_size (abfd
, stabsect
);
3000 /* Stabs entries use a 12 byte format:
3001 4 byte string table index
3003 1 byte stab other field
3004 2 byte stab desc field
3006 FIXME: This will have to change for a 64 bit object format. */
3008 #define STRDXOFF (0)
3010 #define OTHEROFF (5)
3013 #define STABSIZE (12)
3015 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3016 using string table section STRSECT_NAME (in `strtab'). */
3019 print_section_stabs (bfd
*abfd
,
3020 const char *stabsect_name
,
3021 unsigned *string_offset_ptr
)
3024 unsigned file_string_table_offset
= 0;
3025 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3026 bfd_byte
*stabp
, *stabs_end
;
3029 stabs_end
= stabp
+ stab_size
;
3031 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3032 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3034 /* Loop through all symbols and print them.
3036 We start the index at -1 because there is a dummy symbol on
3037 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3038 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3042 unsigned char type
, other
;
3043 unsigned short desc
;
3046 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3047 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3048 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3049 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3050 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3052 printf ("\n%-6d ", i
);
3053 /* Either print the stab name, or, if unnamed, print its number
3054 again (makes consistent formatting for tools like awk). */
3055 name
= bfd_get_stab_name (type
);
3057 printf ("%-6s", sanitize_string (name
));
3058 else if (type
== N_UNDF
)
3061 printf ("%-6d", type
);
3062 printf (" %-6d %-6d ", other
, desc
);
3063 bfd_printf_vma (abfd
, value
);
3064 printf (" %-6lu", strx
);
3066 /* Symbols with type == 0 (N_UNDF) specify the length of the
3067 string table associated with this file. We use that info
3068 to know how to relocate the *next* file's string table indices. */
3071 file_string_table_offset
= next_file_string_table_offset
;
3072 next_file_string_table_offset
+= value
;
3076 bfd_size_type amt
= strx
+ file_string_table_offset
;
3078 /* Using the (possibly updated) string table offset, print the
3079 string (if any) associated with this symbol. */
3080 if (amt
< stabstr_size
)
3081 /* PR 17512: file: 079-79389-0.001:0.1.
3082 FIXME: May need to sanitize this string before displaying. */
3083 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3089 *string_offset_ptr
= next_file_string_table_offset
;
3094 const char * section_name
;
3095 const char * string_section_name
;
3096 unsigned string_offset
;
3101 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3104 stab_section_names
* sought
= (stab_section_names
*) names
;
3106 /* Check for section names for which stabsect_name is a prefix, to
3107 handle .stab.N, etc. */
3108 len
= strlen (sought
->section_name
);
3110 /* If the prefix matches, and the files section name ends with a
3111 nul or a digit, then we match. I.e., we want either an exact
3112 match or a section followed by a number. */
3113 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3114 && (section
->name
[len
] == 0
3115 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3118 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3123 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
3125 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3131 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3133 stab_section_names s
;
3135 s
.section_name
= stabsect_name
;
3136 s
.string_section_name
= strsect_name
;
3137 s
.string_offset
= 0;
3139 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3145 /* Dump the any sections containing stabs debugging information. */
3148 dump_stabs (bfd
*abfd
)
3150 dump_stabs_section (abfd
, ".stab", ".stabstr");
3151 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3152 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3155 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3157 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3161 dump_bfd_header (bfd
*abfd
)
3165 printf (_("architecture: %s, "),
3166 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3167 bfd_get_mach (abfd
)));
3168 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3170 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3171 PF (HAS_RELOC
, "HAS_RELOC");
3172 PF (EXEC_P
, "EXEC_P");
3173 PF (HAS_LINENO
, "HAS_LINENO");
3174 PF (HAS_DEBUG
, "HAS_DEBUG");
3175 PF (HAS_SYMS
, "HAS_SYMS");
3176 PF (HAS_LOCALS
, "HAS_LOCALS");
3177 PF (DYNAMIC
, "DYNAMIC");
3178 PF (WP_TEXT
, "WP_TEXT");
3179 PF (D_PAGED
, "D_PAGED");
3180 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3181 printf (_("\nstart address 0x"));
3182 bfd_printf_vma (abfd
, abfd
->start_address
);
3188 dump_bfd_private_header (bfd
*abfd
)
3190 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3191 non_fatal (_("warning: private headers incomplete: %s"),
3192 bfd_errmsg (bfd_get_error ()));
3196 dump_target_specific (bfd
*abfd
)
3198 const struct objdump_private_desc
* const *desc
;
3199 struct objdump_private_option
*opt
;
3202 /* Find the desc. */
3203 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3204 if ((*desc
)->filter (abfd
))
3209 non_fatal (_("option -P/--private not supported by this file"));
3213 /* Clear all options. */
3214 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3215 opt
->selected
= FALSE
;
3217 /* Decode options. */
3218 b
= dump_private_options
;
3221 e
= strchr (b
, ',');
3226 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3227 if (strcmp (opt
->name
, b
) == 0)
3229 opt
->selected
= TRUE
;
3232 if (opt
->name
== NULL
)
3233 non_fatal (_("target specific dump '%s' not supported"), b
);
3244 (*desc
)->dump (abfd
);
3247 /* Display a section in hexadecimal format with associated characters.
3248 Each line prefixed by the zero padded address. */
3251 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3253 bfd_byte
*data
= NULL
;
3254 bfd_size_type datasize
;
3255 bfd_vma addr_offset
;
3256 bfd_vma start_offset
;
3257 bfd_vma stop_offset
;
3258 unsigned int opb
= bfd_octets_per_byte (abfd
);
3259 /* Bytes per line. */
3260 const int onaline
= 16;
3265 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3268 if (! process_section_p (section
))
3271 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3274 /* Compute the address range to display. */
3275 if (start_address
== (bfd_vma
) -1
3276 || start_address
< section
->vma
)
3279 start_offset
= start_address
- section
->vma
;
3281 if (stop_address
== (bfd_vma
) -1)
3282 stop_offset
= datasize
/ opb
;
3285 if (stop_address
< section
->vma
)
3288 stop_offset
= stop_address
- section
->vma
;
3290 if (stop_offset
> datasize
/ opb
)
3291 stop_offset
= datasize
/ opb
;
3294 if (start_offset
>= stop_offset
)
3297 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3298 if (display_file_offsets
)
3299 printf (_(" (Starting at file offset: 0x%lx)"),
3300 (unsigned long) (section
->filepos
+ start_offset
));
3303 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3305 non_fatal (_("Reading section %s failed because: %s"),
3306 section
->name
, bfd_errmsg (bfd_get_error ()));
3312 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3313 if (strlen (buf
) >= sizeof (buf
))
3317 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3319 count
= strlen (buf
) - count
;
3323 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3324 if (strlen (buf
) >= sizeof (buf
))
3328 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3330 count
= strlen (buf
) - count
;
3334 for (addr_offset
= start_offset
;
3335 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3339 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3340 count
= strlen (buf
);
3341 if ((size_t) count
>= sizeof (buf
))
3345 while (count
< width
)
3350 fputs (buf
+ count
- width
, stdout
);
3353 for (j
= addr_offset
* opb
;
3354 j
< addr_offset
* opb
+ onaline
; j
++)
3356 if (j
< stop_offset
* opb
)
3357 printf ("%02x", (unsigned) (data
[j
]));
3365 for (j
= addr_offset
* opb
;
3366 j
< addr_offset
* opb
+ onaline
; j
++)
3368 if (j
>= stop_offset
* opb
)
3371 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3378 /* Actually display the various requested regions. */
3381 dump_data (bfd
*abfd
)
3383 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3386 /* Should perhaps share code and display with nm? */
3389 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3398 max_count
= dynsymcount
;
3399 printf ("DYNAMIC SYMBOL TABLE:\n");
3404 max_count
= symcount
;
3405 printf ("SYMBOL TABLE:\n");
3409 printf (_("no symbols\n"));
3411 for (count
= 0; count
< max_count
; count
++)
3415 if (*current
== NULL
)
3416 printf (_("no information for symbol number %ld\n"), count
);
3418 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3419 printf (_("could not determine the type of symbol number %ld\n"),
3422 else if (process_section_p ((* current
)->section
)
3423 && (dump_special_syms
3424 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3426 const char *name
= (*current
)->name
;
3428 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3432 /* If we want to demangle the name, we demangle it
3433 here, and temporarily clobber it while calling
3434 bfd_print_symbol. FIXME: This is a gross hack. */
3435 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3437 (*current
)->name
= alloc
;
3438 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3439 bfd_print_symbol_all
);
3442 (*current
)->name
= name
;
3447 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3448 bfd_print_symbol_all
);
3458 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3461 char *last_filename
, *last_functionname
;
3462 unsigned int last_line
;
3463 unsigned int last_discriminator
;
3465 /* Get column headers lined up reasonably. */
3473 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3474 width
= strlen (buf
) - 7;
3476 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3479 last_filename
= NULL
;
3480 last_functionname
= NULL
;
3482 last_discriminator
= 0;
3484 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3487 const char *filename
, *functionname
;
3488 unsigned int linenumber
;
3489 unsigned int discriminator
;
3490 const char *sym_name
;
3491 const char *section_name
;
3492 bfd_vma addend2
= 0;
3494 if (start_address
!= (bfd_vma
) -1
3495 && q
->address
< start_address
)
3497 if (stop_address
!= (bfd_vma
) -1
3498 && q
->address
> stop_address
)
3501 if (with_line_numbers
3503 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3504 &filename
, &functionname
,
3505 &linenumber
, &discriminator
))
3507 if (functionname
!= NULL
3508 && (last_functionname
== NULL
3509 || strcmp (functionname
, last_functionname
) != 0))
3511 printf ("%s():\n", sanitize_string (functionname
));
3512 if (last_functionname
!= NULL
)
3513 free (last_functionname
);
3514 last_functionname
= xstrdup (functionname
);
3518 && (linenumber
!= last_line
3519 || (filename
!= NULL
3520 && last_filename
!= NULL
3521 && filename_cmp (filename
, last_filename
) != 0)
3522 || (discriminator
!= last_discriminator
)))
3524 if (discriminator
> 0)
3525 printf ("%s:%u\n", filename
== NULL
? "???" :
3526 sanitize_string (filename
), linenumber
);
3528 printf ("%s:%u (discriminator %u)\n",
3529 filename
== NULL
? "???" : sanitize_string (filename
),
3530 linenumber
, discriminator
);
3531 last_line
= linenumber
;
3532 last_discriminator
= discriminator
;
3533 if (last_filename
!= NULL
)
3534 free (last_filename
);
3535 if (filename
== NULL
)
3536 last_filename
= NULL
;
3538 last_filename
= xstrdup (filename
);
3542 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3544 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3545 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3550 section_name
= NULL
;
3553 bfd_printf_vma (abfd
, q
->address
);
3554 if (q
->howto
== NULL
)
3555 printf (" *unknown* ");
3556 else if (q
->howto
->name
)
3558 const char *name
= q
->howto
->name
;
3560 /* R_SPARC_OLO10 relocations contain two addends.
3561 But because 'arelent' lacks enough storage to
3562 store them both, the 64-bit ELF Sparc backend
3563 records this as two relocations. One R_SPARC_LO10
3564 and one R_SPARC_13, both pointing to the same
3565 address. This is merely so that we have some
3566 place to store both addend fields.
3568 Undo this transformation, otherwise the output
3569 will be confusing. */
3570 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3571 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3573 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3575 arelent
*q2
= *(p
+ 1);
3578 && q
->address
== q2
->address
3579 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3581 name
= "R_SPARC_OLO10";
3582 addend2
= q2
->addend
;
3586 printf (" %-16s ", name
);
3589 printf (" %-16d ", q
->howto
->type
);
3593 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3597 if (section_name
== NULL
)
3598 section_name
= "*unknown*";
3599 printf ("[%s]", sanitize_string (section_name
));
3604 bfd_signed_vma addend
= q
->addend
;
3612 bfd_printf_vma (abfd
, addend
);
3617 bfd_printf_vma (abfd
, addend2
);
3623 if (last_filename
!= NULL
)
3624 free (last_filename
);
3625 if (last_functionname
!= NULL
)
3626 free (last_functionname
);
3630 dump_relocs_in_section (bfd
*abfd
,
3632 void *dummy ATTRIBUTE_UNUSED
)
3638 if ( bfd_is_abs_section (section
)
3639 || bfd_is_und_section (section
)
3640 || bfd_is_com_section (section
)
3641 || (! process_section_p (section
))
3642 || ((section
->flags
& SEC_RELOC
) == 0))
3645 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3647 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3650 printf (" (none)\n\n");
3658 relpp
= (arelent
**) xmalloc (relsize
);
3659 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3665 non_fatal (_("failed to read relocs in: %s"),
3666 sanitize_string (bfd_get_filename (abfd
)));
3667 bfd_fatal (_("error message was"));
3669 else if (relcount
== 0)
3670 printf (" (none)\n\n");
3674 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3681 dump_relocs (bfd
*abfd
)
3683 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3687 dump_dynamic_relocs (bfd
*abfd
)
3693 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3695 bfd_fatal (bfd_get_filename (abfd
));
3697 printf ("DYNAMIC RELOCATION RECORDS");
3700 printf (" (none)\n\n");
3703 relpp
= (arelent
**) xmalloc (relsize
);
3704 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3707 bfd_fatal (bfd_get_filename (abfd
));
3708 else if (relcount
== 0)
3709 printf (" (none)\n\n");
3713 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3720 /* Creates a table of paths, to search for source files. */
3723 add_include_path (const char *path
)
3727 include_path_count
++;
3728 include_paths
= (const char **)
3729 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3730 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3731 if (path
[1] == ':' && path
[2] == 0)
3732 path
= concat (path
, ".", (const char *) 0);
3734 include_paths
[include_path_count
- 1] = path
;
3738 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3742 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3744 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3745 section
->vma
+= adjust_section_vma
;
3747 section
->lma
+= adjust_section_vma
;
3751 /* Dump selected contents of ABFD. */
3754 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3756 if (bfd_big_endian (abfd
))
3757 byte_get
= byte_get_big_endian
;
3758 else if (bfd_little_endian (abfd
))
3759 byte_get
= byte_get_little_endian
;
3763 /* Load any separate debug information files.
3764 We do this now and without checking do_follow_links because separate
3765 debug info files may contain symbol tables that we will need when
3766 displaying information about the main file. Any memory allocated by
3767 load_separate_debug_files will be released when we call
3768 free_debug_memory below.
3770 The test on is_mainfile is there because the chain of separate debug
3771 info files is a global variable shared by all invocations of dump_bfd. */
3774 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3776 /* If asked to do so, recursively dump the separate files. */
3777 if (do_follow_links
)
3781 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3782 dump_bfd (i
->handle
, FALSE
);
3786 /* If we are adjusting section VMA's, change them all now. Changing
3787 the BFD information is a hack. However, we must do it, or
3788 bfd_find_nearest_line will not do the right thing. */
3789 if (adjust_section_vma
!= 0)
3791 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3792 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3795 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3796 printf (_("\n%s: file format %s\n"),
3797 sanitize_string (bfd_get_filename (abfd
)),
3800 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3801 if (dump_file_header
)
3802 dump_bfd_header (abfd
);
3803 if (dump_private_headers
)
3804 dump_bfd_private_header (abfd
);
3805 if (dump_private_options
!= NULL
)
3806 dump_target_specific (abfd
);
3807 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3814 || dump_dwarf_section_info
)
3816 syms
= slurp_symtab (abfd
);
3818 /* If following links, load any symbol tables from the linked files as well. */
3819 if (do_follow_links
&& is_mainfile
)
3823 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3825 asymbol
** extra_syms
;
3826 long old_symcount
= symcount
;
3828 extra_syms
= slurp_symtab (i
->handle
);
3832 if (old_symcount
== 0)
3838 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
3839 memcpy (syms
+ old_symcount
,
3841 symcount
* sizeof (asymbol
*));
3845 symcount
+= old_symcount
;
3850 if (dump_section_headers
)
3851 dump_headers (abfd
);
3853 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3854 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3855 dynsyms
= slurp_dynamic_symtab (abfd
);
3859 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3860 dynsymcount
, dynsyms
, &synthsyms
);
3866 dump_symbols (abfd
, FALSE
);
3867 if (dump_dynamic_symtab
)
3868 dump_symbols (abfd
, TRUE
);
3869 if (dump_dwarf_section_info
)
3871 if (dump_stab_section_info
)
3873 if (dump_reloc_info
&& ! disassemble
)
3875 if (dump_dynamic_reloc_info
&& ! disassemble
)
3876 dump_dynamic_relocs (abfd
);
3877 if (dump_section_contents
)
3880 disassemble_data (abfd
);
3886 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3887 if (dhandle
!= NULL
)
3889 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3891 dump_debugging_tags
? TRUE
: FALSE
))
3893 non_fatal (_("%s: printing debugging information failed"),
3894 bfd_get_filename (abfd
));
3900 /* PR 6483: If there was no STABS debug info in the file, try
3902 else if (! dump_dwarf_section_info
)
3904 dwarf_select_sections_all ();
3932 free_debug_memory ();
3936 display_object_bfd (bfd
*abfd
)
3940 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3942 dump_bfd (abfd
, TRUE
);
3946 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3948 nonfatal (bfd_get_filename (abfd
));
3949 list_matching_formats (matching
);
3954 if (bfd_get_error () != bfd_error_file_not_recognized
)
3956 nonfatal (bfd_get_filename (abfd
));
3960 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3962 dump_bfd (abfd
, TRUE
);
3966 nonfatal (bfd_get_filename (abfd
));
3968 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3970 list_matching_formats (matching
);
3976 display_any_bfd (bfd
*file
, int level
)
3978 /* Decompress sections unless dumping the section contents. */
3979 if (!dump_section_contents
)
3980 file
->flags
|= BFD_DECOMPRESS
;
3982 /* If the file is an archive, process all of its elements. */
3983 if (bfd_check_format (file
, bfd_archive
))
3986 bfd
*last_arfile
= NULL
;
3989 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
3990 else if (level
> 100)
3992 /* Prevent corrupted files from spinning us into an
3993 infinite loop. 100 is an arbitrary heuristic. */
3994 fatal (_("Archive nesting is too deep"));
3998 printf (_("In nested archive %s:\n"),
3999 sanitize_string (bfd_get_filename (file
)));
4003 bfd_set_error (bfd_error_no_error
);
4005 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4008 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4009 nonfatal (bfd_get_filename (file
));
4013 display_any_bfd (arfile
, level
+ 1);
4015 if (last_arfile
!= NULL
)
4017 bfd_close (last_arfile
);
4018 /* PR 17512: file: ac585d01. */
4019 if (arfile
== last_arfile
)
4025 last_arfile
= arfile
;
4028 if (last_arfile
!= NULL
)
4029 bfd_close (last_arfile
);
4032 display_object_bfd (file
);
4036 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4040 if (get_file_size (filename
) < 1)
4046 file
= bfd_openr (filename
, target
);
4049 nonfatal (filename
);
4053 display_any_bfd (file
, 0);
4055 /* This is an optimization to improve the speed of objdump, especially when
4056 dumping a file with lots of associated debug informatiom. Calling
4057 bfd_close on such a file can take a non-trivial amount of time as there
4058 are lots of lists to walk and buffers to free. This is only really
4059 necessary however if we are about to load another file and we need the
4060 memory back. Otherwise, if we are about to exit, then we can save (a lot
4061 of) time by only doing a quick close, and allowing the OS to reclaim the
4066 bfd_close_all_done (file
);
4070 main (int argc
, char **argv
)
4073 char *target
= default_target
;
4074 bfd_boolean seenflag
= FALSE
;
4076 #if defined (HAVE_SETLOCALE)
4077 #if defined (HAVE_LC_MESSAGES)
4078 setlocale (LC_MESSAGES
, "");
4080 setlocale (LC_CTYPE
, "");
4083 bindtextdomain (PACKAGE
, LOCALEDIR
);
4084 textdomain (PACKAGE
);
4086 program_name
= *argv
;
4087 xmalloc_set_program_name (program_name
);
4088 bfd_set_error_program_name (program_name
);
4090 START_PROGRESS (program_name
, 0);
4092 expandargv (&argc
, &argv
);
4094 if (bfd_init () != BFD_INIT_MAGIC
)
4095 fatal (_("fatal error: libbfd ABI mismatch"));
4096 set_default_bfd_target ();
4098 while ((c
= getopt_long (argc
, argv
,
4099 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4100 long_options
, (int *) 0))
4106 break; /* We've been given a long option. */
4113 if (disassembler_options
)
4114 /* Ignore potential memory leak for now. */
4115 options
= concat (disassembler_options
, ",",
4116 optarg
, (const char *) NULL
);
4119 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4126 display_file_offsets
= TRUE
;
4129 with_line_numbers
= TRUE
;
4138 enum demangling_styles style
;
4140 style
= cplus_demangle_name_to_style (optarg
);
4141 if (style
== unknown_demangling
)
4142 fatal (_("unknown demangling style `%s'"),
4145 cplus_demangle_set_style (style
);
4148 case OPTION_RECURSE_LIMIT
:
4149 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4151 case OPTION_NO_RECURSE_LIMIT
:
4152 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4155 do_wide
= wide_output
= TRUE
;
4157 case OPTION_ADJUST_VMA
:
4158 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4160 case OPTION_START_ADDRESS
:
4161 start_address
= parse_vma (optarg
, "--start-address");
4162 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4163 fatal (_("error: the start address should be before the end address"));
4165 case OPTION_STOP_ADDRESS
:
4166 stop_address
= parse_vma (optarg
, "--stop-address");
4167 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4168 fatal (_("error: the stop address should be after the start address"));
4172 prefix_length
= strlen (prefix
);
4173 /* Remove an unnecessary trailing '/' */
4174 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4177 case OPTION_PREFIX_STRIP
:
4178 prefix_strip
= atoi (optarg
);
4179 if (prefix_strip
< 0)
4180 fatal (_("error: prefix strip must be non-negative"));
4182 case OPTION_INSN_WIDTH
:
4183 insn_width
= strtoul (optarg
, NULL
, 0);
4184 if (insn_width
<= 0)
4185 fatal (_("error: instruction width must be positive"));
4187 case OPTION_INLINES
:
4188 unwind_inlines
= TRUE
;
4191 if (strcmp (optarg
, "B") == 0)
4192 endian
= BFD_ENDIAN_BIG
;
4193 else if (strcmp (optarg
, "L") == 0)
4194 endian
= BFD_ENDIAN_LITTLE
;
4197 nonfatal (_("unrecognized -E option"));
4202 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4203 endian
= BFD_ENDIAN_BIG
;
4204 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4205 endian
= BFD_ENDIAN_LITTLE
;
4208 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4215 dump_file_header
= TRUE
;
4219 formats_info
= TRUE
;
4223 add_include_path (optarg
);
4226 dump_private_headers
= TRUE
;
4230 dump_private_options
= optarg
;
4234 dump_private_headers
= TRUE
;
4236 dump_reloc_info
= TRUE
;
4237 dump_file_header
= TRUE
;
4238 dump_ar_hdrs
= TRUE
;
4239 dump_section_headers
= TRUE
;
4247 dump_dynamic_symtab
= TRUE
;
4253 disasm_sym
= optarg
;
4256 disassemble_zeroes
= TRUE
;
4260 disassemble_all
= TRUE
;
4265 with_source_code
= TRUE
;
4274 dump_debugging_tags
= 1;
4279 dump_dwarf_section_info
= TRUE
;
4282 dwarf_select_sections_by_letters (optarg
);
4284 dwarf_select_sections_all ();
4287 dump_dwarf_section_info
= TRUE
;
4290 dwarf_select_sections_by_names (optarg
);
4292 dwarf_select_sections_all ();
4294 case OPTION_DWARF_DEPTH
:
4297 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4300 case OPTION_DWARF_START
:
4303 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4304 suppress_bfd_header
= 1;
4307 case OPTION_DWARF_CHECK
:
4311 dump_stab_section_info
= TRUE
;
4315 dump_section_contents
= TRUE
;
4319 dump_reloc_info
= TRUE
;
4323 dump_dynamic_reloc_info
= TRUE
;
4327 dump_ar_hdrs
= TRUE
;
4331 dump_section_headers
= TRUE
;
4336 show_version
= TRUE
;
4342 /* No need to set seenflag or to break - usage() does not return. */
4349 print_version ("objdump");
4355 exit_status
= display_info ();
4359 display_file ("a.out", target
, TRUE
);
4361 for (; optind
< argc
;)
4363 display_file (argv
[optind
], target
, optind
== argc
- 1);
4370 END_PROGRESS (program_name
);