1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2020 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. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int no_addresses
; /* --no-addresses */
97 static int prefix_addresses
; /* --prefix-addresses */
98 static int with_line_numbers
; /* -l */
99 static bfd_boolean with_source_code
; /* -S */
100 static int show_raw_insn
; /* --show-raw-insn */
101 static int dump_dwarf_section_info
; /* --dwarf */
102 static int dump_stab_section_info
; /* --stabs */
103 static int dump_ctf_section_info
; /* --ctf */
104 static char *dump_ctf_section_name
;
105 static char *dump_ctf_parent_name
; /* --ctf-parent */
106 static int do_demangle
; /* -C, --demangle */
107 static bfd_boolean disassemble
; /* -d */
108 static bfd_boolean disassemble_all
; /* -D */
109 static int disassemble_zeroes
; /* --disassemble-zeroes */
110 static bfd_boolean formats_info
; /* -i */
111 static int wide_output
; /* -w */
112 static int insn_width
; /* --insn-width */
113 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
114 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
115 static int dump_debugging
; /* --debugging */
116 static int dump_debugging_tags
; /* --debugging-tags */
117 static int suppress_bfd_header
;
118 static int dump_special_syms
= 0; /* --special-syms */
119 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
120 static int file_start_context
= 0; /* --file-start-context */
121 static bfd_boolean display_file_offsets
;/* -F */
122 static const char *prefix
; /* --prefix */
123 static int prefix_strip
; /* --prefix-strip */
124 static size_t prefix_length
;
125 static bfd_boolean unwind_inlines
; /* --inlines. */
126 static const char * disasm_sym
; /* Disassembly start symbol. */
127 static const char * source_comment
; /* --source_comment. */
128 static bfd_boolean visualize_jumps
= FALSE
; /* --visualize-jumps. */
129 static bfd_boolean color_output
= FALSE
; /* --visualize-jumps=color. */
130 static bfd_boolean extended_color_output
= FALSE
; /* --visualize-jumps=extended-color. */
132 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
134 /* A structure to record the sections mentioned in -j switches. */
137 const char * name
; /* The name of the section. */
138 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
139 struct only
* next
; /* Pointer to the next structure in the list. */
141 /* Pointer to an array of 'only' structures.
142 This pointer is NULL if the -j switch has not been used. */
143 static struct only
* only_list
= NULL
;
145 /* Variables for handling include file path table. */
146 static const char **include_paths
;
147 static int include_path_count
;
149 /* Extra info to pass to the section disassembler and address printing
151 struct objdump_disasm_info
154 bfd_boolean require_sec
;
155 arelent
** dynrelbuf
;
157 disassembler_ftype disassemble_fn
;
162 /* Architecture to disassemble for, or default if NULL. */
163 static char *machine
= NULL
;
165 /* Target specific options to the disassembler. */
166 static char *disassembler_options
= NULL
;
168 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
169 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
171 /* The symbol table. */
172 static asymbol
**syms
;
174 /* Number of symbols in `syms'. */
175 static long symcount
= 0;
177 /* The sorted symbol table. */
178 static asymbol
**sorted_syms
;
180 /* Number of symbols in `sorted_syms'. */
181 static long sorted_symcount
= 0;
183 /* The dynamic symbol table. */
184 static asymbol
**dynsyms
;
186 /* The synthetic symbol table. */
187 static asymbol
*synthsyms
;
188 static long synthcount
= 0;
190 /* Number of symbols in `dynsyms'. */
191 static long dynsymcount
= 0;
193 static bfd_byte
*stabs
;
194 static bfd_size_type stab_size
;
196 static bfd_byte
*strtab
;
197 static bfd_size_type stabstr_size
;
199 /* Handlers for -P/--private. */
200 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
202 OBJDUMP_PRIVATE_VECTORS
206 /* The list of detected jumps inside a function. */
207 static struct jump_info
*detected_jumps
= NULL
;
209 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
211 usage (FILE *stream
, int status
)
213 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
214 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
215 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
216 fprintf (stream
, _("\
217 -a, --archive-headers Display archive header information\n\
218 -f, --file-headers Display the contents of the overall file header\n\
219 -p, --private-headers Display object format specific file header contents\n\
220 -P, --private=OPT,OPT... Display object format specific contents\n\
221 -h, --[section-]headers Display the contents of the section headers\n\
222 -x, --all-headers Display the contents of all headers\n\
223 -d, --disassemble Display assembler contents of executable sections\n\
224 -D, --disassemble-all Display assembler contents of all sections\n\
225 --disassemble=<sym> Display assembler contents from <sym>\n\
226 -S, --source Intermix source code with disassembly\n\
227 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
228 -s, --full-contents Display the full contents of all sections requested\n\
229 -g, --debugging Display debug information in object file\n\
230 -e, --debugging-tags Display debug information using ctags style\n\
231 -G, --stabs Display (in raw form) any STABS info in the file\n\
232 -W[lLiaprmfFsoRtUuTgAckK] or\n\
233 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
234 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
235 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
236 =addr,=cu_index,=links,=follow-links]\n\
237 Display DWARF info in the file\n\
238 --ctf=SECTION Display CTF info from SECTION\n\
239 -t, --syms Display the contents of the symbol table(s)\n\
240 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
241 -r, --reloc Display the relocation entries in the file\n\
242 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
243 @<file> Read options from <file>\n\
244 -v, --version Display this program's version number\n\
245 -i, --info List object formats and architectures supported\n\
246 -H, --help Display this information\n\
250 const struct objdump_private_desc
* const *desc
;
252 fprintf (stream
, _("\n The following switches are optional:\n"));
253 fprintf (stream
, _("\
254 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
255 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
256 -j, --section=NAME Only display information for section NAME\n\
257 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
258 -EB --endian=big Assume big endian format when disassembling\n\
259 -EL --endian=little Assume little endian format when disassembling\n\
260 --file-start-context Include context from start of file (with -S)\n\
261 -I, --include=DIR Add DIR to search list for source files\n\
262 -l, --line-numbers Include line numbers and filenames in output\n\
263 -F, --file-offsets Include file offsets when displaying information\n\
264 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
265 The STYLE, if specified, can be `auto', `gnu',\n\
266 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
268 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
269 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
270 -w, --wide Format output for more than 80 columns\n\
271 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
272 --start-address=ADDR Only process data whose address is >= ADDR\n\
273 --stop-address=ADDR Only process data whose address is < ADDR\n\
274 --no-addresses Do not print address alongside disassembly\n\
275 --prefix-addresses Print complete address alongside disassembly\n\
276 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
277 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
278 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
279 --special-syms Include special symbols in symbol dumps\n\
280 --inlines Print all inlines for source line (with -l)\n\
281 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
282 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
283 fprintf (stream
, _("\
284 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
285 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
287 --dwarf-check Make additional dwarf internal consistency checks.\
289 --ctf-parent=SECTION Use SECTION as the CTF parent\n\
290 --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
291 --visualize-jumps=color Use colors in the ASCII art\n\
292 --visualize-jumps=extended-color Use extended 8-bit color codes\n\
293 --visualize-jumps=off Disable jump visualization\n\n"));
295 list_supported_targets (program_name
, stream
);
296 list_supported_architectures (program_name
, stream
);
298 disassembler_usage (stream
);
300 if (objdump_private_vectors
[0] != NULL
)
303 _("\nOptions supported for -P/--private switch:\n"));
304 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
305 (*desc
)->help (stream
);
308 if (REPORT_BUGS_TO
[0] && status
== 0)
309 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
313 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
317 OPTION_START_ADDRESS
,
327 OPTION_RECURSE_LIMIT
,
328 OPTION_NO_RECURSE_LIMIT
,
330 OPTION_SOURCE_COMMENT
,
333 OPTION_VISUALIZE_JUMPS
336 static struct option long_options
[]=
338 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
339 {"all-headers", no_argument
, NULL
, 'x'},
340 {"private-headers", no_argument
, NULL
, 'p'},
341 {"private", required_argument
, NULL
, 'P'},
342 {"architecture", required_argument
, NULL
, 'm'},
343 {"archive-headers", no_argument
, NULL
, 'a'},
344 {"debugging", no_argument
, NULL
, 'g'},
345 {"debugging-tags", no_argument
, NULL
, 'e'},
346 {"demangle", optional_argument
, NULL
, 'C'},
347 {"disassemble", optional_argument
, NULL
, 'd'},
348 {"disassemble-all", no_argument
, NULL
, 'D'},
349 {"disassembler-options", required_argument
, NULL
, 'M'},
350 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
351 {"dynamic-reloc", no_argument
, NULL
, 'R'},
352 {"dynamic-syms", no_argument
, NULL
, 'T'},
353 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
354 {"file-headers", no_argument
, NULL
, 'f'},
355 {"file-offsets", no_argument
, NULL
, 'F'},
356 {"file-start-context", no_argument
, &file_start_context
, 1},
357 {"full-contents", no_argument
, NULL
, 's'},
358 {"headers", no_argument
, NULL
, 'h'},
359 {"help", no_argument
, NULL
, 'H'},
360 {"info", no_argument
, NULL
, 'i'},
361 {"line-numbers", no_argument
, NULL
, 'l'},
362 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
363 {"no-addresses", no_argument
, &no_addresses
, 1},
364 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
365 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
366 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
367 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
368 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
369 {"reloc", no_argument
, NULL
, 'r'},
370 {"section", required_argument
, NULL
, 'j'},
371 {"section-headers", no_argument
, NULL
, 'h'},
372 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
373 {"source", no_argument
, NULL
, 'S'},
374 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
375 {"special-syms", no_argument
, &dump_special_syms
, 1},
376 {"include", required_argument
, NULL
, 'I'},
377 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
378 {"ctf", required_argument
, NULL
, OPTION_CTF
},
379 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
380 {"stabs", no_argument
, NULL
, 'G'},
381 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
382 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
383 {"syms", no_argument
, NULL
, 't'},
384 {"target", required_argument
, NULL
, 'b'},
385 {"version", no_argument
, NULL
, 'V'},
386 {"wide", no_argument
, NULL
, 'w'},
387 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
388 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
389 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
390 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
391 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
392 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
393 {"inlines", no_argument
, 0, OPTION_INLINES
},
394 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
395 {0, no_argument
, 0, 0}
399 nonfatal (const char *msg
)
405 /* Returns a version of IN with any control characters
406 replaced by escape sequences. Uses a static buffer
410 sanitize_string (const char * in
)
412 static char * buffer
= NULL
;
413 static size_t buffer_len
= 0;
414 const char * original
= in
;
421 /* See if any conversion is necessary. In the majority
422 of cases it will not be needed. */
435 /* Copy the input, translating as needed. */
437 if (buffer_len
< (strlen (in
) * 2))
439 free ((void *) buffer
);
440 buffer_len
= strlen (in
) * 2;
441 buffer
= xmalloc (buffer_len
+ 1);
467 /* Returns TRUE if the specified section should be dumped. */
470 process_section_p (asection
* section
)
474 if (only_list
== NULL
)
477 for (only
= only_list
; only
; only
= only
->next
)
478 if (strcmp (only
->name
, section
->name
) == 0)
487 /* Add an entry to the 'only' list. */
490 add_only (char * name
)
494 /* First check to make sure that we do not
495 already have an entry for this name. */
496 for (only
= only_list
; only
; only
= only
->next
)
497 if (strcmp (only
->name
, name
) == 0)
500 only
= xmalloc (sizeof * only
);
503 only
->next
= only_list
;
507 /* Release the memory used by the 'only' list.
508 PR 11225: Issue a warning message for unseen sections.
509 Only do this if none of the sections were seen. This is mainly to support
510 tools like the GAS testsuite where an object file is dumped with a list of
511 generic section names known to be present in a range of different file
515 free_only_list (void)
517 bfd_boolean at_least_one_seen
= FALSE
;
521 if (only_list
== NULL
)
524 for (only
= only_list
; only
; only
= only
->next
)
527 at_least_one_seen
= TRUE
;
531 for (only
= only_list
; only
; only
= next
)
533 if (! at_least_one_seen
)
535 non_fatal (_("section '%s' mentioned in a -j option, "
536 "but not found in any input file"),
547 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
550 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
551 int longest_section_name
= *((int *) data
);
553 /* Ignore linker created section. See elfNN_ia64_object_p in
555 if (section
->flags
& SEC_LINKER_CREATED
)
558 /* PR 10413: Skip sections that we are ignoring. */
559 if (! process_section_p (section
))
562 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
563 sanitize_string (bfd_section_name (section
)),
564 (unsigned long) bfd_section_size (section
) / opb
);
565 bfd_printf_vma (abfd
, bfd_section_vma (section
));
567 bfd_printf_vma (abfd
, section
->lma
);
568 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
569 bfd_section_alignment (section
));
575 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
577 PF (SEC_HAS_CONTENTS
, "CONTENTS");
578 PF (SEC_ALLOC
, "ALLOC");
579 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
580 PF (SEC_LOAD
, "LOAD");
581 PF (SEC_RELOC
, "RELOC");
582 PF (SEC_READONLY
, "READONLY");
583 PF (SEC_CODE
, "CODE");
584 PF (SEC_DATA
, "DATA");
586 PF (SEC_DEBUGGING
, "DEBUGGING");
587 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
588 PF (SEC_EXCLUDE
, "EXCLUDE");
589 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
590 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
592 PF (SEC_TIC54X_BLOCK
, "BLOCK");
593 PF (SEC_TIC54X_CLINK
, "CLINK");
595 PF (SEC_SMALL_DATA
, "SMALL_DATA");
596 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
598 PF (SEC_COFF_SHARED
, "SHARED");
599 PF (SEC_COFF_NOREAD
, "NOREAD");
601 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
603 PF (SEC_ELF_OCTETS
, "OCTETS");
604 PF (SEC_ELF_PURECODE
, "PURECODE");
606 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
607 PF (SEC_GROUP
, "GROUP");
608 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
610 PF (SEC_MEP_VLIW
, "VLIW");
613 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
616 struct coff_comdat_info
*comdat
;
618 switch (section
->flags
& SEC_LINK_DUPLICATES
)
622 case SEC_LINK_DUPLICATES_DISCARD
:
623 ls
= "LINK_ONCE_DISCARD";
625 case SEC_LINK_DUPLICATES_ONE_ONLY
:
626 ls
= "LINK_ONCE_ONE_ONLY";
628 case SEC_LINK_DUPLICATES_SAME_SIZE
:
629 ls
= "LINK_ONCE_SAME_SIZE";
631 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
632 ls
= "LINK_ONCE_SAME_CONTENTS";
635 printf ("%s%s", comma
, ls
);
637 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
639 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
648 /* Called on each SECTION in ABFD, update the int variable pointed to by
649 DATA which contains the string length of the longest section name. */
652 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
653 asection
*section
, void *data
)
655 int *longest_so_far
= (int *) data
;
659 /* Ignore linker created section. */
660 if (section
->flags
& SEC_LINKER_CREATED
)
663 /* Skip sections that we are ignoring. */
664 if (! process_section_p (section
))
667 name
= bfd_section_name (section
);
668 len
= (int) strlen (name
);
669 if (len
> *longest_so_far
)
670 *longest_so_far
= len
;
674 dump_headers (bfd
*abfd
)
676 /* The default width of 13 is just an arbitrary choice. */
677 int max_section_name_length
= 13;
683 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
684 if (bfd_get_arch_size (abfd
) == 32)
690 printf (_("Sections:\n"));
693 bfd_map_over_sections (abfd
, find_longest_section_name
,
694 &max_section_name_length
);
696 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
697 max_section_name_length
, "Name",
698 bfd_vma_width
, "VMA",
699 bfd_vma_width
, "LMA");
702 printf (_(" Flags"));
705 bfd_map_over_sections (abfd
, dump_section_header
,
706 &max_section_name_length
);
710 slurp_symtab (bfd
*abfd
)
715 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
721 storage
= bfd_get_symtab_upper_bound (abfd
);
724 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
725 bfd_fatal (_("error message was"));
729 off_t filesize
= bfd_get_file_size (abfd
);
733 && filesize
< storage
734 /* The MMO file format supports its own special compression
735 technique, so its sections can be larger than the file size. */
736 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
738 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
739 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
740 storage
, (long) filesize
);
746 sy
= (asymbol
**) xmalloc (storage
);
749 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
751 bfd_fatal (bfd_get_filename (abfd
));
755 /* Read in the dynamic symbols. */
758 slurp_dynamic_symtab (bfd
*abfd
)
763 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
766 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
768 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
774 bfd_fatal (bfd_get_filename (abfd
));
777 sy
= (asymbol
**) xmalloc (storage
);
779 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
781 bfd_fatal (bfd_get_filename (abfd
));
785 /* Some symbol names are significant and should be kept in the
786 table of sorted symbol names, even if they are marked as
787 debugging/section symbols. */
790 is_significant_symbol_name (const char * name
)
792 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
795 /* Filter out (in place) symbols that are useless for disassembly.
796 COUNT is the number of elements in SYMBOLS.
797 Return the number of useful symbols. */
800 remove_useless_symbols (asymbol
**symbols
, long count
)
802 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
806 asymbol
*sym
= *in_ptr
++;
808 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
810 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
811 && ! is_significant_symbol_name (sym
->name
))
813 if (bfd_is_und_section (sym
->section
)
814 || bfd_is_com_section (sym
->section
))
819 return out_ptr
- symbols
;
822 static const asection
*compare_section
;
824 /* Sort symbols into value order. */
827 compare_symbols (const void *ap
, const void *bp
)
829 const asymbol
*a
= * (const asymbol
**) ap
;
830 const asymbol
*b
= * (const asymbol
**) bp
;
835 bfd_boolean as
, af
, bs
, bf
;
839 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
841 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
844 /* Prefer symbols from the section currently being disassembled.
845 Don't sort symbols from other sections by section, since there
846 isn't much reason to prefer one section over another otherwise.
847 See sym_ok comment for why we compare by section name. */
848 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
849 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
855 an
= bfd_asymbol_name (a
);
856 bn
= bfd_asymbol_name (b
);
860 /* The symbols gnu_compiled and gcc2_compiled convey no real
861 information, so put them after other symbols with the same value. */
862 af
= (strstr (an
, "gnu_compiled") != NULL
863 || strstr (an
, "gcc2_compiled") != NULL
);
864 bf
= (strstr (bn
, "gnu_compiled") != NULL
865 || strstr (bn
, "gcc2_compiled") != NULL
);
872 /* We use a heuristic for the file name, to try to sort it after
873 more useful symbols. It may not work on non Unix systems, but it
874 doesn't really matter; the only difference is precisely which
875 symbol names get printed. */
877 #define file_symbol(s, sn, snl) \
878 (((s)->flags & BSF_FILE) != 0 \
880 && (sn)[(snl) - 2] == '.' \
881 && ((sn)[(snl) - 1] == 'o' \
882 || (sn)[(snl) - 1] == 'a')))
884 af
= file_symbol (a
, an
, anl
);
885 bf
= file_symbol (b
, bn
, bnl
);
892 /* Sort function and object symbols before global symbols before
893 local symbols before section symbols before debugging symbols. */
898 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
900 if ((aflags
& BSF_DEBUGGING
) != 0)
905 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
907 if ((aflags
& BSF_SECTION_SYM
) != 0)
912 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
914 if ((aflags
& BSF_FUNCTION
) != 0)
919 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
921 if ((aflags
& BSF_OBJECT
) != 0)
926 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
928 if ((aflags
& BSF_LOCAL
) != 0)
933 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
935 if ((aflags
& BSF_GLOBAL
) != 0)
941 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
942 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
947 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
948 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
950 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
951 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
953 return asz
> bsz
? -1 : 1;
956 /* Symbols that start with '.' might be section names, so sort them
957 after symbols that don't start with '.'. */
958 if (an
[0] == '.' && bn
[0] != '.')
960 if (an
[0] != '.' && bn
[0] == '.')
963 /* Finally, if we can't distinguish them in any other way, try to
964 get consistent results by sorting the symbols by name. */
965 return strcmp (an
, bn
);
968 /* Sort relocs into address order. */
971 compare_relocs (const void *ap
, const void *bp
)
973 const arelent
*a
= * (const arelent
**) ap
;
974 const arelent
*b
= * (const arelent
**) bp
;
976 if (a
->address
> b
->address
)
978 else if (a
->address
< b
->address
)
981 /* So that associated relocations tied to the same address show up
982 in the correct order, we don't do any further sorting. */
991 /* Print an address (VMA) to the output stream in INFO.
992 If SKIP_ZEROES is TRUE, omit leading zeroes. */
995 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
996 bfd_boolean skip_zeroes
)
1000 struct objdump_disasm_info
*aux
;
1002 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1003 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1008 for (p
= buf
; *p
== '0'; ++p
)
1013 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1016 /* Print the name of a symbol. */
1019 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1023 const char *name
, *version_string
= NULL
;
1024 bfd_boolean hidden
= FALSE
;
1027 name
= bfd_asymbol_name (sym
);
1028 if (do_demangle
&& name
[0] != '\0')
1030 /* Demangle the name. */
1031 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1036 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1037 version_string
= bfd_get_symbol_version_string (abfd
, sym
, TRUE
,
1040 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1043 name
= sanitize_string (name
);
1047 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1048 if (version_string
&& *version_string
!= '\0')
1049 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1054 printf ("%s", name
);
1055 if (version_string
&& *version_string
!= '\0')
1056 printf (hidden
? "@%s" : "@@%s", version_string
);
1063 static inline bfd_boolean
1064 sym_ok (bfd_boolean want_section
,
1065 bfd
* abfd ATTRIBUTE_UNUSED
,
1068 struct disassemble_info
* inf
)
1072 /* NB: An object file can have different sections with the same
1073 section name. Compare compare section pointers if they have
1075 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1076 && sorted_syms
[place
]->section
!= sec
)
1079 /* Note - we cannot just compare section pointers because they could
1080 be different, but the same... Ie the symbol that we are trying to
1081 find could have come from a separate debug info file. Under such
1082 circumstances the symbol will be associated with a section in the
1083 debug info file, whilst the section we want is in a normal file.
1084 So the section pointers will be different, but the section names
1085 will be the same. */
1086 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1087 bfd_section_name (sec
)) != 0)
1091 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1094 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1095 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1096 require the symbol to be in the section. Returns NULL if there is no
1097 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1098 of the symbol in sorted_syms. */
1101 find_symbol_for_address (bfd_vma vma
,
1102 struct disassemble_info
*inf
,
1105 /* @@ Would it speed things up to cache the last two symbols returned,
1106 and maybe their address ranges? For many processors, only one memory
1107 operand can be present at a time, so the 2-entry cache wouldn't be
1108 constantly churned by code doing heavy memory accesses. */
1110 /* Indices in `sorted_syms'. */
1112 long max_count
= sorted_symcount
;
1114 struct objdump_disasm_info
*aux
;
1118 bfd_boolean want_section
;
1121 if (sorted_symcount
< 1)
1124 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1127 opb
= inf
->octets_per_byte
;
1129 /* Perform a binary search looking for the closest symbol to the
1130 required value. We are searching the range (min, max_count]. */
1131 while (min
+ 1 < max_count
)
1135 thisplace
= (max_count
+ min
) / 2;
1136 sym
= sorted_syms
[thisplace
];
1138 if (bfd_asymbol_value (sym
) > vma
)
1139 max_count
= thisplace
;
1140 else if (bfd_asymbol_value (sym
) < vma
)
1149 /* The symbol we want is now in min, the low end of the range we
1150 were searching. If there are several symbols with the same
1151 value, we want the first one. */
1153 while (thisplace
> 0
1154 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1155 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1158 /* Prefer a symbol in the current section if we have multple symbols
1159 with the same value, as can occur with overlays or zero size
1162 while (min
< max_count
1163 && (bfd_asymbol_value (sorted_syms
[min
])
1164 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1166 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1173 return sorted_syms
[thisplace
];
1178 /* If the file is relocatable, and the symbol could be from this
1179 section, prefer a symbol from this section over symbols from
1180 others, even if the other symbol's value might be closer.
1182 Note that this may be wrong for some symbol references if the
1183 sections have overlapping memory ranges, but in that case there's
1184 no way to tell what's desired without looking at the relocation
1187 Also give the target a chance to reject symbols. */
1188 want_section
= (aux
->require_sec
1189 || ((abfd
->flags
& HAS_RELOC
) != 0
1190 && vma
>= bfd_section_vma (sec
)
1191 && vma
< (bfd_section_vma (sec
)
1192 + bfd_section_size (sec
) / opb
)));
1194 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1197 long newplace
= sorted_symcount
;
1199 for (i
= min
- 1; i
>= 0; i
--)
1201 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1203 if (newplace
== sorted_symcount
)
1206 if (bfd_asymbol_value (sorted_syms
[i
])
1207 != bfd_asymbol_value (sorted_syms
[newplace
]))
1210 /* Remember this symbol and keep searching until we reach
1211 an earlier address. */
1216 if (newplace
!= sorted_symcount
)
1217 thisplace
= newplace
;
1220 /* We didn't find a good symbol with a smaller value.
1221 Look for one with a larger value. */
1222 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1224 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1232 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1233 /* There is no suitable symbol. */
1237 /* If we have not found an exact match for the specified address
1238 and we have dynamic relocations available, then we can produce
1239 a better result by matching a relocation to the address and
1240 using the symbol associated with that relocation. */
1241 rel_count
= aux
->dynrelcount
;
1243 && sorted_syms
[thisplace
]->value
!= vma
1245 && aux
->dynrelbuf
!= NULL
1246 && aux
->dynrelbuf
[0]->address
<= vma
1247 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1248 /* If we have matched a synthetic symbol, then stick with that. */
1249 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1252 arelent
** rel_high
;
1254 rel_low
= aux
->dynrelbuf
;
1255 rel_high
= rel_low
+ rel_count
- 1;
1256 while (rel_low
<= rel_high
)
1258 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1259 arelent
* rel
= *rel_mid
;
1261 if (rel
->address
== vma
)
1263 /* Absolute relocations do not provide a more helpful
1264 symbolic address. Find a non-absolute relocation
1265 with the same address. */
1266 arelent
**rel_vma
= rel_mid
;
1268 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1272 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1276 if (rel
->sym_ptr_ptr
!= NULL
1277 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1280 * place
= thisplace
;
1281 return * rel
->sym_ptr_ptr
;
1287 if (vma
< rel
->address
)
1289 else if (vma
>= rel_mid
[1]->address
)
1290 rel_low
= rel_mid
+ 1;
1299 return sorted_syms
[thisplace
];
1302 /* Print an address and the offset to the nearest symbol. */
1305 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1306 bfd_vma vma
, struct disassemble_info
*inf
,
1307 bfd_boolean skip_zeroes
)
1311 objdump_print_value (vma
, inf
, skip_zeroes
);
1312 (*inf
->fprintf_func
) (inf
->stream
, " ");
1319 (*inf
->fprintf_func
) (inf
->stream
, "<%s",
1320 sanitize_string (bfd_section_name (sec
)));
1321 secaddr
= bfd_section_vma (sec
);
1324 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1325 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1327 else if (vma
> secaddr
)
1329 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1330 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1332 (*inf
->fprintf_func
) (inf
->stream
, ">");
1336 (*inf
->fprintf_func
) (inf
->stream
, "<");
1338 objdump_print_symname (abfd
, inf
, sym
);
1340 if (bfd_asymbol_value (sym
) == vma
)
1342 /* Undefined symbols in an executables and dynamic objects do not have
1343 a value associated with them, so it does not make sense to display
1344 an offset relative to them. Normally we would not be provided with
1345 this kind of symbol, but the target backend might choose to do so,
1346 and the code in find_symbol_for_address might return an as yet
1347 unresolved symbol associated with a dynamic reloc. */
1348 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1349 && bfd_is_und_section (sym
->section
))
1351 else if (bfd_asymbol_value (sym
) > vma
)
1353 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1354 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1356 else if (vma
> bfd_asymbol_value (sym
))
1358 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1359 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1362 (*inf
->fprintf_func
) (inf
->stream
, ">");
1365 if (display_file_offsets
)
1366 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1367 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1370 /* Print an address (VMA), symbolically if possible.
1371 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1374 objdump_print_addr (bfd_vma vma
,
1375 struct disassemble_info
*inf
,
1376 bfd_boolean skip_zeroes
)
1378 struct objdump_disasm_info
*aux
;
1379 asymbol
*sym
= NULL
;
1380 bfd_boolean skip_find
= FALSE
;
1382 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1384 if (sorted_symcount
< 1)
1388 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1389 objdump_print_value (vma
, inf
, skip_zeroes
);
1392 if (display_file_offsets
)
1393 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1394 (long int) (inf
->section
->filepos
1395 + (vma
- inf
->section
->vma
)));
1399 if (aux
->reloc
!= NULL
1400 && aux
->reloc
->sym_ptr_ptr
!= NULL
1401 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1403 sym
= * aux
->reloc
->sym_ptr_ptr
;
1405 /* Adjust the vma to the reloc. */
1406 vma
+= bfd_asymbol_value (sym
);
1408 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1413 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1415 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1419 /* Print VMA to INFO. This function is passed to the disassembler
1423 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1425 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1428 /* Determine if the given address has a symbol associated with it. */
1431 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1435 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1437 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1440 /* Hold the last function name and the last line number we displayed
1441 in a disassembly. */
1443 static char *prev_functionname
;
1444 static unsigned int prev_line
;
1445 static unsigned int prev_discriminator
;
1447 /* We keep a list of all files that we have seen when doing a
1448 disassembly with source, so that we know how much of the file to
1449 display. This can be important for inlined functions. */
1451 struct print_file_list
1453 struct print_file_list
*next
;
1454 const char *filename
;
1455 const char *modname
;
1458 const char **linemap
;
1461 unsigned max_printed
;
1465 static struct print_file_list
*print_files
;
1467 /* The number of preceding context lines to show when we start
1468 displaying a file for the first time. */
1470 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1472 /* Read a complete file into memory. */
1475 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1478 int ps
= getpagesize ();
1482 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1486 if (fstat (fd
, fst
) < 0)
1491 *size
= fst
->st_size
;
1493 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1494 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1495 if (map
!= (char *) -1L)
1501 map
= (const char *) malloc (*size
);
1502 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1504 free ((void *) map
);
1511 #define line_map_decrease 5
1513 /* Precompute array of lines for a mapped file. */
1515 static const char **
1516 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1518 const char *p
, *lstart
, *end
;
1519 int chars_per_line
= 45; /* First iteration will use 40. */
1520 unsigned int lineno
;
1521 const char **linemap
= NULL
;
1522 unsigned long line_map_size
= 0;
1528 for (p
= map
; p
< end
; p
++)
1532 if (p
+ 1 < end
&& p
[1] == '\r')
1535 else if (*p
== '\r')
1537 if (p
+ 1 < end
&& p
[1] == '\n')
1543 /* End of line found. */
1545 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1547 unsigned long newsize
;
1549 chars_per_line
-= line_map_decrease
;
1550 if (chars_per_line
<= 1)
1552 line_map_size
= size
/ chars_per_line
+ 1;
1553 if (line_map_size
< lineno
+ 1)
1554 line_map_size
= lineno
+ 1;
1555 newsize
= line_map_size
* sizeof (char *);
1556 linemap
= (const char **) xrealloc (linemap
, newsize
);
1559 linemap
[lineno
++] = lstart
;
1567 /* Tries to open MODNAME, and if successful adds a node to print_files
1568 linked list and returns that node. Returns NULL on failure. */
1570 static struct print_file_list
*
1571 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1573 struct print_file_list
*p
;
1575 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1577 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1584 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1587 p
->filename
= origname
;
1588 p
->modname
= modname
;
1589 p
->next
= print_files
;
1595 /* If the source file, as described in the symtab, is not found
1596 try to locate it in one of the paths specified with -I
1597 If found, add location to print_files linked list. */
1599 static struct print_file_list
*
1600 update_source_path (const char *filename
, bfd
*abfd
)
1602 struct print_file_list
*p
;
1607 p
= try_print_file_open (filename
, filename
, &fst
);
1610 if (include_path_count
== 0)
1613 /* Get the name of the file. */
1614 fname
= lbasename (filename
);
1616 /* If file exists under a new path, we need to add it to the list
1617 so that show_line knows about it. */
1618 for (i
= 0; i
< include_path_count
; i
++)
1620 char *modname
= concat (include_paths
[i
], "/", fname
,
1623 p
= try_print_file_open (filename
, modname
, &fst
);
1633 long mtime
= bfd_get_mtime (abfd
);
1635 if (fst
.st_mtime
> mtime
)
1636 warn (_("source file %s is more recent than object file\n"),
1643 /* Print a source file line. */
1646 print_line (struct print_file_list
*p
, unsigned int linenum
)
1652 if (linenum
>= p
->maxline
)
1654 l
= p
->linemap
[linenum
];
1655 if (source_comment
!= NULL
&& strlen (l
) > 0)
1656 printf ("%s", source_comment
);
1657 len
= strcspn (l
, "\n\r");
1658 /* Test fwrite return value to quiet glibc warning. */
1659 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1663 /* Print a range of source code lines. */
1666 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1670 while (start
<= end
)
1672 print_line (p
, start
);
1677 /* Show the line number, or the source line, in a disassembly
1681 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1683 const char *filename
;
1684 const char *functionname
;
1685 unsigned int linenumber
;
1686 unsigned int discriminator
;
1690 if (! with_line_numbers
&& ! with_source_code
)
1693 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1694 &filename
, &functionname
,
1695 &linenumber
, &discriminator
))
1698 if (filename
!= NULL
&& *filename
== '\0')
1700 if (functionname
!= NULL
&& *functionname
== '\0')
1701 functionname
= NULL
;
1704 && IS_ABSOLUTE_PATH (filename
)
1708 const char *fname
= filename
;
1710 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1713 memcpy (path
, prefix
, prefix_length
);
1714 path_up
= path
+ prefix_length
;
1716 /* Build relocated filename, stripping off leading directories
1717 from the initial filename if requested. */
1718 if (prefix_strip
> 0)
1723 /* Skip selected directory levels. */
1724 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1725 if (IS_DIR_SEPARATOR (*s
))
1732 /* Update complete filename. */
1733 strncpy (path_up
, fname
, PATH_MAX
);
1734 path_up
[PATH_MAX
] = '\0';
1742 if (with_line_numbers
)
1744 if (functionname
!= NULL
1745 && (prev_functionname
== NULL
1746 || strcmp (functionname
, prev_functionname
) != 0))
1748 char *demangle_alloc
= NULL
;
1749 if (do_demangle
&& functionname
[0] != '\0')
1751 /* Demangle the name. */
1752 demangle_alloc
= bfd_demangle (abfd
, functionname
,
1756 /* Demangling adds trailing parens, so don't print those. */
1757 if (demangle_alloc
!= NULL
)
1758 printf ("%s:\n", sanitize_string (demangle_alloc
));
1760 printf ("%s():\n", sanitize_string (functionname
));
1763 free (demangle_alloc
);
1766 && (linenumber
!= prev_line
1767 || discriminator
!= prev_discriminator
))
1769 if (discriminator
> 0)
1770 printf ("%s:%u (discriminator %u)\n",
1771 filename
== NULL
? "???" : sanitize_string (filename
),
1772 linenumber
, discriminator
);
1774 printf ("%s:%u\n", filename
== NULL
1775 ? "???" : sanitize_string (filename
),
1780 const char *filename2
;
1781 const char *functionname2
;
1784 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1787 printf ("inlined by %s:%u",
1788 sanitize_string (filename2
), line2
);
1789 printf (" (%s)\n", sanitize_string (functionname2
));
1794 if (with_source_code
1798 struct print_file_list
**pp
, *p
;
1801 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1802 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1809 filename
= xstrdup (filename
);
1810 p
= update_source_path (filename
, abfd
);
1813 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1815 if (file_start_context
&& p
->first
)
1819 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1820 if (l
>= linenumber
)
1822 if (p
->max_printed
>= l
)
1824 if (p
->max_printed
< linenumber
)
1825 l
= p
->max_printed
+ 1;
1830 dump_lines (p
, l
, linenumber
);
1831 if (p
->max_printed
< linenumber
)
1832 p
->max_printed
= linenumber
;
1833 p
->last_line
= linenumber
;
1838 if (functionname
!= NULL
1839 && (prev_functionname
== NULL
1840 || strcmp (functionname
, prev_functionname
) != 0))
1842 if (prev_functionname
!= NULL
)
1843 free (prev_functionname
);
1844 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1845 strcpy (prev_functionname
, functionname
);
1848 if (linenumber
> 0 && linenumber
!= prev_line
)
1849 prev_line
= linenumber
;
1851 if (discriminator
!= prev_discriminator
)
1852 prev_discriminator
= discriminator
;
1858 /* Pseudo FILE object for strings. */
1866 /* sprintf to a "stream". */
1868 static int ATTRIBUTE_PRINTF_2
1869 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1876 size_t space
= f
->alloc
- f
->pos
;
1878 va_start (args
, format
);
1879 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1885 f
->alloc
= (f
->alloc
+ n
) * 2;
1886 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1893 /* Code for generating (colored) diagrams of control flow start and end
1896 /* Structure used to store the properties of a jump. */
1900 /* The next jump, or NULL if this is the last object. */
1901 struct jump_info
*next
;
1902 /* The previous jump, or NULL if this is the first object. */
1903 struct jump_info
*prev
;
1904 /* The start addresses of the jump. */
1907 /* The list of start addresses. */
1909 /* The number of elements. */
1911 /* The maximum number of elements that fit into the array. */
1914 /* The end address of the jump. */
1916 /* The drawing level of the jump. */
1920 /* Construct a jump object for a jump from start
1921 to end with the corresponding level. */
1923 static struct jump_info
*
1924 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1926 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1928 result
->next
= NULL
;
1929 result
->prev
= NULL
;
1930 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1931 result
->start
.addresses
[0] = start
;
1932 result
->start
.count
= 1;
1933 result
->start
.max_count
= 2;
1935 result
->level
= level
;
1940 /* Free a jump object and return the next object
1941 or NULL if this was the last one. */
1943 static struct jump_info
*
1944 jump_info_free (struct jump_info
*ji
)
1946 struct jump_info
*result
= NULL
;
1951 if (ji
->start
.addresses
)
1952 free (ji
->start
.addresses
);
1959 /* Get the smallest value of all start and end addresses. */
1962 jump_info_min_address (const struct jump_info
*ji
)
1964 bfd_vma min_address
= ji
->end
;
1967 for (i
= ji
->start
.count
; i
-- > 0;)
1968 if (ji
->start
.addresses
[i
] < min_address
)
1969 min_address
= ji
->start
.addresses
[i
];
1973 /* Get the largest value of all start and end addresses. */
1976 jump_info_max_address (const struct jump_info
*ji
)
1978 bfd_vma max_address
= ji
->end
;
1981 for (i
= ji
->start
.count
; i
-- > 0;)
1982 if (ji
->start
.addresses
[i
] > max_address
)
1983 max_address
= ji
->start
.addresses
[i
];
1987 /* Get the target address of a jump. */
1990 jump_info_end_address (const struct jump_info
*ji
)
1995 /* Test if an address is one of the start addresses of a jump. */
1998 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2000 bfd_boolean result
= FALSE
;
2003 for (i
= ji
->start
.count
; i
-- > 0;)
2004 if (address
== ji
->start
.addresses
[i
])
2013 /* Test if an address is the target address of a jump. */
2016 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2018 return (address
== ji
->end
);
2021 /* Get the difference between the smallest and largest address of a jump. */
2024 jump_info_size (const struct jump_info
*ji
)
2026 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2029 /* Unlink a jump object from a list. */
2032 jump_info_unlink (struct jump_info
*node
,
2033 struct jump_info
**base
)
2036 node
->next
->prev
= node
->prev
;
2038 node
->prev
->next
= node
->next
;
2045 /* Insert unlinked jump info node into a list. */
2048 jump_info_insert (struct jump_info
*node
,
2049 struct jump_info
*target
,
2050 struct jump_info
**base
)
2052 node
->next
= target
;
2053 node
->prev
= target
->prev
;
2054 target
->prev
= node
;
2056 node
->prev
->next
= node
;
2061 /* Add unlinked node to the front of a list. */
2064 jump_info_add_front (struct jump_info
*node
,
2065 struct jump_info
**base
)
2069 node
->next
->prev
= node
;
2074 /* Move linked node to target position. */
2077 jump_info_move_linked (struct jump_info
*node
,
2078 struct jump_info
*target
,
2079 struct jump_info
**base
)
2082 jump_info_unlink (node
, base
);
2083 /* Insert node at target position. */
2084 jump_info_insert (node
, target
, base
);
2087 /* Test if two jumps intersect. */
2090 jump_info_intersect (const struct jump_info
*a
,
2091 const struct jump_info
*b
)
2093 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2094 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2097 /* Merge two compatible jump info objects. */
2100 jump_info_merge (struct jump_info
**base
)
2102 struct jump_info
*a
;
2104 for (a
= *base
; a
; a
= a
->next
)
2106 struct jump_info
*b
;
2108 for (b
= a
->next
; b
; b
= b
->next
)
2110 /* Merge both jumps into one. */
2111 if (a
->end
== b
->end
)
2113 /* Reallocate addresses. */
2114 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2117 if (needed_size
> a
->start
.max_count
)
2119 a
->start
.max_count
+= b
->start
.max_count
;
2120 a
->start
.addresses
=
2121 xrealloc (a
->start
.addresses
,
2122 a
->start
.max_count
* sizeof (bfd_vma
*));
2125 /* Append start addresses. */
2126 for (i
= 0; i
< b
->start
.count
; ++i
)
2127 a
->start
.addresses
[a
->start
.count
++] =
2128 b
->start
.addresses
[i
];
2130 /* Remove and delete jump. */
2131 struct jump_info
*tmp
= b
->prev
;
2132 jump_info_unlink (b
, base
);
2140 /* Sort jumps by their size and starting point using a stable
2141 minsort. This could be improved if sorting performance is
2142 an issue, for example by using mergesort. */
2145 jump_info_sort (struct jump_info
**base
)
2147 struct jump_info
*current_element
= *base
;
2149 while (current_element
)
2151 struct jump_info
*best_match
= current_element
;
2152 struct jump_info
*runner
= current_element
->next
;
2153 bfd_vma best_size
= jump_info_size (best_match
);
2157 bfd_vma runner_size
= jump_info_size (runner
);
2159 if ((runner_size
< best_size
)
2160 || ((runner_size
== best_size
)
2161 && (jump_info_min_address (runner
)
2162 < jump_info_min_address (best_match
))))
2164 best_match
= runner
;
2165 best_size
= runner_size
;
2168 runner
= runner
->next
;
2171 if (best_match
== current_element
)
2172 current_element
= current_element
->next
;
2174 jump_info_move_linked (best_match
, current_element
, base
);
2178 /* Visualize all jumps at a given address. */
2181 jump_info_visualize_address (bfd_vma address
,
2184 uint8_t *color_buffer
)
2186 struct jump_info
*ji
= detected_jumps
;
2187 size_t len
= (max_level
+ 1) * 3;
2189 /* Clear line buffer. */
2190 memset (line_buffer
, ' ', len
);
2191 memset (color_buffer
, 0, len
);
2193 /* Iterate over jumps and add their ASCII art. */
2196 /* Discard jumps that are never needed again. */
2197 if (jump_info_max_address (ji
) < address
)
2199 struct jump_info
*tmp
= ji
;
2202 jump_info_unlink (tmp
, &detected_jumps
);
2203 jump_info_free (tmp
);
2207 /* This jump intersects with the current address. */
2208 if (jump_info_min_address (ji
) <= address
)
2210 /* Hash target address to get an even
2211 distribution between all values. */
2212 bfd_vma hash_address
= jump_info_end_address (ji
);
2213 uint8_t color
= iterative_hash_object (hash_address
, 0);
2214 /* Fetch line offset. */
2215 int offset
= (max_level
- ji
->level
) * 3;
2217 /* Draw start line. */
2218 if (jump_info_is_start_address (ji
, address
))
2220 size_t i
= offset
+ 1;
2222 for (; i
< len
- 1; ++i
)
2223 if (line_buffer
[i
] == ' ')
2225 line_buffer
[i
] = '-';
2226 color_buffer
[i
] = color
;
2229 if (line_buffer
[i
] == ' ')
2231 line_buffer
[i
] = '-';
2232 color_buffer
[i
] = color
;
2234 else if (line_buffer
[i
] == '>')
2236 line_buffer
[i
] = 'X';
2237 color_buffer
[i
] = color
;
2240 if (line_buffer
[offset
] == ' ')
2242 if (address
<= ji
->end
)
2243 line_buffer
[offset
] =
2244 (jump_info_min_address (ji
) == address
) ? '/': '+';
2246 line_buffer
[offset
] =
2247 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2248 color_buffer
[offset
] = color
;
2251 /* Draw jump target. */
2252 else if (jump_info_is_end_address (ji
, address
))
2254 size_t i
= offset
+ 1;
2256 for (; i
< len
- 1; ++i
)
2257 if (line_buffer
[i
] == ' ')
2259 line_buffer
[i
] = '-';
2260 color_buffer
[i
] = color
;
2263 if (line_buffer
[i
] == ' ')
2265 line_buffer
[i
] = '>';
2266 color_buffer
[i
] = color
;
2268 else if (line_buffer
[i
] == '-')
2270 line_buffer
[i
] = 'X';
2271 color_buffer
[i
] = color
;
2274 if (line_buffer
[offset
] == ' ')
2276 if (jump_info_min_address (ji
) < address
)
2277 line_buffer
[offset
] =
2278 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2280 line_buffer
[offset
] = '/';
2281 color_buffer
[offset
] = color
;
2284 /* Draw intermediate line segment. */
2285 else if (line_buffer
[offset
] == ' ')
2287 line_buffer
[offset
] = '|';
2288 color_buffer
[offset
] = color
;
2296 /* Clone of disassemble_bytes to detect jumps inside a function. */
2297 /* FIXME: is this correct? Can we strip it down even further? */
2299 static struct jump_info
*
2300 disassemble_jumps (struct disassemble_info
* inf
,
2301 disassembler_ftype disassemble_fn
,
2302 bfd_vma start_offset
,
2303 bfd_vma stop_offset
,
2306 arelent
** relppend
)
2308 struct objdump_disasm_info
*aux
;
2309 struct jump_info
*jumps
= NULL
;
2311 bfd_vma addr_offset
;
2312 unsigned int opb
= inf
->octets_per_byte
;
2316 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2317 section
= inf
->section
;
2320 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2323 inf
->insn_info_valid
= 0;
2324 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2325 inf
->stream
= &sfile
;
2327 addr_offset
= start_offset
;
2328 while (addr_offset
< stop_offset
)
2330 int previous_octets
;
2332 /* Remember the length of the previous instruction. */
2333 previous_octets
= octets
;
2337 inf
->bytes_per_line
= 0;
2338 inf
->bytes_per_chunk
= 0;
2339 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2340 | (wide_output
? WIDE_OUTPUT
: 0));
2342 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2344 if (inf
->disassembler_needs_relocs
2345 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2346 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2347 && *relppp
< relppend
)
2349 bfd_signed_vma distance_to_rel
;
2351 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2353 /* Check to see if the current reloc is associated with
2354 the instruction that we are about to disassemble. */
2355 if (distance_to_rel
== 0
2356 /* FIXME: This is wrong. We are trying to catch
2357 relocs that are addressed part way through the
2358 current instruction, as might happen with a packed
2359 VLIW instruction. Unfortunately we do not know the
2360 length of the current instruction since we have not
2361 disassembled it yet. Instead we take a guess based
2362 upon the length of the previous instruction. The
2363 proper solution is to have a new target-specific
2364 disassembler function which just returns the length
2365 of an instruction at a given address without trying
2366 to display its disassembly. */
2367 || (distance_to_rel
> 0
2368 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2370 inf
->flags
|= INSN_HAS_RELOC
;
2374 if (! disassemble_all
2375 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2376 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2377 /* Set a stop_vma so that the disassembler will not read
2378 beyond the next symbol. We assume that symbols appear on
2379 the boundaries between instructions. We only do this when
2380 disassembling code of course, and when -D is in effect. */
2381 inf
->stop_vma
= section
->vma
+ stop_offset
;
2383 inf
->stop_offset
= stop_offset
;
2385 /* Extract jump information. */
2386 inf
->insn_info_valid
= 0;
2387 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2388 /* Test if a jump was detected. */
2389 if (inf
->insn_info_valid
2390 && ((inf
->insn_type
== dis_branch
)
2391 || (inf
->insn_type
== dis_condbranch
)
2392 || (inf
->insn_type
== dis_jsr
)
2393 || (inf
->insn_type
== dis_condjsr
))
2394 && (inf
->target
>= section
->vma
+ start_offset
)
2395 && (inf
->target
< section
->vma
+ stop_offset
))
2397 struct jump_info
*ji
=
2398 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2399 jump_info_add_front (ji
, &jumps
);
2404 addr_offset
+= octets
/ opb
;
2407 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2408 inf
->stream
= stdout
;
2410 free (sfile
.buffer
);
2413 jump_info_merge (&jumps
);
2414 /* Process jumps. */
2415 jump_info_sort (&jumps
);
2417 /* Group jumps by level. */
2418 struct jump_info
*last_jump
= jumps
;
2423 /* The last jump is part of the next group. */
2424 struct jump_info
*base
= last_jump
;
2425 /* Increment level. */
2426 base
->level
= ++max_level
;
2428 /* Find jumps that can be combined on the same
2429 level, with the largest jumps tested first.
2430 This has the advantage that large jumps are on
2431 lower levels and do not intersect with small
2432 jumps that get grouped on higher levels. */
2433 struct jump_info
*exchange_item
= last_jump
->next
;
2434 struct jump_info
*it
= exchange_item
;
2436 for (; it
; it
= it
->next
)
2438 /* Test if the jump intersects with any
2439 jump from current group. */
2440 bfd_boolean ok
= TRUE
;
2441 struct jump_info
*it_collision
;
2443 for (it_collision
= base
;
2444 it_collision
!= exchange_item
;
2445 it_collision
= it_collision
->next
)
2447 /* This jump intersects so we leave it out. */
2448 if (jump_info_intersect (it_collision
, it
))
2455 /* Add jump to group. */
2458 /* Move current element to the front. */
2459 if (it
!= exchange_item
)
2461 struct jump_info
*save
= it
->prev
;
2462 jump_info_move_linked (it
, exchange_item
, &jumps
);
2468 last_jump
= exchange_item
;
2469 exchange_item
= exchange_item
->next
;
2471 last_jump
->level
= max_level
;
2475 /* Move to next group. */
2476 last_jump
= exchange_item
;
2482 /* The number of zeroes we want to see before we start skipping them.
2483 The number is arbitrarily chosen. */
2485 #define DEFAULT_SKIP_ZEROES 8
2487 /* The number of zeroes to skip at the end of a section. If the
2488 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2489 SKIP_ZEROES, they will be disassembled. If there are fewer than
2490 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2491 attempt to avoid disassembling zeroes inserted by section
2494 #define DEFAULT_SKIP_ZEROES_AT_END 3
2497 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2502 /* Print out jump visualization. */
2505 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2506 uint8_t *color_buffer
)
2511 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2513 size_t line_buffer_size
= strlen (line_buffer
);
2514 char last_color
= 0;
2517 for (i
= 0; i
<= line_buffer_size
; ++i
)
2521 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2523 if (color
!= last_color
)
2526 if (extended_color_output
)
2527 /* Use extended 8bit color, but
2528 do not choose dark colors. */
2529 printf ("\033[38;5;%dm", 124 + (color
% 108));
2531 /* Use simple terminal colors. */
2532 printf ("\033[%dm", 31 + (color
% 7));
2539 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2543 /* Disassemble some data in memory between given values. */
2546 disassemble_bytes (struct disassemble_info
* inf
,
2547 disassembler_ftype disassemble_fn
,
2550 bfd_vma start_offset
,
2551 bfd_vma stop_offset
,
2554 arelent
** relppend
)
2556 struct objdump_disasm_info
*aux
;
2558 int octets_per_line
;
2559 int skip_addr_chars
;
2560 bfd_vma addr_offset
;
2561 unsigned int opb
= inf
->octets_per_byte
;
2562 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2563 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2567 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2568 section
= inf
->section
;
2571 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2575 octets_per_line
= insn_width
;
2577 octets_per_line
= 4;
2579 octets_per_line
= 16;
2581 /* Figure out how many characters to skip at the start of an
2582 address, to make the disassembly look nicer. We discard leading
2583 zeroes in chunks of 4, ensuring that there is always a leading
2585 skip_addr_chars
= 0;
2586 if (!no_addresses
&& !prefix_addresses
)
2590 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2592 while (buf
[skip_addr_chars
] == '0')
2595 /* Don't discard zeros on overflow. */
2596 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2597 skip_addr_chars
= 0;
2599 if (skip_addr_chars
!= 0)
2600 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2603 inf
->insn_info_valid
= 0;
2605 /* Determine maximum level. */
2606 uint8_t *color_buffer
= NULL
;
2607 char *line_buffer
= NULL
;
2610 /* Some jumps were detected. */
2613 struct jump_info
*ji
;
2615 /* Find maximum jump level. */
2616 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2618 if (ji
->level
> max_level
)
2619 max_level
= ji
->level
;
2622 /* Allocate buffers. */
2623 size_t len
= (max_level
+ 1) * 3 + 1;
2624 line_buffer
= xmalloc (len
);
2625 line_buffer
[len
- 1] = 0;
2626 color_buffer
= xmalloc (len
);
2627 color_buffer
[len
- 1] = 0;
2630 addr_offset
= start_offset
;
2631 while (addr_offset
< stop_offset
)
2634 bfd_boolean need_nl
= FALSE
;
2638 /* Make sure we don't use relocs from previous instructions. */
2641 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2643 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2646 if (! disassemble_zeroes
2647 && (inf
->insn_info_valid
== 0
2648 || inf
->branch_delay_insns
== 0)
2649 && (z
- addr_offset
* opb
>= skip_zeroes
2650 || (z
== stop_offset
* opb
&&
2651 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2653 /* If there are more nonzero octets to follow, we only skip
2654 zeroes in multiples of 4, to try to avoid running over
2655 the start of an instruction which happens to start with
2657 if (z
!= stop_offset
* opb
)
2658 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2660 octets
= z
- addr_offset
* opb
;
2662 /* If we are going to display more data, and we are displaying
2663 file offsets, then tell the user how many zeroes we skip
2664 and the file offset from where we resume dumping. */
2665 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2666 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2668 (unsigned long) (section
->filepos
2669 + (addr_offset
+ (octets
/ opb
))));
2679 if (with_line_numbers
|| with_source_code
)
2680 show_line (aux
->abfd
, section
, addr_offset
);
2684 else if (!prefix_addresses
)
2688 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2689 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2693 printf ("%s:\t", buf
+ skip_addr_chars
);
2697 aux
->require_sec
= TRUE
;
2698 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2699 aux
->require_sec
= FALSE
;
2703 print_jump_visualisation (section
->vma
+ addr_offset
,
2704 max_level
, line_buffer
,
2710 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2711 inf
->stream
= &sfile
;
2712 inf
->bytes_per_line
= 0;
2713 inf
->bytes_per_chunk
= 0;
2714 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2715 | (wide_output
? WIDE_OUTPUT
: 0));
2717 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2719 if (inf
->disassembler_needs_relocs
2720 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2721 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2722 && *relppp
< relppend
)
2724 bfd_signed_vma distance_to_rel
;
2726 int max_reloc_offset
2727 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2729 distance_to_rel
= ((**relppp
)->address
- rel_offset
2732 if (distance_to_rel
> 0
2733 && (max_reloc_offset
< 0
2734 || distance_to_rel
<= max_reloc_offset
))
2736 /* This reloc *might* apply to the current insn,
2737 starting somewhere inside it. Discover the length
2738 of the current insn so that the check below will
2741 insn_size
= insn_width
;
2744 /* We find the length by calling the dissassembler
2745 function with a dummy print handler. This should
2746 work unless the disassembler is not expecting to
2747 be called multiple times for the same address.
2749 This does mean disassembling the instruction
2750 twice, but we only do this when there is a high
2751 probability that there is a reloc that will
2752 affect the instruction. */
2753 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2754 insn_size
= disassemble_fn (section
->vma
2755 + addr_offset
, inf
);
2756 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2760 /* Check to see if the current reloc is associated with
2761 the instruction that we are about to disassemble. */
2762 if (distance_to_rel
== 0
2763 || (distance_to_rel
> 0
2764 && distance_to_rel
< insn_size
/ (int) opb
))
2766 inf
->flags
|= INSN_HAS_RELOC
;
2767 aux
->reloc
= **relppp
;
2771 if (! disassemble_all
2772 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2773 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2774 /* Set a stop_vma so that the disassembler will not read
2775 beyond the next symbol. We assume that symbols appear on
2776 the boundaries between instructions. We only do this when
2777 disassembling code of course, and when -D is in effect. */
2778 inf
->stop_vma
= section
->vma
+ stop_offset
;
2780 inf
->stop_offset
= stop_offset
;
2781 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2784 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2785 inf
->stream
= stdout
;
2786 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2787 octets_per_line
= inf
->bytes_per_line
;
2788 if (octets
< (int) opb
)
2791 printf ("%s\n", sfile
.buffer
);
2794 non_fatal (_("disassemble_fn returned length %d"),
2805 octets
= octets_per_line
;
2806 if (addr_offset
+ octets
/ opb
> stop_offset
)
2807 octets
= (stop_offset
- addr_offset
) * opb
;
2809 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2811 if (ISPRINT (data
[j
]))
2812 buf
[j
- addr_offset
* opb
] = data
[j
];
2814 buf
[j
- addr_offset
* opb
] = '.';
2816 buf
[j
- addr_offset
* opb
] = '\0';
2819 if (prefix_addresses
2821 : show_raw_insn
>= 0)
2825 /* If ! prefix_addresses and ! wide_output, we print
2826 octets_per_line octets per line. */
2828 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2829 pb
= octets_per_line
;
2831 if (inf
->bytes_per_chunk
)
2832 bpc
= inf
->bytes_per_chunk
;
2836 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2838 /* PR 21580: Check for a buffer ending early. */
2839 if (j
+ bpc
<= stop_offset
* opb
)
2843 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2845 for (k
= bpc
- 1; k
>= 0; k
--)
2846 printf ("%02x", (unsigned) data
[j
+ k
]);
2850 for (k
= 0; k
< bpc
; k
++)
2851 printf ("%02x", (unsigned) data
[j
+ k
]);
2857 for (; pb
< octets_per_line
; pb
+= bpc
)
2861 for (k
= 0; k
< bpc
; k
++)
2866 /* Separate raw data from instruction by extra space. */
2876 printf ("%s", sfile
.buffer
);
2878 if (prefix_addresses
2880 : show_raw_insn
>= 0)
2888 j
= addr_offset
* opb
+ pb
;
2894 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2895 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2899 printf ("%s:\t", buf
+ skip_addr_chars
);
2902 print_jump_visualisation (section
->vma
+ j
/ opb
,
2903 max_level
, line_buffer
,
2906 pb
+= octets_per_line
;
2909 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2911 /* PR 21619: Check for a buffer ending early. */
2912 if (j
+ bpc
<= stop_offset
* opb
)
2916 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2918 for (k
= bpc
- 1; k
>= 0; k
--)
2919 printf ("%02x", (unsigned) data
[j
+ k
]);
2923 for (k
= 0; k
< bpc
; k
++)
2924 printf ("%02x", (unsigned) data
[j
+ k
]);
2938 while ((*relppp
) < relppend
2939 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2941 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2954 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2959 if (q
->howto
== NULL
)
2960 printf ("*unknown*\t");
2961 else if (q
->howto
->name
)
2962 printf ("%s\t", q
->howto
->name
);
2964 printf ("%d\t", q
->howto
->type
);
2966 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2967 printf ("*unknown*");
2970 const char *sym_name
;
2972 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2973 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2974 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2979 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2980 sym_name
= bfd_section_name (sym_sec
);
2981 if (sym_name
== NULL
|| *sym_name
== '\0')
2982 sym_name
= "*unknown*";
2983 printf ("%s", sanitize_string (sym_name
));
2989 bfd_signed_vma addend
= q
->addend
;
2997 objdump_print_value (addend
, inf
, TRUE
);
3009 addr_offset
+= octets
/ opb
;
3012 free (sfile
.buffer
);
3014 free (color_buffer
);
3018 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3020 const struct elf_backend_data
* bed
;
3021 bfd_vma sign_adjust
= 0;
3022 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
3023 struct objdump_disasm_info
* paux
;
3024 unsigned int opb
= pinfo
->octets_per_byte
;
3025 bfd_byte
* data
= NULL
;
3026 bfd_size_type datasize
= 0;
3027 arelent
** rel_pp
= NULL
;
3028 arelent
** rel_ppstart
= NULL
;
3029 arelent
** rel_ppend
;
3030 bfd_vma stop_offset
;
3031 asymbol
* sym
= NULL
;
3035 unsigned long addr_offset
;
3036 bfd_boolean do_print
;
3039 stop_offset_reached
,
3044 /* Sections that do not contain machine
3045 code are not normally disassembled. */
3046 if (! disassemble_all
3047 && only_list
== NULL
3048 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3049 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3052 if (! process_section_p (section
))
3055 datasize
= bfd_section_size (section
);
3059 if (start_address
== (bfd_vma
) -1
3060 || start_address
< section
->vma
)
3063 addr_offset
= start_address
- section
->vma
;
3065 if (stop_address
== (bfd_vma
) -1)
3066 stop_offset
= datasize
/ opb
;
3069 if (stop_address
< section
->vma
)
3072 stop_offset
= stop_address
- section
->vma
;
3073 if (stop_offset
> datasize
/ opb
)
3074 stop_offset
= datasize
/ opb
;
3077 if (addr_offset
>= stop_offset
)
3080 /* Decide which set of relocs to use. Load them if necessary. */
3081 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3082 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3084 rel_pp
= paux
->dynrelbuf
;
3085 rel_count
= paux
->dynrelcount
;
3086 /* Dynamic reloc addresses are absolute, non-dynamic are section
3087 relative. REL_OFFSET specifies the reloc address corresponding
3088 to the start of this section. */
3089 rel_offset
= section
->vma
;
3097 if ((section
->flags
& SEC_RELOC
) != 0
3098 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3102 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3104 bfd_fatal (bfd_get_filename (abfd
));
3108 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3109 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3111 bfd_fatal (bfd_get_filename (abfd
));
3113 /* Sort the relocs by address. */
3114 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3118 rel_ppend
= rel_pp
+ rel_count
;
3120 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3122 non_fatal (_("Reading section %s failed because: %s"),
3123 section
->name
, bfd_errmsg (bfd_get_error ()));
3127 pinfo
->buffer
= data
;
3128 pinfo
->buffer_vma
= section
->vma
;
3129 pinfo
->buffer_length
= datasize
;
3130 pinfo
->section
= section
;
3132 /* Sort the symbols into value and section order. */
3133 compare_section
= section
;
3134 if (sorted_symcount
> 1)
3135 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3137 /* Skip over the relocs belonging to addresses below the
3139 while (rel_pp
< rel_ppend
3140 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3143 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3145 /* Find the nearest symbol forwards from our current position. */
3146 paux
->require_sec
= TRUE
;
3147 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3148 (struct disassemble_info
*) inf
,
3150 paux
->require_sec
= FALSE
;
3152 /* PR 9774: If the target used signed addresses then we must make
3153 sure that we sign extend the value that we calculate for 'addr'
3154 in the loop below. */
3155 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3156 && (bed
= get_elf_backend_data (abfd
)) != NULL
3157 && bed
->sign_extend_vma
)
3158 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3160 /* Disassemble a block of instructions up to the address associated with
3161 the symbol we have just found. Then print the symbol and find the
3162 next symbol on. Repeat until we have disassembled the entire section
3163 or we have reached the end of the address range we are interested in. */
3164 do_print
= paux
->symbol
== NULL
;
3165 loop_until
= stop_offset_reached
;
3167 while (addr_offset
< stop_offset
)
3171 bfd_vma nextstop_offset
;
3174 addr
= section
->vma
+ addr_offset
;
3175 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3177 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3182 (x
< sorted_symcount
3183 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3187 pinfo
->symbols
= sorted_syms
+ place
;
3188 pinfo
->num_symbols
= x
- place
;
3189 pinfo
->symtab_pos
= place
;
3193 pinfo
->symbols
= NULL
;
3194 pinfo
->num_symbols
= 0;
3195 pinfo
->symtab_pos
= -1;
3198 /* If we are only disassembling from a specific symbol,
3199 check to see if we should start or stop displaying. */
3200 if (sym
&& paux
->symbol
)
3204 /* See if we should stop printing. */
3208 if (sym
->flags
& BSF_FUNCTION
)
3212 case stop_offset_reached
:
3213 /* Handled by the while loop. */
3217 /* FIXME: There is an implicit assumption here
3218 that the name of sym is different from
3220 if (! bfd_is_local_label (abfd
, sym
))
3227 const char * name
= bfd_asymbol_name (sym
);
3228 char * alloc
= NULL
;
3230 if (do_demangle
&& name
[0] != '\0')
3232 /* Demangle the name. */
3233 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3238 /* We are not currently printing. Check to see
3239 if the current symbol matches the requested symbol. */
3240 if (streq (name
, paux
->symbol
))
3244 if (sym
->flags
& BSF_FUNCTION
)
3246 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3247 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3249 /* Sym is a function symbol with a size associated
3250 with it. Turn on automatic disassembly for the
3251 next VALUE bytes. */
3252 stop_offset
= addr_offset
3253 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3254 loop_until
= stop_offset_reached
;
3258 /* Otherwise we need to tell the loop heuristic to
3259 loop until the next function symbol is encountered. */
3260 loop_until
= function_sym
;
3265 /* Otherwise loop until the next symbol is encountered. */
3266 loop_until
= next_sym
;
3274 if (! prefix_addresses
&& do_print
)
3276 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3277 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3279 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3282 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3284 else if (sym
== NULL
)
3288 #define is_valid_next_sym(SYM) \
3289 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3290 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3291 && pinfo->symbol_is_valid (SYM, pinfo))
3293 /* Search forward for the next appropriate symbol in
3294 SECTION. Note that all the symbols are sorted
3295 together into one big array, and that some sections
3296 may have overlapping addresses. */
3297 while (place
< sorted_symcount
3298 && ! is_valid_next_sym (sorted_syms
[place
]))
3301 if (place
>= sorted_symcount
)
3304 nextsym
= sorted_syms
[place
];
3307 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3308 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3309 else if (nextsym
== NULL
)
3310 nextstop_offset
= stop_offset
;
3312 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3314 if (nextstop_offset
> stop_offset
3315 || nextstop_offset
<= addr_offset
)
3316 nextstop_offset
= stop_offset
;
3318 /* If a symbol is explicitly marked as being an object
3319 rather than a function, just dump the bytes without
3320 disassembling them. */
3323 || sym
->section
!= section
3324 || bfd_asymbol_value (sym
) > addr
3325 || ((sym
->flags
& BSF_OBJECT
) == 0
3326 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3328 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3330 || (sym
->flags
& BSF_FUNCTION
) != 0)
3337 /* Resolve symbol name. */
3338 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3340 struct disassemble_info di
;
3343 sf
.alloc
= strlen (sym
->name
) + 40;
3344 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3346 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3349 objdump_print_symname (abfd
, &di
, sym
);
3351 /* Fetch jump information. */
3352 detected_jumps
= disassemble_jumps
3353 (pinfo
, paux
->disassemble_fn
,
3354 addr_offset
, nextstop_offset
,
3355 rel_offset
, &rel_pp
, rel_ppend
);
3357 /* Free symbol name. */
3361 /* Add jumps to output. */
3362 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3363 addr_offset
, nextstop_offset
,
3364 rel_offset
, &rel_pp
, rel_ppend
);
3367 while (detected_jumps
)
3369 detected_jumps
= jump_info_free (detected_jumps
);
3373 addr_offset
= nextstop_offset
;
3379 if (rel_ppstart
!= NULL
)
3383 /* Disassemble the contents of an object file. */
3386 disassemble_data (bfd
*abfd
)
3388 struct disassemble_info disasm_info
;
3389 struct objdump_disasm_info aux
;
3393 prev_functionname
= NULL
;
3395 prev_discriminator
= 0;
3397 /* We make a copy of syms to sort. We don't want to sort syms
3398 because that will screw up the relocs. */
3399 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3400 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3401 * sizeof (asymbol
*));
3402 if (sorted_symcount
!= 0)
3404 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3405 sorted_symcount
* sizeof (asymbol
*));
3407 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3410 for (i
= 0; i
< synthcount
; ++i
)
3412 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3416 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3418 disasm_info
.application_data
= (void *) &aux
;
3420 aux
.require_sec
= FALSE
;
3421 aux
.dynrelbuf
= NULL
;
3422 aux
.dynrelcount
= 0;
3424 aux
.symbol
= disasm_sym
;
3426 disasm_info
.print_address_func
= objdump_print_address
;
3427 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3429 if (machine
!= NULL
)
3431 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3434 fatal (_("can't use supplied machine %s"), machine
);
3436 abfd
->arch_info
= inf
;
3439 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3441 struct bfd_target
*xvec
;
3443 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3444 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3445 xvec
->byteorder
= endian
;
3449 /* Use libopcodes to locate a suitable disassembler. */
3450 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3451 bfd_big_endian (abfd
),
3452 bfd_get_mach (abfd
), abfd
);
3453 if (!aux
.disassemble_fn
)
3455 non_fatal (_("can't disassemble for architecture %s\n"),
3456 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3461 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3462 disasm_info
.arch
= bfd_get_arch (abfd
);
3463 disasm_info
.mach
= bfd_get_mach (abfd
);
3464 disasm_info
.disassembler_options
= disassembler_options
;
3465 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3466 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3467 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3468 disasm_info
.disassembler_needs_relocs
= FALSE
;
3470 if (bfd_big_endian (abfd
))
3471 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3472 else if (bfd_little_endian (abfd
))
3473 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3475 /* ??? Aborting here seems too drastic. We could default to big or little
3477 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3479 /* Allow the target to customize the info structure. */
3480 disassemble_init_for_target (& disasm_info
);
3482 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3484 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3486 if (relsize
< 0 && dump_dynamic_reloc_info
)
3487 bfd_fatal (bfd_get_filename (abfd
));
3491 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3492 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3495 if (aux
.dynrelcount
< 0)
3496 bfd_fatal (bfd_get_filename (abfd
));
3498 /* Sort the relocs by address. */
3499 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3503 disasm_info
.symtab
= sorted_syms
;
3504 disasm_info
.symtab_size
= sorted_symcount
;
3506 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3508 if (aux
.dynrelbuf
!= NULL
)
3509 free (aux
.dynrelbuf
);
3511 disassemble_free_target (&disasm_info
);
3515 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3516 asection
*sec
, void *file
)
3518 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3519 bfd
*abfd
= (bfd
*) file
;
3524 if (section
->start
!= NULL
)
3526 /* If it is already loaded, do nothing. */
3527 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3529 free (section
->start
);
3532 section
->filename
= bfd_get_filename (abfd
);
3533 section
->reloc_info
= NULL
;
3534 section
->num_relocs
= 0;
3535 section
->address
= bfd_section_vma (sec
);
3536 section
->user_data
= sec
;
3537 section
->size
= bfd_section_size (sec
);
3538 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3539 alloced
= amt
= section
->size
+ 1;
3540 if (alloced
!= amt
|| alloced
== 0)
3542 section
->start
= NULL
;
3543 free_debug_section (debug
);
3544 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3545 sanitize_string (section
->name
),
3546 (unsigned long long) section
->size
);
3549 section
->start
= contents
= malloc (alloced
);
3550 if (section
->start
== NULL
3551 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3553 free_debug_section (debug
);
3554 printf (_("\nCan't get contents for section '%s'.\n"),
3555 sanitize_string (section
->name
));
3558 /* Ensure any string section has a terminating NUL. */
3559 section
->start
[section
->size
] = 0;
3561 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3562 && debug_displays
[debug
].relocate
)
3567 bfd_cache_section_contents (sec
, section
->start
);
3569 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3576 free_debug_section (debug
);
3577 printf (_("\nCan't get contents for section '%s'.\n"),
3578 sanitize_string (section
->name
));
3582 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3585 unsigned long reloc_count
;
3588 relocs
= (arelent
**) xmalloc (reloc_size
);
3590 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3591 if (reloc_count
== 0)
3595 section
->reloc_info
= relocs
;
3596 section
->num_relocs
= reloc_count
;
3605 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3610 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3613 relocs
= (arelent
**) dsec
->reloc_info
;
3615 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3616 if (rp
->address
== offset
)
3623 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3625 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3626 bfd
*abfd
= (bfd
*) file
;
3629 /* If it is already loaded, do nothing. */
3630 if (section
->start
!= NULL
)
3632 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3636 /* Locate the debug section. */
3637 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3639 section
->name
= section
->uncompressed_name
;
3642 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3644 section
->name
= section
->compressed_name
;
3649 return load_specific_debug_section (debug
, sec
, file
);
3653 free_debug_section (enum dwarf_section_display_enum debug
)
3655 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3657 if (section
->start
== NULL
)
3660 /* PR 17512: file: 0f67f69d. */
3661 if (section
->user_data
!= NULL
)
3663 asection
* sec
= (asection
*) section
->user_data
;
3665 /* If we are freeing contents that are also pointed to by the BFD
3666 library's section structure then make sure to update those pointers
3667 too. Otherwise, the next time we try to load data for this section
3668 we can end up using a stale pointer. */
3669 if (section
->start
== sec
->contents
)
3671 sec
->contents
= NULL
;
3672 sec
->flags
&= ~ SEC_IN_MEMORY
;
3673 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3677 free ((char *) section
->start
);
3678 section
->start
= NULL
;
3679 section
->address
= 0;
3684 close_debug_file (void * file
)
3686 bfd
* abfd
= (bfd
*) file
;
3692 open_debug_file (const char * pathname
)
3696 data
= bfd_openr (pathname
, NULL
);
3700 if (! bfd_check_format (data
, bfd_object
))
3706 #if HAVE_LIBDEBUGINFOD
3707 /* Return a hex string represention of the build-id. */
3710 get_build_id (void * data
)
3713 char * build_id_str
;
3714 bfd
* abfd
= (bfd
*) data
;
3715 const struct bfd_build_id
* build_id
;
3717 build_id
= abfd
->build_id
;
3718 if (build_id
== NULL
)
3721 build_id_str
= malloc (build_id
->size
* 2 + 1);
3722 if (build_id_str
== NULL
)
3725 for (i
= 0; i
< build_id
->size
; i
++)
3726 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3727 build_id_str
[build_id
->size
* 2] = '\0';
3729 return (unsigned char *)build_id_str
;
3731 #endif /* HAVE_LIBDEBUGINFOD */
3734 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3735 void *arg ATTRIBUTE_UNUSED
)
3737 const char *name
= bfd_section_name (section
);
3741 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3742 match
= ".debug_info";
3746 for (i
= 0; i
< max
; i
++)
3747 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3748 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3749 && debug_displays
[i
].enabled
!= NULL
3750 && *debug_displays
[i
].enabled
)
3752 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3754 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3755 sec
->name
= sec
->uncompressed_name
;
3757 sec
->name
= sec
->compressed_name
;
3758 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3761 debug_displays
[i
].display (sec
, abfd
);
3763 if (i
!= info
&& i
!= abbrev
)
3764 free_debug_section ((enum dwarf_section_display_enum
) i
);
3770 /* Dump the dwarf debugging information. */
3773 dump_dwarf (bfd
*abfd
)
3775 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3776 if (byte_get
== NULL
)
3778 warn (_("File %s does not contain any dwarf debug information\n"),
3779 bfd_get_filename (abfd
));
3783 switch (bfd_get_arch (abfd
))
3786 /* S12Z has a 24 bit address space. But the only known
3787 producer of dwarf_info encodes addresses into 32 bits. */
3792 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3796 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3797 bfd_get_mach (abfd
));
3799 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3802 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3803 it. Return NULL on failure. */
3806 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3807 bfd_size_type
*entsize_ptr
)
3812 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3813 if (stabsect
== NULL
)
3815 printf (_("No %s section present\n\n"),
3816 sanitize_string (sect_name
));
3820 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3822 non_fatal (_("reading %s section of %s failed: %s"),
3823 sect_name
, bfd_get_filename (abfd
),
3824 bfd_errmsg (bfd_get_error ()));
3830 *size_ptr
= bfd_section_size (stabsect
);
3832 *entsize_ptr
= stabsect
->entsize
;
3837 /* Stabs entries use a 12 byte format:
3838 4 byte string table index
3840 1 byte stab other field
3841 2 byte stab desc field
3843 FIXME: This will have to change for a 64 bit object format. */
3845 #define STRDXOFF (0)
3847 #define OTHEROFF (5)
3850 #define STABSIZE (12)
3852 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3853 using string table section STRSECT_NAME (in `strtab'). */
3856 print_section_stabs (bfd
*abfd
,
3857 const char *stabsect_name
,
3858 unsigned *string_offset_ptr
)
3861 unsigned file_string_table_offset
= 0;
3862 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3863 bfd_byte
*stabp
, *stabs_end
;
3866 stabs_end
= stabp
+ stab_size
;
3868 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3869 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3871 /* Loop through all symbols and print them.
3873 We start the index at -1 because there is a dummy symbol on
3874 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3875 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3879 unsigned char type
, other
;
3880 unsigned short desc
;
3883 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3884 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3885 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3886 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3887 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3889 printf ("\n%-6d ", i
);
3890 /* Either print the stab name, or, if unnamed, print its number
3891 again (makes consistent formatting for tools like awk). */
3892 name
= bfd_get_stab_name (type
);
3894 printf ("%-6s", sanitize_string (name
));
3895 else if (type
== N_UNDF
)
3898 printf ("%-6d", type
);
3899 printf (" %-6d %-6d ", other
, desc
);
3900 bfd_printf_vma (abfd
, value
);
3901 printf (" %-6lu", strx
);
3903 /* Symbols with type == 0 (N_UNDF) specify the length of the
3904 string table associated with this file. We use that info
3905 to know how to relocate the *next* file's string table indices. */
3908 file_string_table_offset
= next_file_string_table_offset
;
3909 next_file_string_table_offset
+= value
;
3913 bfd_size_type amt
= strx
+ file_string_table_offset
;
3915 /* Using the (possibly updated) string table offset, print the
3916 string (if any) associated with this symbol. */
3917 if (amt
< stabstr_size
)
3918 /* PR 17512: file: 079-79389-0.001:0.1.
3919 FIXME: May need to sanitize this string before displaying. */
3920 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3926 *string_offset_ptr
= next_file_string_table_offset
;
3931 const char * section_name
;
3932 const char * string_section_name
;
3933 unsigned string_offset
;
3938 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3941 stab_section_names
* sought
= (stab_section_names
*) names
;
3943 /* Check for section names for which stabsect_name is a prefix, to
3944 handle .stab.N, etc. */
3945 len
= strlen (sought
->section_name
);
3947 /* If the prefix matches, and the files section name ends with a
3948 nul or a digit, then we match. I.e., we want either an exact
3949 match or a section followed by a number. */
3950 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3951 && (section
->name
[len
] == 0
3952 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3955 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3956 &stabstr_size
, NULL
);
3960 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3962 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3968 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3970 stab_section_names s
;
3972 s
.section_name
= stabsect_name
;
3973 s
.string_section_name
= strsect_name
;
3974 s
.string_offset
= 0;
3976 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3982 /* Dump the any sections containing stabs debugging information. */
3985 dump_stabs (bfd
*abfd
)
3987 dump_stabs_section (abfd
, ".stab", ".stabstr");
3988 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3989 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3992 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3994 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3998 dump_bfd_header (bfd
*abfd
)
4002 printf (_("architecture: %s, "),
4003 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4004 bfd_get_mach (abfd
)));
4005 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4007 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4008 PF (HAS_RELOC
, "HAS_RELOC");
4009 PF (EXEC_P
, "EXEC_P");
4010 PF (HAS_LINENO
, "HAS_LINENO");
4011 PF (HAS_DEBUG
, "HAS_DEBUG");
4012 PF (HAS_SYMS
, "HAS_SYMS");
4013 PF (HAS_LOCALS
, "HAS_LOCALS");
4014 PF (DYNAMIC
, "DYNAMIC");
4015 PF (WP_TEXT
, "WP_TEXT");
4016 PF (D_PAGED
, "D_PAGED");
4017 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4018 printf (_("\nstart address 0x"));
4019 bfd_printf_vma (abfd
, abfd
->start_address
);
4024 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4025 it is passed, or a pointer to newly-allocated storage, in which case
4026 dump_ctf() will free it when it no longer needs it. */
4029 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4032 const char *blanks
= arg
;
4035 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4040 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4042 make_ctfsect (const char *name
, bfd_byte
*data
,
4047 ctfsect
.cts_name
= name
;
4048 ctfsect
.cts_entsize
= 1;
4049 ctfsect
.cts_size
= size
;
4050 ctfsect
.cts_data
= data
;
4055 /* Dump one CTF archive member. */
4058 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4060 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4061 const char *things
[] = {"Header", "Labels", "Data objects",
4062 "Function objects", "Variables", "Types", "Strings",
4067 /* Only print out the name of non-default-named archive members.
4068 The name .ctf appears everywhere, even for things that aren't
4069 really archives, so printing it out is liable to be confusing.
4071 The parent, if there is one, is the default-owned archive member:
4072 avoid importing it into itself. (This does no harm, but looks
4075 if (strcmp (name
, ".ctf") != 0)
4077 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4078 ctf_import (ctf
, parent
);
4081 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4083 ctf_dump_state_t
*s
= NULL
;
4086 printf ("\n %s:\n", *thing
);
4087 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4088 (void *) " ")) != NULL
)
4090 printf ("%s\n", item
);
4094 if (ctf_errno (ctf
))
4096 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4097 ctf_errmsg (ctf_errno (ctf
)));
4104 /* Dump the CTF debugging information. */
4107 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4109 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4110 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4111 bfd_size_type ctfsize
, parentsize
;
4113 ctf_file_t
*parent
= NULL
;
4116 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4117 bfd_fatal (bfd_get_filename (abfd
));
4120 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4122 bfd_fatal (bfd_get_filename (abfd
));
4124 /* Load the CTF file and dump it. */
4126 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4127 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4129 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4130 bfd_fatal (bfd_get_filename (abfd
));
4135 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4136 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4138 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4139 bfd_fatal (bfd_get_filename (abfd
));
4142 lookparent
= parenta
;
4147 /* Assume that the applicable parent archive member is the default one.
4148 (This is what all known implementations are expected to do, if they
4149 put CTFs and their parents in archives together.) */
4150 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4152 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4153 bfd_fatal (bfd_get_filename (abfd
));
4156 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4158 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4159 ctf_file_close (parent
);
4161 ctf_close (parenta
);
4168 dump_bfd_private_header (bfd
*abfd
)
4170 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4171 non_fatal (_("warning: private headers incomplete: %s"),
4172 bfd_errmsg (bfd_get_error ()));
4176 dump_target_specific (bfd
*abfd
)
4178 const struct objdump_private_desc
* const *desc
;
4179 struct objdump_private_option
*opt
;
4182 /* Find the desc. */
4183 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4184 if ((*desc
)->filter (abfd
))
4189 non_fatal (_("option -P/--private not supported by this file"));
4193 /* Clear all options. */
4194 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4195 opt
->selected
= FALSE
;
4197 /* Decode options. */
4198 b
= dump_private_options
;
4201 e
= strchr (b
, ',');
4206 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4207 if (strcmp (opt
->name
, b
) == 0)
4209 opt
->selected
= TRUE
;
4212 if (opt
->name
== NULL
)
4213 non_fatal (_("target specific dump '%s' not supported"), b
);
4224 (*desc
)->dump (abfd
);
4227 /* Display a section in hexadecimal format with associated characters.
4228 Each line prefixed by the zero padded address. */
4231 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4233 bfd_byte
*data
= NULL
;
4234 bfd_size_type datasize
;
4235 bfd_vma addr_offset
;
4236 bfd_vma start_offset
;
4237 bfd_vma stop_offset
;
4238 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4239 /* Bytes per line. */
4240 const int onaline
= 16;
4245 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4248 if (! process_section_p (section
))
4251 if ((datasize
= bfd_section_size (section
)) == 0)
4254 /* Compute the address range to display. */
4255 if (start_address
== (bfd_vma
) -1
4256 || start_address
< section
->vma
)
4259 start_offset
= start_address
- section
->vma
;
4261 if (stop_address
== (bfd_vma
) -1)
4262 stop_offset
= datasize
/ opb
;
4265 if (stop_address
< section
->vma
)
4268 stop_offset
= stop_address
- section
->vma
;
4270 if (stop_offset
> datasize
/ opb
)
4271 stop_offset
= datasize
/ opb
;
4274 if (start_offset
>= stop_offset
)
4277 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4278 if (display_file_offsets
)
4279 printf (_(" (Starting at file offset: 0x%lx)"),
4280 (unsigned long) (section
->filepos
+ start_offset
));
4283 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4285 non_fatal (_("Reading section %s failed because: %s"),
4286 section
->name
, bfd_errmsg (bfd_get_error ()));
4292 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4293 if (strlen (buf
) >= sizeof (buf
))
4297 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4299 count
= strlen (buf
) - count
;
4303 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4304 if (strlen (buf
) >= sizeof (buf
))
4308 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4310 count
= strlen (buf
) - count
;
4314 for (addr_offset
= start_offset
;
4315 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4319 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4320 count
= strlen (buf
);
4321 if ((size_t) count
>= sizeof (buf
))
4325 while (count
< width
)
4330 fputs (buf
+ count
- width
, stdout
);
4333 for (j
= addr_offset
* opb
;
4334 j
< addr_offset
* opb
+ onaline
; j
++)
4336 if (j
< stop_offset
* opb
)
4337 printf ("%02x", (unsigned) (data
[j
]));
4345 for (j
= addr_offset
* opb
;
4346 j
< addr_offset
* opb
+ onaline
; j
++)
4348 if (j
>= stop_offset
* opb
)
4351 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4358 /* Actually display the various requested regions. */
4361 dump_data (bfd
*abfd
)
4363 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4366 /* Should perhaps share code and display with nm? */
4369 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4378 max_count
= dynsymcount
;
4379 printf ("DYNAMIC SYMBOL TABLE:\n");
4384 max_count
= symcount
;
4385 printf ("SYMBOL TABLE:\n");
4389 printf (_("no symbols\n"));
4391 for (count
= 0; count
< max_count
; count
++)
4395 if (*current
== NULL
)
4396 printf (_("no information for symbol number %ld\n"), count
);
4398 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4399 printf (_("could not determine the type of symbol number %ld\n"),
4402 else if (process_section_p ((* current
)->section
)
4403 && (dump_special_syms
4404 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4406 const char *name
= (*current
)->name
;
4408 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4412 /* If we want to demangle the name, we demangle it
4413 here, and temporarily clobber it while calling
4414 bfd_print_symbol. FIXME: This is a gross hack. */
4415 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4417 (*current
)->name
= alloc
;
4418 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4419 bfd_print_symbol_all
);
4422 (*current
)->name
= name
;
4427 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4428 bfd_print_symbol_all
);
4438 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4441 char *last_filename
, *last_functionname
;
4442 unsigned int last_line
;
4443 unsigned int last_discriminator
;
4445 /* Get column headers lined up reasonably. */
4453 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4454 width
= strlen (buf
) - 7;
4456 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4459 last_filename
= NULL
;
4460 last_functionname
= NULL
;
4462 last_discriminator
= 0;
4464 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4467 const char *filename
, *functionname
;
4468 unsigned int linenumber
;
4469 unsigned int discriminator
;
4470 const char *sym_name
;
4471 const char *section_name
;
4472 bfd_vma addend2
= 0;
4474 if (start_address
!= (bfd_vma
) -1
4475 && q
->address
< start_address
)
4477 if (stop_address
!= (bfd_vma
) -1
4478 && q
->address
> stop_address
)
4481 if (with_line_numbers
4483 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4484 &filename
, &functionname
,
4485 &linenumber
, &discriminator
))
4487 if (functionname
!= NULL
4488 && (last_functionname
== NULL
4489 || strcmp (functionname
, last_functionname
) != 0))
4491 printf ("%s():\n", sanitize_string (functionname
));
4492 if (last_functionname
!= NULL
)
4493 free (last_functionname
);
4494 last_functionname
= xstrdup (functionname
);
4498 && (linenumber
!= last_line
4499 || (filename
!= NULL
4500 && last_filename
!= NULL
4501 && filename_cmp (filename
, last_filename
) != 0)
4502 || (discriminator
!= last_discriminator
)))
4504 if (discriminator
> 0)
4505 printf ("%s:%u\n", filename
== NULL
? "???" :
4506 sanitize_string (filename
), linenumber
);
4508 printf ("%s:%u (discriminator %u)\n",
4509 filename
== NULL
? "???" : sanitize_string (filename
),
4510 linenumber
, discriminator
);
4511 last_line
= linenumber
;
4512 last_discriminator
= discriminator
;
4513 if (last_filename
!= NULL
)
4514 free (last_filename
);
4515 if (filename
== NULL
)
4516 last_filename
= NULL
;
4518 last_filename
= xstrdup (filename
);
4522 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4524 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4525 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4530 section_name
= NULL
;
4533 bfd_printf_vma (abfd
, q
->address
);
4534 if (q
->howto
== NULL
)
4535 printf (" *unknown* ");
4536 else if (q
->howto
->name
)
4538 const char *name
= q
->howto
->name
;
4540 /* R_SPARC_OLO10 relocations contain two addends.
4541 But because 'arelent' lacks enough storage to
4542 store them both, the 64-bit ELF Sparc backend
4543 records this as two relocations. One R_SPARC_LO10
4544 and one R_SPARC_13, both pointing to the same
4545 address. This is merely so that we have some
4546 place to store both addend fields.
4548 Undo this transformation, otherwise the output
4549 will be confusing. */
4550 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4551 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4553 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4555 arelent
*q2
= *(p
+ 1);
4558 && q
->address
== q2
->address
4559 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4561 name
= "R_SPARC_OLO10";
4562 addend2
= q2
->addend
;
4566 printf (" %-16s ", name
);
4569 printf (" %-16d ", q
->howto
->type
);
4573 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4577 if (section_name
== NULL
)
4578 section_name
= "*unknown*";
4579 printf ("[%s]", sanitize_string (section_name
));
4584 bfd_signed_vma addend
= q
->addend
;
4592 bfd_printf_vma (abfd
, addend
);
4597 bfd_printf_vma (abfd
, addend2
);
4603 if (last_filename
!= NULL
)
4604 free (last_filename
);
4605 if (last_functionname
!= NULL
)
4606 free (last_functionname
);
4610 dump_relocs_in_section (bfd
*abfd
,
4612 void *dummy ATTRIBUTE_UNUSED
)
4614 arelent
**relpp
= NULL
;
4618 if ( bfd_is_abs_section (section
)
4619 || bfd_is_und_section (section
)
4620 || bfd_is_com_section (section
)
4621 || (! process_section_p (section
))
4622 || ((section
->flags
& SEC_RELOC
) == 0))
4625 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4627 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4630 printf (" (none)\n\n");
4638 relpp
= (arelent
**) xmalloc (relsize
);
4639 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4645 non_fatal (_("failed to read relocs in: %s"),
4646 sanitize_string (bfd_get_filename (abfd
)));
4647 bfd_fatal (_("error message was"));
4649 else if (relcount
== 0)
4650 printf (" (none)\n\n");
4654 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4661 dump_relocs (bfd
*abfd
)
4663 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4667 dump_dynamic_relocs (bfd
*abfd
)
4673 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4675 bfd_fatal (bfd_get_filename (abfd
));
4677 printf ("DYNAMIC RELOCATION RECORDS");
4680 printf (" (none)\n\n");
4683 relpp
= (arelent
**) xmalloc (relsize
);
4684 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4687 bfd_fatal (bfd_get_filename (abfd
));
4688 else if (relcount
== 0)
4689 printf (" (none)\n\n");
4693 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4700 /* Creates a table of paths, to search for source files. */
4703 add_include_path (const char *path
)
4707 include_path_count
++;
4708 include_paths
= (const char **)
4709 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4710 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4711 if (path
[1] == ':' && path
[2] == 0)
4712 path
= concat (path
, ".", (const char *) 0);
4714 include_paths
[include_path_count
- 1] = path
;
4718 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4722 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4724 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4725 section
->vma
+= adjust_section_vma
;
4727 section
->lma
+= adjust_section_vma
;
4731 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4734 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4739 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4740 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4743 /* Dump selected contents of ABFD. */
4746 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4748 const struct elf_backend_data
* bed
;
4750 if (bfd_big_endian (abfd
))
4751 byte_get
= byte_get_big_endian
;
4752 else if (bfd_little_endian (abfd
))
4753 byte_get
= byte_get_little_endian
;
4757 /* Load any separate debug information files.
4758 We do this now and without checking do_follow_links because separate
4759 debug info files may contain symbol tables that we will need when
4760 displaying information about the main file. Any memory allocated by
4761 load_separate_debug_files will be released when we call
4762 free_debug_memory below.
4764 The test on is_mainfile is there because the chain of separate debug
4765 info files is a global variable shared by all invocations of dump_bfd. */
4768 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4770 /* If asked to do so, recursively dump the separate files. */
4771 if (do_follow_links
)
4775 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4776 dump_bfd (i
->handle
, FALSE
);
4780 /* Adjust user-specified start and stop limits for targets that use
4781 signed addresses. */
4782 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4783 && (bed
= get_elf_backend_data (abfd
)) != NULL
4784 && bed
->sign_extend_vma
)
4786 start_address
= sign_extend_address (abfd
, start_address
,
4788 stop_address
= sign_extend_address (abfd
, stop_address
,
4792 /* If we are adjusting section VMA's, change them all now. Changing
4793 the BFD information is a hack. However, we must do it, or
4794 bfd_find_nearest_line will not do the right thing. */
4795 if (adjust_section_vma
!= 0)
4797 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4798 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4801 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4802 printf (_("\n%s: file format %s\n"),
4803 sanitize_string (bfd_get_filename (abfd
)),
4806 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4807 if (dump_file_header
)
4808 dump_bfd_header (abfd
);
4809 if (dump_private_headers
)
4810 dump_bfd_private_header (abfd
);
4811 if (dump_private_options
!= NULL
)
4812 dump_target_specific (abfd
);
4813 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4820 || dump_dwarf_section_info
)
4822 syms
= slurp_symtab (abfd
);
4824 /* If following links, load any symbol tables from the linked files as well. */
4825 if (do_follow_links
&& is_mainfile
)
4829 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4831 asymbol
** extra_syms
;
4832 long old_symcount
= symcount
;
4834 extra_syms
= slurp_symtab (i
->handle
);
4838 if (old_symcount
== 0)
4844 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4845 memcpy (syms
+ old_symcount
,
4847 symcount
* sizeof (asymbol
*));
4851 symcount
+= old_symcount
;
4856 if (dump_section_headers
)
4857 dump_headers (abfd
);
4859 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4860 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4861 dynsyms
= slurp_dynamic_symtab (abfd
);
4865 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4866 dynsymcount
, dynsyms
, &synthsyms
);
4872 dump_symbols (abfd
, FALSE
);
4873 if (dump_dynamic_symtab
)
4874 dump_symbols (abfd
, TRUE
);
4875 if (dump_dwarf_section_info
)
4877 if (dump_ctf_section_info
)
4878 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4879 if (dump_stab_section_info
)
4881 if (dump_reloc_info
&& ! disassemble
)
4883 if (dump_dynamic_reloc_info
&& ! disassemble
)
4884 dump_dynamic_relocs (abfd
);
4885 if (dump_section_contents
)
4888 disassemble_data (abfd
);
4894 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4895 if (dhandle
!= NULL
)
4897 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4899 dump_debugging_tags
? TRUE
: FALSE
))
4901 non_fatal (_("%s: printing debugging information failed"),
4902 bfd_get_filename (abfd
));
4908 /* PR 6483: If there was no STABS debug info in the file, try
4910 else if (! dump_dwarf_section_info
)
4912 dwarf_select_sections_all ();
4940 free_debug_memory ();
4944 display_object_bfd (bfd
*abfd
)
4948 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4950 dump_bfd (abfd
, TRUE
);
4954 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4956 nonfatal (bfd_get_filename (abfd
));
4957 list_matching_formats (matching
);
4962 if (bfd_get_error () != bfd_error_file_not_recognized
)
4964 nonfatal (bfd_get_filename (abfd
));
4968 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4970 dump_bfd (abfd
, TRUE
);
4974 nonfatal (bfd_get_filename (abfd
));
4976 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4978 list_matching_formats (matching
);
4984 display_any_bfd (bfd
*file
, int level
)
4986 /* Decompress sections unless dumping the section contents. */
4987 if (!dump_section_contents
)
4988 file
->flags
|= BFD_DECOMPRESS
;
4990 /* If the file is an archive, process all of its elements. */
4991 if (bfd_check_format (file
, bfd_archive
))
4994 bfd
*last_arfile
= NULL
;
4997 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4998 else if (level
> 100)
5000 /* Prevent corrupted files from spinning us into an
5001 infinite loop. 100 is an arbitrary heuristic. */
5002 fatal (_("Archive nesting is too deep"));
5006 printf (_("In nested archive %s:\n"),
5007 sanitize_string (bfd_get_filename (file
)));
5011 bfd_set_error (bfd_error_no_error
);
5013 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5016 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5017 nonfatal (bfd_get_filename (file
));
5021 display_any_bfd (arfile
, level
+ 1);
5023 if (last_arfile
!= NULL
)
5025 bfd_close (last_arfile
);
5026 /* PR 17512: file: ac585d01. */
5027 if (arfile
== last_arfile
)
5033 last_arfile
= arfile
;
5036 if (last_arfile
!= NULL
)
5037 bfd_close (last_arfile
);
5040 display_object_bfd (file
);
5044 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5048 if (get_file_size (filename
) < 1)
5054 file
= bfd_openr (filename
, target
);
5057 nonfatal (filename
);
5061 display_any_bfd (file
, 0);
5063 /* This is an optimization to improve the speed of objdump, especially when
5064 dumping a file with lots of associated debug informatiom. Calling
5065 bfd_close on such a file can take a non-trivial amount of time as there
5066 are lots of lists to walk and buffers to free. This is only really
5067 necessary however if we are about to load another file and we need the
5068 memory back. Otherwise, if we are about to exit, then we can save (a lot
5069 of) time by only doing a quick close, and allowing the OS to reclaim the
5074 bfd_close_all_done (file
);
5078 main (int argc
, char **argv
)
5081 char *target
= default_target
;
5082 bfd_boolean seenflag
= FALSE
;
5084 #if defined (HAVE_SETLOCALE)
5085 #if defined (HAVE_LC_MESSAGES)
5086 setlocale (LC_MESSAGES
, "");
5088 setlocale (LC_CTYPE
, "");
5091 bindtextdomain (PACKAGE
, LOCALEDIR
);
5092 textdomain (PACKAGE
);
5094 program_name
= *argv
;
5095 xmalloc_set_program_name (program_name
);
5096 bfd_set_error_program_name (program_name
);
5098 START_PROGRESS (program_name
, 0);
5100 expandargv (&argc
, &argv
);
5102 if (bfd_init () != BFD_INIT_MAGIC
)
5103 fatal (_("fatal error: libbfd ABI mismatch"));
5104 set_default_bfd_target ();
5106 while ((c
= getopt_long (argc
, argv
,
5107 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5108 long_options
, (int *) 0))
5114 break; /* We've been given a long option. */
5121 if (disassembler_options
)
5122 /* Ignore potential memory leak for now. */
5123 options
= concat (disassembler_options
, ",",
5124 optarg
, (const char *) NULL
);
5127 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5134 display_file_offsets
= TRUE
;
5137 with_line_numbers
= TRUE
;
5146 enum demangling_styles style
;
5148 style
= cplus_demangle_name_to_style (optarg
);
5149 if (style
== unknown_demangling
)
5150 fatal (_("unknown demangling style `%s'"),
5153 cplus_demangle_set_style (style
);
5156 case OPTION_RECURSE_LIMIT
:
5157 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5159 case OPTION_NO_RECURSE_LIMIT
:
5160 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5163 do_wide
= wide_output
= TRUE
;
5165 case OPTION_ADJUST_VMA
:
5166 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5168 case OPTION_START_ADDRESS
:
5169 start_address
= parse_vma (optarg
, "--start-address");
5170 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5171 fatal (_("error: the start address should be before the end address"));
5173 case OPTION_STOP_ADDRESS
:
5174 stop_address
= parse_vma (optarg
, "--stop-address");
5175 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5176 fatal (_("error: the stop address should be after the start address"));
5180 prefix_length
= strlen (prefix
);
5181 /* Remove an unnecessary trailing '/' */
5182 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5185 case OPTION_PREFIX_STRIP
:
5186 prefix_strip
= atoi (optarg
);
5187 if (prefix_strip
< 0)
5188 fatal (_("error: prefix strip must be non-negative"));
5190 case OPTION_INSN_WIDTH
:
5191 insn_width
= strtoul (optarg
, NULL
, 0);
5192 if (insn_width
<= 0)
5193 fatal (_("error: instruction width must be positive"));
5195 case OPTION_INLINES
:
5196 unwind_inlines
= TRUE
;
5198 case OPTION_VISUALIZE_JUMPS
:
5199 visualize_jumps
= TRUE
;
5200 color_output
= FALSE
;
5201 extended_color_output
= FALSE
;
5204 if (streq (optarg
, "color"))
5205 color_output
= TRUE
;
5206 else if (streq (optarg
, "extended-color"))
5208 color_output
= TRUE
;
5209 extended_color_output
= TRUE
;
5211 else if (streq (optarg
, "off"))
5212 visualize_jumps
= FALSE
;
5214 nonfatal (_("unrecognized argument to --visualize-option"));
5218 if (strcmp (optarg
, "B") == 0)
5219 endian
= BFD_ENDIAN_BIG
;
5220 else if (strcmp (optarg
, "L") == 0)
5221 endian
= BFD_ENDIAN_LITTLE
;
5224 nonfatal (_("unrecognized -E option"));
5229 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5230 endian
= BFD_ENDIAN_BIG
;
5231 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5232 endian
= BFD_ENDIAN_LITTLE
;
5235 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5242 dump_file_header
= TRUE
;
5246 formats_info
= TRUE
;
5250 add_include_path (optarg
);
5253 dump_private_headers
= TRUE
;
5257 dump_private_options
= optarg
;
5261 dump_private_headers
= TRUE
;
5263 dump_reloc_info
= TRUE
;
5264 dump_file_header
= TRUE
;
5265 dump_ar_hdrs
= TRUE
;
5266 dump_section_headers
= TRUE
;
5274 dump_dynamic_symtab
= TRUE
;
5280 disasm_sym
= optarg
;
5283 disassemble_zeroes
= TRUE
;
5287 disassemble_all
= TRUE
;
5292 with_source_code
= TRUE
;
5295 case OPTION_SOURCE_COMMENT
:
5297 with_source_code
= TRUE
;
5300 source_comment
= xstrdup (sanitize_string (optarg
));
5302 source_comment
= xstrdup ("# ");
5310 dump_debugging_tags
= 1;
5315 dump_dwarf_section_info
= TRUE
;
5318 dwarf_select_sections_by_letters (optarg
);
5320 dwarf_select_sections_all ();
5323 dump_dwarf_section_info
= TRUE
;
5326 dwarf_select_sections_by_names (optarg
);
5328 dwarf_select_sections_all ();
5330 case OPTION_DWARF_DEPTH
:
5333 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5336 case OPTION_DWARF_START
:
5339 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5340 suppress_bfd_header
= 1;
5343 case OPTION_DWARF_CHECK
:
5347 dump_ctf_section_info
= TRUE
;
5348 dump_ctf_section_name
= xstrdup (optarg
);
5351 case OPTION_CTF_PARENT
:
5352 dump_ctf_parent_name
= xstrdup (optarg
);
5355 dump_stab_section_info
= TRUE
;
5359 dump_section_contents
= TRUE
;
5363 dump_reloc_info
= TRUE
;
5367 dump_dynamic_reloc_info
= TRUE
;
5371 dump_ar_hdrs
= TRUE
;
5375 dump_section_headers
= TRUE
;
5380 show_version
= TRUE
;
5386 /* No need to set seenflag or to break - usage() does not return. */
5393 print_version ("objdump");
5399 exit_status
= display_info ();
5403 display_file ("a.out", target
, TRUE
);
5405 for (; optind
< argc
;)
5407 display_file (argv
[optind
], target
, optind
== argc
- 1);
5413 free (dump_ctf_section_name
);
5414 free (dump_ctf_parent_name
);
5415 free ((void *) source_comment
);
5417 END_PROGRESS (program_name
);