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[lLiaprmfFsoORtUuTgAckK] or\n\
233 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
234 =frames-interp,=str,=str-offsets,=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 unsigned int octets_per_line
;
2559 unsigned 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
)
2633 bfd_boolean need_nl
= FALSE
;
2637 /* Make sure we don't use relocs from previous instructions. */
2640 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2642 if (! disassemble_zeroes
)
2643 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
2644 if (data
[addr_offset
* opb
+ octets
] != 0)
2646 if (! disassemble_zeroes
2647 && (inf
->insn_info_valid
== 0
2648 || inf
->branch_delay_insns
== 0)
2649 && (octets
>= skip_zeroes
2650 || (addr_offset
* opb
+ octets
== stop_offset
* opb
2651 && octets
< 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 (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
2660 /* If we are going to display more data, and we are displaying
2661 file offsets, then tell the user how many zeroes we skip
2662 and the file offset from where we resume dumping. */
2663 if (display_file_offsets
2664 && addr_offset
+ octets
/ opb
< stop_offset
)
2665 printf (_("\t... (skipping %lu zeroes, "
2666 "resuming at file offset: 0x%lx)\n"),
2667 (unsigned long) (octets
/ opb
),
2668 (unsigned long) (section
->filepos
2669 + addr_offset
+ octets
/ opb
));
2676 unsigned int bpc
= 0;
2677 unsigned int pb
= 0;
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
,
2712 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2713 inf
->stream
= &sfile
;
2714 inf
->bytes_per_line
= 0;
2715 inf
->bytes_per_chunk
= 0;
2716 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2717 | (wide_output
? WIDE_OUTPUT
: 0));
2719 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2721 if (inf
->disassembler_needs_relocs
2722 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2723 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2724 && *relppp
< relppend
)
2726 bfd_signed_vma distance_to_rel
;
2727 int max_reloc_offset
2728 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2730 distance_to_rel
= ((**relppp
)->address
- rel_offset
2734 if (distance_to_rel
> 0
2735 && (max_reloc_offset
< 0
2736 || distance_to_rel
<= max_reloc_offset
))
2738 /* This reloc *might* apply to the current insn,
2739 starting somewhere inside it. Discover the length
2740 of the current insn so that the check below will
2743 insn_size
= insn_width
;
2746 /* We find the length by calling the dissassembler
2747 function with a dummy print handler. This should
2748 work unless the disassembler is not expecting to
2749 be called multiple times for the same address.
2751 This does mean disassembling the instruction
2752 twice, but we only do this when there is a high
2753 probability that there is a reloc that will
2754 affect the instruction. */
2755 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2756 insn_size
= disassemble_fn (section
->vma
2757 + addr_offset
, inf
);
2758 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2762 /* Check to see if the current reloc is associated with
2763 the instruction that we are about to disassemble. */
2764 if (distance_to_rel
== 0
2765 || (distance_to_rel
> 0
2766 && distance_to_rel
< insn_size
/ (int) opb
))
2768 inf
->flags
|= INSN_HAS_RELOC
;
2769 aux
->reloc
= **relppp
;
2773 if (! disassemble_all
2774 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2775 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
2776 /* Set a stop_vma so that the disassembler will not read
2777 beyond the next symbol. We assume that symbols appear on
2778 the boundaries between instructions. We only do this when
2779 disassembling code of course, and when -D is in effect. */
2780 inf
->stop_vma
= section
->vma
+ stop_offset
;
2782 inf
->stop_offset
= stop_offset
;
2783 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2787 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2788 inf
->stream
= stdout
;
2789 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2790 octets_per_line
= inf
->bytes_per_line
;
2791 if (insn_size
< (int) opb
)
2794 printf ("%s\n", sfile
.buffer
);
2797 non_fatal (_("disassemble_fn returned length %d"),
2808 octets
= octets_per_line
;
2809 if (addr_offset
+ octets
/ opb
> stop_offset
)
2810 octets
= (stop_offset
- addr_offset
) * opb
;
2812 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2814 if (ISPRINT (data
[j
]))
2815 buf
[j
- addr_offset
* opb
] = data
[j
];
2817 buf
[j
- addr_offset
* opb
] = '.';
2819 buf
[j
- addr_offset
* opb
] = '\0';
2822 if (prefix_addresses
2824 : show_raw_insn
>= 0)
2828 /* If ! prefix_addresses and ! wide_output, we print
2829 octets_per_line octets per line. */
2831 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2832 pb
= octets_per_line
;
2834 if (inf
->bytes_per_chunk
)
2835 bpc
= inf
->bytes_per_chunk
;
2839 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2841 /* PR 21580: Check for a buffer ending early. */
2842 if (j
+ bpc
<= stop_offset
* opb
)
2846 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2848 for (k
= bpc
; k
-- != 0; )
2849 printf ("%02x", (unsigned) data
[j
+ k
]);
2853 for (k
= 0; k
< bpc
; k
++)
2854 printf ("%02x", (unsigned) data
[j
+ k
]);
2860 for (; pb
< octets_per_line
; pb
+= bpc
)
2864 for (k
= 0; k
< bpc
; k
++)
2869 /* Separate raw data from instruction by extra space. */
2879 printf ("%s", sfile
.buffer
);
2881 if (prefix_addresses
2883 : show_raw_insn
>= 0)
2891 j
= addr_offset
* opb
+ pb
;
2897 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2898 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2902 printf ("%s:\t", buf
+ skip_addr_chars
);
2905 print_jump_visualisation (section
->vma
+ j
/ opb
,
2906 max_level
, line_buffer
,
2909 pb
+= octets_per_line
;
2912 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2914 /* PR 21619: Check for a buffer ending early. */
2915 if (j
+ bpc
<= stop_offset
* opb
)
2919 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2921 for (k
= bpc
; k
-- != 0; )
2922 printf ("%02x", (unsigned) data
[j
+ k
]);
2926 for (k
= 0; k
< bpc
; k
++)
2927 printf ("%02x", (unsigned) data
[j
+ k
]);
2941 while ((*relppp
) < relppend
2942 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2944 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2957 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2962 if (q
->howto
== NULL
)
2963 printf ("*unknown*\t");
2964 else if (q
->howto
->name
)
2965 printf ("%s\t", q
->howto
->name
);
2967 printf ("%d\t", q
->howto
->type
);
2969 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2970 printf ("*unknown*");
2973 const char *sym_name
;
2975 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2976 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2977 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2982 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2983 sym_name
= bfd_section_name (sym_sec
);
2984 if (sym_name
== NULL
|| *sym_name
== '\0')
2985 sym_name
= "*unknown*";
2986 printf ("%s", sanitize_string (sym_name
));
2992 bfd_signed_vma addend
= q
->addend
;
3000 objdump_print_value (addend
, inf
, TRUE
);
3012 addr_offset
+= octets
/ opb
;
3015 free (sfile
.buffer
);
3017 free (color_buffer
);
3021 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3023 const struct elf_backend_data
* bed
;
3024 bfd_vma sign_adjust
= 0;
3025 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
3026 struct objdump_disasm_info
* paux
;
3027 unsigned int opb
= pinfo
->octets_per_byte
;
3028 bfd_byte
* data
= NULL
;
3029 bfd_size_type datasize
= 0;
3030 arelent
** rel_pp
= NULL
;
3031 arelent
** rel_ppstart
= NULL
;
3032 arelent
** rel_ppend
;
3033 bfd_vma stop_offset
;
3034 asymbol
* sym
= NULL
;
3038 unsigned long addr_offset
;
3039 bfd_boolean do_print
;
3042 stop_offset_reached
,
3047 /* Sections that do not contain machine
3048 code are not normally disassembled. */
3049 if (! disassemble_all
3050 && only_list
== NULL
3051 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3052 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3055 if (! process_section_p (section
))
3058 datasize
= bfd_section_size (section
);
3062 if (start_address
== (bfd_vma
) -1
3063 || start_address
< section
->vma
)
3066 addr_offset
= start_address
- section
->vma
;
3068 if (stop_address
== (bfd_vma
) -1)
3069 stop_offset
= datasize
/ opb
;
3072 if (stop_address
< section
->vma
)
3075 stop_offset
= stop_address
- section
->vma
;
3076 if (stop_offset
> datasize
/ opb
)
3077 stop_offset
= datasize
/ opb
;
3080 if (addr_offset
>= stop_offset
)
3083 /* Decide which set of relocs to use. Load them if necessary. */
3084 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3085 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3087 rel_pp
= paux
->dynrelbuf
;
3088 rel_count
= paux
->dynrelcount
;
3089 /* Dynamic reloc addresses are absolute, non-dynamic are section
3090 relative. REL_OFFSET specifies the reloc address corresponding
3091 to the start of this section. */
3092 rel_offset
= section
->vma
;
3100 if ((section
->flags
& SEC_RELOC
) != 0
3101 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3105 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3107 bfd_fatal (bfd_get_filename (abfd
));
3111 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3112 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3114 bfd_fatal (bfd_get_filename (abfd
));
3116 /* Sort the relocs by address. */
3117 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3121 rel_ppend
= rel_pp
+ rel_count
;
3123 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3125 non_fatal (_("Reading section %s failed because: %s"),
3126 section
->name
, bfd_errmsg (bfd_get_error ()));
3130 pinfo
->buffer
= data
;
3131 pinfo
->buffer_vma
= section
->vma
;
3132 pinfo
->buffer_length
= datasize
;
3133 pinfo
->section
= section
;
3135 /* Sort the symbols into value and section order. */
3136 compare_section
= section
;
3137 if (sorted_symcount
> 1)
3138 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3140 /* Skip over the relocs belonging to addresses below the
3142 while (rel_pp
< rel_ppend
3143 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3146 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3148 /* Find the nearest symbol forwards from our current position. */
3149 paux
->require_sec
= TRUE
;
3150 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3151 (struct disassemble_info
*) inf
,
3153 paux
->require_sec
= FALSE
;
3155 /* PR 9774: If the target used signed addresses then we must make
3156 sure that we sign extend the value that we calculate for 'addr'
3157 in the loop below. */
3158 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3159 && (bed
= get_elf_backend_data (abfd
)) != NULL
3160 && bed
->sign_extend_vma
)
3161 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3163 /* Disassemble a block of instructions up to the address associated with
3164 the symbol we have just found. Then print the symbol and find the
3165 next symbol on. Repeat until we have disassembled the entire section
3166 or we have reached the end of the address range we are interested in. */
3167 do_print
= paux
->symbol
== NULL
;
3168 loop_until
= stop_offset_reached
;
3170 while (addr_offset
< stop_offset
)
3174 bfd_vma nextstop_offset
;
3177 addr
= section
->vma
+ addr_offset
;
3178 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3180 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3185 (x
< sorted_symcount
3186 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3190 pinfo
->symbols
= sorted_syms
+ place
;
3191 pinfo
->num_symbols
= x
- place
;
3192 pinfo
->symtab_pos
= place
;
3196 pinfo
->symbols
= NULL
;
3197 pinfo
->num_symbols
= 0;
3198 pinfo
->symtab_pos
= -1;
3201 /* If we are only disassembling from a specific symbol,
3202 check to see if we should start or stop displaying. */
3203 if (sym
&& paux
->symbol
)
3207 /* See if we should stop printing. */
3211 if (sym
->flags
& BSF_FUNCTION
)
3215 case stop_offset_reached
:
3216 /* Handled by the while loop. */
3220 /* FIXME: There is an implicit assumption here
3221 that the name of sym is different from
3223 if (! bfd_is_local_label (abfd
, sym
))
3230 const char * name
= bfd_asymbol_name (sym
);
3231 char * alloc
= NULL
;
3233 if (do_demangle
&& name
[0] != '\0')
3235 /* Demangle the name. */
3236 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3241 /* We are not currently printing. Check to see
3242 if the current symbol matches the requested symbol. */
3243 if (streq (name
, paux
->symbol
))
3247 if (sym
->flags
& BSF_FUNCTION
)
3249 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3250 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3252 /* Sym is a function symbol with a size associated
3253 with it. Turn on automatic disassembly for the
3254 next VALUE bytes. */
3255 stop_offset
= addr_offset
3256 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3257 loop_until
= stop_offset_reached
;
3261 /* Otherwise we need to tell the loop heuristic to
3262 loop until the next function symbol is encountered. */
3263 loop_until
= function_sym
;
3268 /* Otherwise loop until the next symbol is encountered. */
3269 loop_until
= next_sym
;
3277 if (! prefix_addresses
&& do_print
)
3279 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3280 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3282 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3285 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3287 else if (sym
== NULL
)
3291 #define is_valid_next_sym(SYM) \
3292 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3293 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3294 && pinfo->symbol_is_valid (SYM, pinfo))
3296 /* Search forward for the next appropriate symbol in
3297 SECTION. Note that all the symbols are sorted
3298 together into one big array, and that some sections
3299 may have overlapping addresses. */
3300 while (place
< sorted_symcount
3301 && ! is_valid_next_sym (sorted_syms
[place
]))
3304 if (place
>= sorted_symcount
)
3307 nextsym
= sorted_syms
[place
];
3310 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3311 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3312 else if (nextsym
== NULL
)
3313 nextstop_offset
= stop_offset
;
3315 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3317 if (nextstop_offset
> stop_offset
3318 || nextstop_offset
<= addr_offset
)
3319 nextstop_offset
= stop_offset
;
3321 /* If a symbol is explicitly marked as being an object
3322 rather than a function, just dump the bytes without
3323 disassembling them. */
3326 || sym
->section
!= section
3327 || bfd_asymbol_value (sym
) > addr
3328 || ((sym
->flags
& BSF_OBJECT
) == 0
3329 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3331 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3333 || (sym
->flags
& BSF_FUNCTION
) != 0)
3340 /* Resolve symbol name. */
3341 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3343 struct disassemble_info di
;
3346 sf
.alloc
= strlen (sym
->name
) + 40;
3347 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3349 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3352 objdump_print_symname (abfd
, &di
, sym
);
3354 /* Fetch jump information. */
3355 detected_jumps
= disassemble_jumps
3356 (pinfo
, paux
->disassemble_fn
,
3357 addr_offset
, nextstop_offset
,
3358 rel_offset
, &rel_pp
, rel_ppend
);
3360 /* Free symbol name. */
3364 /* Add jumps to output. */
3365 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3366 addr_offset
, nextstop_offset
,
3367 rel_offset
, &rel_pp
, rel_ppend
);
3370 while (detected_jumps
)
3372 detected_jumps
= jump_info_free (detected_jumps
);
3376 addr_offset
= nextstop_offset
;
3382 if (rel_ppstart
!= NULL
)
3386 /* Disassemble the contents of an object file. */
3389 disassemble_data (bfd
*abfd
)
3391 struct disassemble_info disasm_info
;
3392 struct objdump_disasm_info aux
;
3396 prev_functionname
= NULL
;
3398 prev_discriminator
= 0;
3400 /* We make a copy of syms to sort. We don't want to sort syms
3401 because that will screw up the relocs. */
3402 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3403 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3404 * sizeof (asymbol
*));
3405 if (sorted_symcount
!= 0)
3407 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3408 sorted_symcount
* sizeof (asymbol
*));
3410 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3413 for (i
= 0; i
< synthcount
; ++i
)
3415 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3419 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3421 disasm_info
.application_data
= (void *) &aux
;
3423 aux
.require_sec
= FALSE
;
3424 aux
.dynrelbuf
= NULL
;
3425 aux
.dynrelcount
= 0;
3427 aux
.symbol
= disasm_sym
;
3429 disasm_info
.print_address_func
= objdump_print_address
;
3430 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3432 if (machine
!= NULL
)
3434 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3437 fatal (_("can't use supplied machine %s"), machine
);
3439 abfd
->arch_info
= inf
;
3442 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3444 struct bfd_target
*xvec
;
3446 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3447 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3448 xvec
->byteorder
= endian
;
3452 /* Use libopcodes to locate a suitable disassembler. */
3453 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3454 bfd_big_endian (abfd
),
3455 bfd_get_mach (abfd
), abfd
);
3456 if (!aux
.disassemble_fn
)
3458 non_fatal (_("can't disassemble for architecture %s\n"),
3459 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3464 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3465 disasm_info
.arch
= bfd_get_arch (abfd
);
3466 disasm_info
.mach
= bfd_get_mach (abfd
);
3467 disasm_info
.disassembler_options
= disassembler_options
;
3468 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3469 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3470 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3471 disasm_info
.disassembler_needs_relocs
= FALSE
;
3473 if (bfd_big_endian (abfd
))
3474 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3475 else if (bfd_little_endian (abfd
))
3476 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3478 /* ??? Aborting here seems too drastic. We could default to big or little
3480 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3482 disasm_info
.endian_code
= disasm_info
.endian
;
3484 /* Allow the target to customize the info structure. */
3485 disassemble_init_for_target (& disasm_info
);
3487 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3489 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3491 if (relsize
< 0 && dump_dynamic_reloc_info
)
3492 bfd_fatal (bfd_get_filename (abfd
));
3496 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3497 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3500 if (aux
.dynrelcount
< 0)
3501 bfd_fatal (bfd_get_filename (abfd
));
3503 /* Sort the relocs by address. */
3504 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3508 disasm_info
.symtab
= sorted_syms
;
3509 disasm_info
.symtab_size
= sorted_symcount
;
3511 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3513 if (aux
.dynrelbuf
!= NULL
)
3514 free (aux
.dynrelbuf
);
3516 disassemble_free_target (&disasm_info
);
3520 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3521 asection
*sec
, void *file
)
3523 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3524 bfd
*abfd
= (bfd
*) file
;
3529 if (section
->start
!= NULL
)
3531 /* If it is already loaded, do nothing. */
3532 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3534 free (section
->start
);
3537 section
->filename
= bfd_get_filename (abfd
);
3538 section
->reloc_info
= NULL
;
3539 section
->num_relocs
= 0;
3540 section
->address
= bfd_section_vma (sec
);
3541 section
->user_data
= sec
;
3542 section
->size
= bfd_section_size (sec
);
3543 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3544 alloced
= amt
= section
->size
+ 1;
3545 if (alloced
!= amt
|| alloced
== 0)
3547 section
->start
= NULL
;
3548 free_debug_section (debug
);
3549 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3550 sanitize_string (section
->name
),
3551 (unsigned long long) section
->size
);
3554 section
->start
= contents
= malloc (alloced
);
3555 if (section
->start
== NULL
3556 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3558 free_debug_section (debug
);
3559 printf (_("\nCan't get contents for section '%s'.\n"),
3560 sanitize_string (section
->name
));
3563 /* Ensure any string section has a terminating NUL. */
3564 section
->start
[section
->size
] = 0;
3566 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3567 && debug_displays
[debug
].relocate
)
3572 bfd_cache_section_contents (sec
, section
->start
);
3574 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3581 free_debug_section (debug
);
3582 printf (_("\nCan't get contents for section '%s'.\n"),
3583 sanitize_string (section
->name
));
3587 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3590 unsigned long reloc_count
;
3593 relocs
= (arelent
**) xmalloc (reloc_size
);
3595 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3596 if (reloc_count
== 0)
3600 section
->reloc_info
= relocs
;
3601 section
->num_relocs
= reloc_count
;
3610 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3615 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3618 relocs
= (arelent
**) dsec
->reloc_info
;
3620 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3621 if (rp
->address
== offset
)
3628 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3630 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3631 bfd
*abfd
= (bfd
*) file
;
3634 /* If it is already loaded, do nothing. */
3635 if (section
->start
!= NULL
)
3637 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3641 /* Locate the debug section. */
3642 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3644 section
->name
= section
->uncompressed_name
;
3647 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3649 section
->name
= section
->compressed_name
;
3654 return load_specific_debug_section (debug
, sec
, file
);
3658 free_debug_section (enum dwarf_section_display_enum debug
)
3660 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3662 if (section
->start
== NULL
)
3665 /* PR 17512: file: 0f67f69d. */
3666 if (section
->user_data
!= NULL
)
3668 asection
* sec
= (asection
*) section
->user_data
;
3670 /* If we are freeing contents that are also pointed to by the BFD
3671 library's section structure then make sure to update those pointers
3672 too. Otherwise, the next time we try to load data for this section
3673 we can end up using a stale pointer. */
3674 if (section
->start
== sec
->contents
)
3676 sec
->contents
= NULL
;
3677 sec
->flags
&= ~ SEC_IN_MEMORY
;
3678 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3682 free ((char *) section
->start
);
3683 section
->start
= NULL
;
3684 section
->address
= 0;
3689 close_debug_file (void * file
)
3691 bfd
* abfd
= (bfd
*) file
;
3697 open_debug_file (const char * pathname
)
3701 data
= bfd_openr (pathname
, NULL
);
3705 if (! bfd_check_format (data
, bfd_object
))
3711 #if HAVE_LIBDEBUGINFOD
3712 /* Return a hex string represention of the build-id. */
3715 get_build_id (void * data
)
3718 char * build_id_str
;
3719 bfd
* abfd
= (bfd
*) data
;
3720 const struct bfd_build_id
* build_id
;
3722 build_id
= abfd
->build_id
;
3723 if (build_id
== NULL
)
3726 build_id_str
= malloc (build_id
->size
* 2 + 1);
3727 if (build_id_str
== NULL
)
3730 for (i
= 0; i
< build_id
->size
; i
++)
3731 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3732 build_id_str
[build_id
->size
* 2] = '\0';
3734 return (unsigned char *)build_id_str
;
3736 #endif /* HAVE_LIBDEBUGINFOD */
3739 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3740 void *arg ATTRIBUTE_UNUSED
)
3742 const char *name
= bfd_section_name (section
);
3746 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3747 match
= ".debug_info";
3751 for (i
= 0; i
< max
; i
++)
3752 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3753 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3754 && debug_displays
[i
].enabled
!= NULL
3755 && *debug_displays
[i
].enabled
)
3757 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3759 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3760 sec
->name
= sec
->uncompressed_name
;
3762 sec
->name
= sec
->compressed_name
;
3763 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3766 debug_displays
[i
].display (sec
, abfd
);
3768 if (i
!= info
&& i
!= abbrev
)
3769 free_debug_section ((enum dwarf_section_display_enum
) i
);
3775 /* Dump the dwarf debugging information. */
3778 dump_dwarf (bfd
*abfd
)
3780 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3781 if (byte_get
== NULL
)
3783 warn (_("File %s does not contain any dwarf debug information\n"),
3784 bfd_get_filename (abfd
));
3788 switch (bfd_get_arch (abfd
))
3791 /* S12Z has a 24 bit address space. But the only known
3792 producer of dwarf_info encodes addresses into 32 bits. */
3797 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3801 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3802 bfd_get_mach (abfd
));
3804 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3807 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3808 it. Return NULL on failure. */
3811 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3812 bfd_size_type
*entsize_ptr
)
3817 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3818 if (stabsect
== NULL
)
3820 printf (_("No %s section present\n\n"),
3821 sanitize_string (sect_name
));
3825 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3827 non_fatal (_("reading %s section of %s failed: %s"),
3828 sect_name
, bfd_get_filename (abfd
),
3829 bfd_errmsg (bfd_get_error ()));
3835 *size_ptr
= bfd_section_size (stabsect
);
3837 *entsize_ptr
= stabsect
->entsize
;
3842 /* Stabs entries use a 12 byte format:
3843 4 byte string table index
3845 1 byte stab other field
3846 2 byte stab desc field
3848 FIXME: This will have to change for a 64 bit object format. */
3850 #define STRDXOFF (0)
3852 #define OTHEROFF (5)
3855 #define STABSIZE (12)
3857 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3858 using string table section STRSECT_NAME (in `strtab'). */
3861 print_section_stabs (bfd
*abfd
,
3862 const char *stabsect_name
,
3863 unsigned *string_offset_ptr
)
3866 unsigned file_string_table_offset
= 0;
3867 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3868 bfd_byte
*stabp
, *stabs_end
;
3871 stabs_end
= stabp
+ stab_size
;
3873 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3874 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3876 /* Loop through all symbols and print them.
3878 We start the index at -1 because there is a dummy symbol on
3879 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3880 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3884 unsigned char type
, other
;
3885 unsigned short desc
;
3888 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3889 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3890 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3891 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3892 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3894 printf ("\n%-6d ", i
);
3895 /* Either print the stab name, or, if unnamed, print its number
3896 again (makes consistent formatting for tools like awk). */
3897 name
= bfd_get_stab_name (type
);
3899 printf ("%-6s", sanitize_string (name
));
3900 else if (type
== N_UNDF
)
3903 printf ("%-6d", type
);
3904 printf (" %-6d %-6d ", other
, desc
);
3905 bfd_printf_vma (abfd
, value
);
3906 printf (" %-6lu", strx
);
3908 /* Symbols with type == 0 (N_UNDF) specify the length of the
3909 string table associated with this file. We use that info
3910 to know how to relocate the *next* file's string table indices. */
3913 file_string_table_offset
= next_file_string_table_offset
;
3914 next_file_string_table_offset
+= value
;
3918 bfd_size_type amt
= strx
+ file_string_table_offset
;
3920 /* Using the (possibly updated) string table offset, print the
3921 string (if any) associated with this symbol. */
3922 if (amt
< stabstr_size
)
3923 /* PR 17512: file: 079-79389-0.001:0.1.
3924 FIXME: May need to sanitize this string before displaying. */
3925 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3931 *string_offset_ptr
= next_file_string_table_offset
;
3936 const char * section_name
;
3937 const char * string_section_name
;
3938 unsigned string_offset
;
3943 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3946 stab_section_names
* sought
= (stab_section_names
*) names
;
3948 /* Check for section names for which stabsect_name is a prefix, to
3949 handle .stab.N, etc. */
3950 len
= strlen (sought
->section_name
);
3952 /* If the prefix matches, and the files section name ends with a
3953 nul or a digit, then we match. I.e., we want either an exact
3954 match or a section followed by a number. */
3955 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3956 && (section
->name
[len
] == 0
3957 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3960 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3961 &stabstr_size
, NULL
);
3965 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3967 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3973 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3975 stab_section_names s
;
3977 s
.section_name
= stabsect_name
;
3978 s
.string_section_name
= strsect_name
;
3979 s
.string_offset
= 0;
3981 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3987 /* Dump the any sections containing stabs debugging information. */
3990 dump_stabs (bfd
*abfd
)
3992 dump_stabs_section (abfd
, ".stab", ".stabstr");
3993 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3994 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3997 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3999 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4003 dump_bfd_header (bfd
*abfd
)
4007 printf (_("architecture: %s, "),
4008 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4009 bfd_get_mach (abfd
)));
4010 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4012 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4013 PF (HAS_RELOC
, "HAS_RELOC");
4014 PF (EXEC_P
, "EXEC_P");
4015 PF (HAS_LINENO
, "HAS_LINENO");
4016 PF (HAS_DEBUG
, "HAS_DEBUG");
4017 PF (HAS_SYMS
, "HAS_SYMS");
4018 PF (HAS_LOCALS
, "HAS_LOCALS");
4019 PF (DYNAMIC
, "DYNAMIC");
4020 PF (WP_TEXT
, "WP_TEXT");
4021 PF (D_PAGED
, "D_PAGED");
4022 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4023 printf (_("\nstart address 0x"));
4024 bfd_printf_vma (abfd
, abfd
->start_address
);
4029 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4030 it is passed, or a pointer to newly-allocated storage, in which case
4031 dump_ctf() will free it when it no longer needs it. */
4034 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4037 const char *blanks
= arg
;
4040 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4045 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4047 make_ctfsect (const char *name
, bfd_byte
*data
,
4052 ctfsect
.cts_name
= name
;
4053 ctfsect
.cts_entsize
= 1;
4054 ctfsect
.cts_size
= size
;
4055 ctfsect
.cts_data
= data
;
4060 /* Dump one CTF archive member. */
4063 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4065 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4066 const char *things
[] = {"Header", "Labels", "Data objects",
4067 "Function objects", "Variables", "Types", "Strings",
4072 /* Only print out the name of non-default-named archive members.
4073 The name .ctf appears everywhere, even for things that aren't
4074 really archives, so printing it out is liable to be confusing.
4076 The parent, if there is one, is the default-owned archive member:
4077 avoid importing it into itself. (This does no harm, but looks
4080 if (strcmp (name
, ".ctf") != 0)
4082 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4083 ctf_import (ctf
, parent
);
4086 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4088 ctf_dump_state_t
*s
= NULL
;
4091 printf ("\n %s:\n", *thing
);
4092 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4093 (void *) " ")) != NULL
)
4095 printf ("%s\n", item
);
4099 if (ctf_errno (ctf
))
4101 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4102 ctf_errmsg (ctf_errno (ctf
)));
4109 /* Dump the CTF debugging information. */
4112 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4114 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4115 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4116 bfd_size_type ctfsize
, parentsize
;
4118 ctf_file_t
*parent
= NULL
;
4121 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4122 bfd_fatal (bfd_get_filename (abfd
));
4125 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4127 bfd_fatal (bfd_get_filename (abfd
));
4129 /* Load the CTF file and dump it. */
4131 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4132 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4134 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4135 bfd_fatal (bfd_get_filename (abfd
));
4140 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4141 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4143 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4144 bfd_fatal (bfd_get_filename (abfd
));
4147 lookparent
= parenta
;
4152 /* Assume that the applicable parent archive member is the default one.
4153 (This is what all known implementations are expected to do, if they
4154 put CTFs and their parents in archives together.) */
4155 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4157 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4158 bfd_fatal (bfd_get_filename (abfd
));
4161 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4163 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4164 ctf_file_close (parent
);
4166 ctf_close (parenta
);
4173 dump_bfd_private_header (bfd
*abfd
)
4175 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4176 non_fatal (_("warning: private headers incomplete: %s"),
4177 bfd_errmsg (bfd_get_error ()));
4181 dump_target_specific (bfd
*abfd
)
4183 const struct objdump_private_desc
* const *desc
;
4184 struct objdump_private_option
*opt
;
4187 /* Find the desc. */
4188 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4189 if ((*desc
)->filter (abfd
))
4194 non_fatal (_("option -P/--private not supported by this file"));
4198 /* Clear all options. */
4199 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4200 opt
->selected
= FALSE
;
4202 /* Decode options. */
4203 b
= dump_private_options
;
4206 e
= strchr (b
, ',');
4211 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4212 if (strcmp (opt
->name
, b
) == 0)
4214 opt
->selected
= TRUE
;
4217 if (opt
->name
== NULL
)
4218 non_fatal (_("target specific dump '%s' not supported"), b
);
4229 (*desc
)->dump (abfd
);
4232 /* Display a section in hexadecimal format with associated characters.
4233 Each line prefixed by the zero padded address. */
4236 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4238 bfd_byte
*data
= NULL
;
4239 bfd_size_type datasize
;
4240 bfd_vma addr_offset
;
4241 bfd_vma start_offset
;
4242 bfd_vma stop_offset
;
4243 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4244 /* Bytes per line. */
4245 const int onaline
= 16;
4250 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4253 if (! process_section_p (section
))
4256 if ((datasize
= bfd_section_size (section
)) == 0)
4259 /* Compute the address range to display. */
4260 if (start_address
== (bfd_vma
) -1
4261 || start_address
< section
->vma
)
4264 start_offset
= start_address
- section
->vma
;
4266 if (stop_address
== (bfd_vma
) -1)
4267 stop_offset
= datasize
/ opb
;
4270 if (stop_address
< section
->vma
)
4273 stop_offset
= stop_address
- section
->vma
;
4275 if (stop_offset
> datasize
/ opb
)
4276 stop_offset
= datasize
/ opb
;
4279 if (start_offset
>= stop_offset
)
4282 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4283 if (display_file_offsets
)
4284 printf (_(" (Starting at file offset: 0x%lx)"),
4285 (unsigned long) (section
->filepos
+ start_offset
));
4288 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4290 non_fatal (_("Reading section %s failed because: %s"),
4291 section
->name
, bfd_errmsg (bfd_get_error ()));
4297 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4298 if (strlen (buf
) >= sizeof (buf
))
4302 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4304 count
= strlen (buf
) - count
;
4308 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4309 if (strlen (buf
) >= sizeof (buf
))
4313 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4315 count
= strlen (buf
) - count
;
4319 for (addr_offset
= start_offset
;
4320 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4324 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4325 count
= strlen (buf
);
4326 if ((size_t) count
>= sizeof (buf
))
4330 while (count
< width
)
4335 fputs (buf
+ count
- width
, stdout
);
4338 for (j
= addr_offset
* opb
;
4339 j
< addr_offset
* opb
+ onaline
; j
++)
4341 if (j
< stop_offset
* opb
)
4342 printf ("%02x", (unsigned) (data
[j
]));
4350 for (j
= addr_offset
* opb
;
4351 j
< addr_offset
* opb
+ onaline
; j
++)
4353 if (j
>= stop_offset
* opb
)
4356 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4363 /* Actually display the various requested regions. */
4366 dump_data (bfd
*abfd
)
4368 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4371 /* Should perhaps share code and display with nm? */
4374 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4383 max_count
= dynsymcount
;
4384 printf ("DYNAMIC SYMBOL TABLE:\n");
4389 max_count
= symcount
;
4390 printf ("SYMBOL TABLE:\n");
4394 printf (_("no symbols\n"));
4396 for (count
= 0; count
< max_count
; count
++)
4400 if (*current
== NULL
)
4401 printf (_("no information for symbol number %ld\n"), count
);
4403 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4404 printf (_("could not determine the type of symbol number %ld\n"),
4407 else if (process_section_p ((* current
)->section
)
4408 && (dump_special_syms
4409 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4411 const char *name
= (*current
)->name
;
4413 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4417 /* If we want to demangle the name, we demangle it
4418 here, and temporarily clobber it while calling
4419 bfd_print_symbol. FIXME: This is a gross hack. */
4420 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4422 (*current
)->name
= alloc
;
4423 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4424 bfd_print_symbol_all
);
4427 (*current
)->name
= name
;
4432 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4433 bfd_print_symbol_all
);
4443 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4446 char *last_filename
, *last_functionname
;
4447 unsigned int last_line
;
4448 unsigned int last_discriminator
;
4450 /* Get column headers lined up reasonably. */
4458 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4459 width
= strlen (buf
) - 7;
4461 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4464 last_filename
= NULL
;
4465 last_functionname
= NULL
;
4467 last_discriminator
= 0;
4469 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4472 const char *filename
, *functionname
;
4473 unsigned int linenumber
;
4474 unsigned int discriminator
;
4475 const char *sym_name
;
4476 const char *section_name
;
4477 bfd_vma addend2
= 0;
4479 if (start_address
!= (bfd_vma
) -1
4480 && q
->address
< start_address
)
4482 if (stop_address
!= (bfd_vma
) -1
4483 && q
->address
> stop_address
)
4486 if (with_line_numbers
4488 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4489 &filename
, &functionname
,
4490 &linenumber
, &discriminator
))
4492 if (functionname
!= NULL
4493 && (last_functionname
== NULL
4494 || strcmp (functionname
, last_functionname
) != 0))
4496 printf ("%s():\n", sanitize_string (functionname
));
4497 if (last_functionname
!= NULL
)
4498 free (last_functionname
);
4499 last_functionname
= xstrdup (functionname
);
4503 && (linenumber
!= last_line
4504 || (filename
!= NULL
4505 && last_filename
!= NULL
4506 && filename_cmp (filename
, last_filename
) != 0)
4507 || (discriminator
!= last_discriminator
)))
4509 if (discriminator
> 0)
4510 printf ("%s:%u\n", filename
== NULL
? "???" :
4511 sanitize_string (filename
), linenumber
);
4513 printf ("%s:%u (discriminator %u)\n",
4514 filename
== NULL
? "???" : sanitize_string (filename
),
4515 linenumber
, discriminator
);
4516 last_line
= linenumber
;
4517 last_discriminator
= discriminator
;
4518 if (last_filename
!= NULL
)
4519 free (last_filename
);
4520 if (filename
== NULL
)
4521 last_filename
= NULL
;
4523 last_filename
= xstrdup (filename
);
4527 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4529 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4530 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4535 section_name
= NULL
;
4538 bfd_printf_vma (abfd
, q
->address
);
4539 if (q
->howto
== NULL
)
4540 printf (" *unknown* ");
4541 else if (q
->howto
->name
)
4543 const char *name
= q
->howto
->name
;
4545 /* R_SPARC_OLO10 relocations contain two addends.
4546 But because 'arelent' lacks enough storage to
4547 store them both, the 64-bit ELF Sparc backend
4548 records this as two relocations. One R_SPARC_LO10
4549 and one R_SPARC_13, both pointing to the same
4550 address. This is merely so that we have some
4551 place to store both addend fields.
4553 Undo this transformation, otherwise the output
4554 will be confusing. */
4555 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4556 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4558 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4560 arelent
*q2
= *(p
+ 1);
4563 && q
->address
== q2
->address
4564 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4566 name
= "R_SPARC_OLO10";
4567 addend2
= q2
->addend
;
4571 printf (" %-16s ", name
);
4574 printf (" %-16d ", q
->howto
->type
);
4578 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4582 if (section_name
== NULL
)
4583 section_name
= "*unknown*";
4584 printf ("[%s]", sanitize_string (section_name
));
4589 bfd_signed_vma addend
= q
->addend
;
4597 bfd_printf_vma (abfd
, addend
);
4602 bfd_printf_vma (abfd
, addend2
);
4608 if (last_filename
!= NULL
)
4609 free (last_filename
);
4610 if (last_functionname
!= NULL
)
4611 free (last_functionname
);
4615 dump_relocs_in_section (bfd
*abfd
,
4617 void *dummy ATTRIBUTE_UNUSED
)
4619 arelent
**relpp
= NULL
;
4623 if ( bfd_is_abs_section (section
)
4624 || bfd_is_und_section (section
)
4625 || bfd_is_com_section (section
)
4626 || (! process_section_p (section
))
4627 || ((section
->flags
& SEC_RELOC
) == 0))
4630 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4632 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4635 printf (" (none)\n\n");
4643 relpp
= (arelent
**) xmalloc (relsize
);
4644 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4650 non_fatal (_("failed to read relocs in: %s"),
4651 sanitize_string (bfd_get_filename (abfd
)));
4652 bfd_fatal (_("error message was"));
4654 else if (relcount
== 0)
4655 printf (" (none)\n\n");
4659 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4666 dump_relocs (bfd
*abfd
)
4668 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4672 dump_dynamic_relocs (bfd
*abfd
)
4678 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4680 bfd_fatal (bfd_get_filename (abfd
));
4682 printf ("DYNAMIC RELOCATION RECORDS");
4685 printf (" (none)\n\n");
4688 relpp
= (arelent
**) xmalloc (relsize
);
4689 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4692 bfd_fatal (bfd_get_filename (abfd
));
4693 else if (relcount
== 0)
4694 printf (" (none)\n\n");
4698 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4705 /* Creates a table of paths, to search for source files. */
4708 add_include_path (const char *path
)
4712 include_path_count
++;
4713 include_paths
= (const char **)
4714 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4715 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4716 if (path
[1] == ':' && path
[2] == 0)
4717 path
= concat (path
, ".", (const char *) 0);
4719 include_paths
[include_path_count
- 1] = path
;
4723 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4727 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4729 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4730 section
->vma
+= adjust_section_vma
;
4732 section
->lma
+= adjust_section_vma
;
4736 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4739 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4744 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4745 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4748 /* Dump selected contents of ABFD. */
4751 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4753 const struct elf_backend_data
* bed
;
4755 if (bfd_big_endian (abfd
))
4756 byte_get
= byte_get_big_endian
;
4757 else if (bfd_little_endian (abfd
))
4758 byte_get
= byte_get_little_endian
;
4762 /* Load any separate debug information files.
4763 We do this now and without checking do_follow_links because separate
4764 debug info files may contain symbol tables that we will need when
4765 displaying information about the main file. Any memory allocated by
4766 load_separate_debug_files will be released when we call
4767 free_debug_memory below.
4769 The test on is_mainfile is there because the chain of separate debug
4770 info files is a global variable shared by all invocations of dump_bfd. */
4773 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4775 /* If asked to do so, recursively dump the separate files. */
4776 if (do_follow_links
)
4780 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4781 dump_bfd (i
->handle
, FALSE
);
4785 /* Adjust user-specified start and stop limits for targets that use
4786 signed addresses. */
4787 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4788 && (bed
= get_elf_backend_data (abfd
)) != NULL
4789 && bed
->sign_extend_vma
)
4791 start_address
= sign_extend_address (abfd
, start_address
,
4793 stop_address
= sign_extend_address (abfd
, stop_address
,
4797 /* If we are adjusting section VMA's, change them all now. Changing
4798 the BFD information is a hack. However, we must do it, or
4799 bfd_find_nearest_line will not do the right thing. */
4800 if (adjust_section_vma
!= 0)
4802 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4803 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4806 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4807 printf (_("\n%s: file format %s\n"),
4808 sanitize_string (bfd_get_filename (abfd
)),
4811 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4812 if (dump_file_header
)
4813 dump_bfd_header (abfd
);
4814 if (dump_private_headers
)
4815 dump_bfd_private_header (abfd
);
4816 if (dump_private_options
!= NULL
)
4817 dump_target_specific (abfd
);
4818 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4825 || dump_dwarf_section_info
)
4827 syms
= slurp_symtab (abfd
);
4829 /* If following links, load any symbol tables from the linked files as well. */
4830 if (do_follow_links
&& is_mainfile
)
4834 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4836 asymbol
** extra_syms
;
4837 long old_symcount
= symcount
;
4839 extra_syms
= slurp_symtab (i
->handle
);
4843 if (old_symcount
== 0)
4849 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4850 memcpy (syms
+ old_symcount
,
4852 symcount
* sizeof (asymbol
*));
4856 symcount
+= old_symcount
;
4861 if (dump_section_headers
)
4862 dump_headers (abfd
);
4864 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4865 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4866 dynsyms
= slurp_dynamic_symtab (abfd
);
4870 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4871 dynsymcount
, dynsyms
, &synthsyms
);
4877 dump_symbols (abfd
, FALSE
);
4878 if (dump_dynamic_symtab
)
4879 dump_symbols (abfd
, TRUE
);
4880 if (dump_dwarf_section_info
)
4882 if (dump_ctf_section_info
)
4883 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4884 if (dump_stab_section_info
)
4886 if (dump_reloc_info
&& ! disassemble
)
4888 if (dump_dynamic_reloc_info
&& ! disassemble
)
4889 dump_dynamic_relocs (abfd
);
4890 if (dump_section_contents
)
4893 disassemble_data (abfd
);
4899 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4900 if (dhandle
!= NULL
)
4902 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4904 dump_debugging_tags
? TRUE
: FALSE
))
4906 non_fatal (_("%s: printing debugging information failed"),
4907 bfd_get_filename (abfd
));
4913 /* PR 6483: If there was no STABS debug info in the file, try
4915 else if (! dump_dwarf_section_info
)
4917 dwarf_select_sections_all ();
4945 free_debug_memory ();
4949 display_object_bfd (bfd
*abfd
)
4953 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4955 dump_bfd (abfd
, TRUE
);
4959 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4961 nonfatal (bfd_get_filename (abfd
));
4962 list_matching_formats (matching
);
4967 if (bfd_get_error () != bfd_error_file_not_recognized
)
4969 nonfatal (bfd_get_filename (abfd
));
4973 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4975 dump_bfd (abfd
, TRUE
);
4979 nonfatal (bfd_get_filename (abfd
));
4981 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4983 list_matching_formats (matching
);
4989 display_any_bfd (bfd
*file
, int level
)
4991 /* Decompress sections unless dumping the section contents. */
4992 if (!dump_section_contents
)
4993 file
->flags
|= BFD_DECOMPRESS
;
4995 /* If the file is an archive, process all of its elements. */
4996 if (bfd_check_format (file
, bfd_archive
))
4999 bfd
*last_arfile
= NULL
;
5002 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5003 else if (level
> 100)
5005 /* Prevent corrupted files from spinning us into an
5006 infinite loop. 100 is an arbitrary heuristic. */
5007 fatal (_("Archive nesting is too deep"));
5011 printf (_("In nested archive %s:\n"),
5012 sanitize_string (bfd_get_filename (file
)));
5016 bfd_set_error (bfd_error_no_error
);
5018 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5021 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5022 nonfatal (bfd_get_filename (file
));
5026 display_any_bfd (arfile
, level
+ 1);
5028 if (last_arfile
!= NULL
)
5030 bfd_close (last_arfile
);
5031 /* PR 17512: file: ac585d01. */
5032 if (arfile
== last_arfile
)
5038 last_arfile
= arfile
;
5041 if (last_arfile
!= NULL
)
5042 bfd_close (last_arfile
);
5045 display_object_bfd (file
);
5049 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5053 if (get_file_size (filename
) < 1)
5059 file
= bfd_openr (filename
, target
);
5062 nonfatal (filename
);
5066 display_any_bfd (file
, 0);
5068 /* This is an optimization to improve the speed of objdump, especially when
5069 dumping a file with lots of associated debug informatiom. Calling
5070 bfd_close on such a file can take a non-trivial amount of time as there
5071 are lots of lists to walk and buffers to free. This is only really
5072 necessary however if we are about to load another file and we need the
5073 memory back. Otherwise, if we are about to exit, then we can save (a lot
5074 of) time by only doing a quick close, and allowing the OS to reclaim the
5079 bfd_close_all_done (file
);
5083 main (int argc
, char **argv
)
5086 char *target
= default_target
;
5087 bfd_boolean seenflag
= FALSE
;
5089 #if defined (HAVE_SETLOCALE)
5090 #if defined (HAVE_LC_MESSAGES)
5091 setlocale (LC_MESSAGES
, "");
5093 setlocale (LC_CTYPE
, "");
5096 bindtextdomain (PACKAGE
, LOCALEDIR
);
5097 textdomain (PACKAGE
);
5099 program_name
= *argv
;
5100 xmalloc_set_program_name (program_name
);
5101 bfd_set_error_program_name (program_name
);
5103 START_PROGRESS (program_name
, 0);
5105 expandargv (&argc
, &argv
);
5107 if (bfd_init () != BFD_INIT_MAGIC
)
5108 fatal (_("fatal error: libbfd ABI mismatch"));
5109 set_default_bfd_target ();
5111 while ((c
= getopt_long (argc
, argv
,
5112 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5113 long_options
, (int *) 0))
5119 break; /* We've been given a long option. */
5126 if (disassembler_options
)
5127 /* Ignore potential memory leak for now. */
5128 options
= concat (disassembler_options
, ",",
5129 optarg
, (const char *) NULL
);
5132 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5139 display_file_offsets
= TRUE
;
5142 with_line_numbers
= TRUE
;
5151 enum demangling_styles style
;
5153 style
= cplus_demangle_name_to_style (optarg
);
5154 if (style
== unknown_demangling
)
5155 fatal (_("unknown demangling style `%s'"),
5158 cplus_demangle_set_style (style
);
5161 case OPTION_RECURSE_LIMIT
:
5162 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5164 case OPTION_NO_RECURSE_LIMIT
:
5165 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5168 do_wide
= wide_output
= TRUE
;
5170 case OPTION_ADJUST_VMA
:
5171 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5173 case OPTION_START_ADDRESS
:
5174 start_address
= parse_vma (optarg
, "--start-address");
5175 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5176 fatal (_("error: the start address should be before the end address"));
5178 case OPTION_STOP_ADDRESS
:
5179 stop_address
= parse_vma (optarg
, "--stop-address");
5180 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5181 fatal (_("error: the stop address should be after the start address"));
5185 prefix_length
= strlen (prefix
);
5186 /* Remove an unnecessary trailing '/' */
5187 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5190 case OPTION_PREFIX_STRIP
:
5191 prefix_strip
= atoi (optarg
);
5192 if (prefix_strip
< 0)
5193 fatal (_("error: prefix strip must be non-negative"));
5195 case OPTION_INSN_WIDTH
:
5196 insn_width
= strtoul (optarg
, NULL
, 0);
5197 if (insn_width
<= 0)
5198 fatal (_("error: instruction width must be positive"));
5200 case OPTION_INLINES
:
5201 unwind_inlines
= TRUE
;
5203 case OPTION_VISUALIZE_JUMPS
:
5204 visualize_jumps
= TRUE
;
5205 color_output
= FALSE
;
5206 extended_color_output
= FALSE
;
5209 if (streq (optarg
, "color"))
5210 color_output
= TRUE
;
5211 else if (streq (optarg
, "extended-color"))
5213 color_output
= TRUE
;
5214 extended_color_output
= TRUE
;
5216 else if (streq (optarg
, "off"))
5217 visualize_jumps
= FALSE
;
5219 nonfatal (_("unrecognized argument to --visualize-option"));
5223 if (strcmp (optarg
, "B") == 0)
5224 endian
= BFD_ENDIAN_BIG
;
5225 else if (strcmp (optarg
, "L") == 0)
5226 endian
= BFD_ENDIAN_LITTLE
;
5229 nonfatal (_("unrecognized -E option"));
5234 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5235 endian
= BFD_ENDIAN_BIG
;
5236 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5237 endian
= BFD_ENDIAN_LITTLE
;
5240 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5247 dump_file_header
= TRUE
;
5251 formats_info
= TRUE
;
5255 add_include_path (optarg
);
5258 dump_private_headers
= TRUE
;
5262 dump_private_options
= optarg
;
5266 dump_private_headers
= TRUE
;
5268 dump_reloc_info
= TRUE
;
5269 dump_file_header
= TRUE
;
5270 dump_ar_hdrs
= TRUE
;
5271 dump_section_headers
= TRUE
;
5279 dump_dynamic_symtab
= TRUE
;
5285 disasm_sym
= optarg
;
5288 disassemble_zeroes
= TRUE
;
5292 disassemble_all
= TRUE
;
5297 with_source_code
= TRUE
;
5300 case OPTION_SOURCE_COMMENT
:
5302 with_source_code
= TRUE
;
5305 source_comment
= xstrdup (sanitize_string (optarg
));
5307 source_comment
= xstrdup ("# ");
5315 dump_debugging_tags
= 1;
5320 dump_dwarf_section_info
= TRUE
;
5323 dwarf_select_sections_by_letters (optarg
);
5325 dwarf_select_sections_all ();
5328 dump_dwarf_section_info
= TRUE
;
5331 dwarf_select_sections_by_names (optarg
);
5333 dwarf_select_sections_all ();
5335 case OPTION_DWARF_DEPTH
:
5338 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5341 case OPTION_DWARF_START
:
5344 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5345 suppress_bfd_header
= 1;
5348 case OPTION_DWARF_CHECK
:
5352 dump_ctf_section_info
= TRUE
;
5353 dump_ctf_section_name
= xstrdup (optarg
);
5356 case OPTION_CTF_PARENT
:
5357 dump_ctf_parent_name
= xstrdup (optarg
);
5360 dump_stab_section_info
= TRUE
;
5364 dump_section_contents
= TRUE
;
5368 dump_reloc_info
= TRUE
;
5372 dump_dynamic_reloc_info
= TRUE
;
5376 dump_ar_hdrs
= TRUE
;
5380 dump_section_headers
= TRUE
;
5385 show_version
= TRUE
;
5391 /* No need to set seenflag or to break - usage() does not return. */
5398 print_version ("objdump");
5404 exit_status
= display_info ();
5408 display_file ("a.out", target
, TRUE
);
5410 for (; optind
< argc
;)
5412 display_file (argv
[optind
], target
, optind
== argc
- 1);
5418 free (dump_ctf_section_name
);
5419 free (dump_ctf_parent_name
);
5420 free ((void *) source_comment
);
5422 END_PROGRESS (program_name
);