1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2021 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 bool 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 bool 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 bool disassemble
; /* -d */
108 static bool disassemble_all
; /* -D */
109 static int disassemble_zeroes
; /* --disassemble-zeroes */
110 static bool 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 bool 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 bool unwind_inlines
; /* --inlines. */
126 static const char * disasm_sym
; /* Disassembly start symbol. */
127 static const char * source_comment
; /* --source_comment. */
128 static bool visualize_jumps
= false; /* --visualize-jumps. */
129 static bool color_output
= false; /* --visualize-jumps=color. */
130 static bool extended_color_output
= false; /* --visualize-jumps=extended-color. */
131 static int process_links
= false; /* --process-links. */
133 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
135 /* A structure to record the sections mentioned in -j switches. */
138 const char *name
; /* The name of the section. */
139 bool seen
; /* A flag to indicate that the section has been found in one or more input files. */
140 struct only
*next
; /* Pointer to the next structure in the list. */
142 /* Pointer to an array of 'only' structures.
143 This pointer is NULL if the -j switch has not been used. */
144 static struct only
* only_list
= NULL
;
146 /* Variables for handling include file path table. */
147 static const char **include_paths
;
148 static int include_path_count
;
150 /* Extra info to pass to the section disassembler and address printing
152 struct objdump_disasm_info
156 disassembler_ftype disassemble_fn
;
161 /* Architecture to disassemble for, or default if NULL. */
162 static char *machine
= NULL
;
164 /* Target specific options to the disassembler. */
165 static char *disassembler_options
= NULL
;
167 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
168 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
170 /* The symbol table. */
171 static asymbol
**syms
;
173 /* Number of symbols in `syms'. */
174 static long symcount
= 0;
176 /* The sorted symbol table. */
177 static asymbol
**sorted_syms
;
179 /* Number of symbols in `sorted_syms'. */
180 static long sorted_symcount
= 0;
182 /* The dynamic symbol table. */
183 static asymbol
**dynsyms
;
185 /* The synthetic symbol table. */
186 static asymbol
*synthsyms
;
187 static long synthcount
= 0;
189 /* Number of symbols in `dynsyms'. */
190 static long dynsymcount
= 0;
192 static bfd_byte
*stabs
;
193 static bfd_size_type stab_size
;
195 static bfd_byte
*strtab
;
196 static bfd_size_type stabstr_size
;
198 /* Handlers for -P/--private. */
199 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
201 OBJDUMP_PRIVATE_VECTORS
205 /* The list of detected jumps inside a function. */
206 static struct jump_info
*detected_jumps
= NULL
;
208 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
210 usage (FILE *stream
, int status
)
212 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
213 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
214 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
215 fprintf (stream
, _("\
216 -a, --archive-headers Display archive header information\n\
217 -f, --file-headers Display the contents of the overall file header\n\
218 -p, --private-headers Display object format specific file header contents\n\
219 -P, --private=OPT,OPT... Display object format specific contents\n\
220 -h, --[section-]headers Display the contents of the section headers\n\
221 -x, --all-headers Display the contents of all headers\n\
222 -d, --disassemble Display assembler contents of executable sections\n\
223 -D, --disassemble-all Display assembler contents of all sections\n\
224 --disassemble=<sym> Display assembler contents from <sym>\n\
225 -S, --source Intermix source code with disassembly\n\
226 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
227 -s, --full-contents Display the full contents of all sections requested\n\
228 -g, --debugging Display debug information in object file\n\
229 -e, --debugging-tags Display debug information using ctags style\n\
230 -G, --stabs Display (in raw form) any STABS info in the file\n\
231 -W[lLiaprmfFsoORtUuTgAck] or\n\
232 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
233 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
234 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
235 =addr,=cu_index,=links]\n\
236 Display DWARF info in the file\n\
238 #if DEFAULT_FOR_FOLLOW_LINKS
239 fprintf (stream
, _("\
240 -WK,--dwarf=follow-links Follow links to separate debug info files (default)\n\
241 -WN,--dwarf=no-follow-links Do not follow links to separate debug info files\n\
244 fprintf (stream
, _("\
245 -WK,--dwarf=follow-links Follow links to separate debug info files\n\
246 -WN,--dwarf=no-follow-links Do not follow links to separate debug info files (default)\n\
249 fprintf (stream
, _("\
250 -L, --process-links Display the contents of non-debug sections in separate debuginfo files.\n\
253 fprintf (stream
, _("\
254 --ctf=SECTION Display CTF info from SECTION\n\
257 fprintf (stream
, _("\
258 -t, --syms Display the contents of the symbol table(s)\n\
259 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
260 -r, --reloc Display the relocation entries in the file\n\
261 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
262 @<file> Read options from <file>\n\
263 -v, --version Display this program's version number\n\
264 -i, --info List object formats and architectures supported\n\
265 -H, --help Display this information\n\
269 const struct objdump_private_desc
* const *desc
;
271 fprintf (stream
, _("\n The following switches are optional:\n"));
272 fprintf (stream
, _("\
273 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
274 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
275 -j, --section=NAME Only display information for section NAME\n\
276 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
277 -EB --endian=big Assume big endian format when disassembling\n\
278 -EL --endian=little Assume little endian format when disassembling\n\
279 --file-start-context Include context from start of file (with -S)\n\
280 -I, --include=DIR Add DIR to search list for source files\n\
281 -l, --line-numbers Include line numbers and filenames in output\n\
282 -F, --file-offsets Include file offsets when displaying information\n\
283 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
284 The STYLE, if specified, can be `auto', `gnu',\n\
285 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
287 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
288 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
289 -w, --wide Format output for more than 80 columns\n\
290 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
291 --start-address=ADDR Only process data whose address is >= ADDR\n\
292 --stop-address=ADDR Only process data whose address is < ADDR\n\
293 --no-addresses Do not print address alongside disassembly\n\
294 --prefix-addresses Print complete address alongside disassembly\n\
295 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
296 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
297 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
298 --special-syms Include special symbols in symbol dumps\n\
299 --inlines Print all inlines for source line (with -l)\n\
300 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
301 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
302 fprintf (stream
, _("\
303 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
304 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
306 --dwarf-check Make additional dwarf internal consistency checks.\n"));
308 fprintf (stream
, _("\
309 --ctf-parent=SECTION Use SECTION as the CTF parent\n"));
311 fprintf (stream
, _("\
312 --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
313 --visualize-jumps=color Use colors in the ASCII art\n\
314 --visualize-jumps=extended-color Use extended 8-bit color codes\n\
315 --visualize-jumps=off Disable jump visualization\n\n"));
317 list_supported_targets (program_name
, stream
);
318 list_supported_architectures (program_name
, stream
);
320 disassembler_usage (stream
);
322 if (objdump_private_vectors
[0] != NULL
)
325 _("\nOptions supported for -P/--private switch:\n"));
326 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
327 (*desc
)->help (stream
);
330 if (REPORT_BUGS_TO
[0] && status
== 0)
331 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
335 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
339 OPTION_START_ADDRESS
,
349 OPTION_RECURSE_LIMIT
,
350 OPTION_NO_RECURSE_LIMIT
,
352 OPTION_SOURCE_COMMENT
,
357 OPTION_VISUALIZE_JUMPS
360 static struct option long_options
[]=
362 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
363 {"all-headers", no_argument
, NULL
, 'x'},
364 {"private-headers", no_argument
, NULL
, 'p'},
365 {"private", required_argument
, NULL
, 'P'},
366 {"architecture", required_argument
, NULL
, 'm'},
367 {"archive-headers", no_argument
, NULL
, 'a'},
368 {"debugging", no_argument
, NULL
, 'g'},
369 {"debugging-tags", no_argument
, NULL
, 'e'},
370 {"demangle", optional_argument
, NULL
, 'C'},
371 {"disassemble", optional_argument
, NULL
, 'd'},
372 {"disassemble-all", no_argument
, NULL
, 'D'},
373 {"disassembler-options", required_argument
, NULL
, 'M'},
374 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
375 {"dynamic-reloc", no_argument
, NULL
, 'R'},
376 {"dynamic-syms", no_argument
, NULL
, 'T'},
377 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
378 {"file-headers", no_argument
, NULL
, 'f'},
379 {"file-offsets", no_argument
, NULL
, 'F'},
380 {"file-start-context", no_argument
, &file_start_context
, 1},
381 {"full-contents", no_argument
, NULL
, 's'},
382 {"headers", no_argument
, NULL
, 'h'},
383 {"help", no_argument
, NULL
, 'H'},
384 {"info", no_argument
, NULL
, 'i'},
385 {"line-numbers", no_argument
, NULL
, 'l'},
386 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
387 {"no-addresses", no_argument
, &no_addresses
, 1},
388 {"process-links", no_argument
, &process_links
, true},
389 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
390 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
391 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
392 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
393 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
394 {"reloc", no_argument
, NULL
, 'r'},
395 {"section", required_argument
, NULL
, 'j'},
396 {"section-headers", no_argument
, NULL
, 'h'},
397 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
398 {"source", no_argument
, NULL
, 'S'},
399 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
400 {"special-syms", no_argument
, &dump_special_syms
, 1},
401 {"include", required_argument
, NULL
, 'I'},
402 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
404 {"ctf", required_argument
, NULL
, OPTION_CTF
},
405 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
407 {"stabs", no_argument
, NULL
, 'G'},
408 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
409 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
410 {"syms", no_argument
, NULL
, 't'},
411 {"target", required_argument
, NULL
, 'b'},
412 {"version", no_argument
, NULL
, 'V'},
413 {"wide", no_argument
, NULL
, 'w'},
414 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
415 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
416 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
417 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
418 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
419 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
420 {"inlines", no_argument
, 0, OPTION_INLINES
},
421 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
422 {0, no_argument
, 0, 0}
426 nonfatal (const char *msg
)
432 /* Returns a version of IN with any control characters
433 replaced by escape sequences. Uses a static buffer
437 sanitize_string (const char * in
)
439 static char * buffer
= NULL
;
440 static size_t buffer_len
= 0;
441 const char * original
= in
;
448 /* See if any conversion is necessary. In the majority
449 of cases it will not be needed. */
462 /* Copy the input, translating as needed. */
464 if (buffer_len
< (strlen (in
) * 2))
466 free ((void *) buffer
);
467 buffer_len
= strlen (in
) * 2;
468 buffer
= xmalloc (buffer_len
+ 1);
494 /* Returns TRUE if the specified section should be dumped. */
497 process_section_p (asection
* section
)
501 if (only_list
== NULL
)
504 for (only
= only_list
; only
; only
= only
->next
)
505 if (strcmp (only
->name
, section
->name
) == 0)
514 /* Add an entry to the 'only' list. */
517 add_only (char * name
)
521 /* First check to make sure that we do not
522 already have an entry for this name. */
523 for (only
= only_list
; only
; only
= only
->next
)
524 if (strcmp (only
->name
, name
) == 0)
527 only
= xmalloc (sizeof * only
);
530 only
->next
= only_list
;
534 /* Release the memory used by the 'only' list.
535 PR 11225: Issue a warning message for unseen sections.
536 Only do this if none of the sections were seen. This is mainly to support
537 tools like the GAS testsuite where an object file is dumped with a list of
538 generic section names known to be present in a range of different file
542 free_only_list (void)
544 bool at_least_one_seen
= false;
548 if (only_list
== NULL
)
551 for (only
= only_list
; only
; only
= only
->next
)
554 at_least_one_seen
= true;
558 for (only
= only_list
; only
; only
= next
)
560 if (! at_least_one_seen
)
562 non_fatal (_("section '%s' mentioned in a -j option, "
563 "but not found in any input file"),
574 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
577 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
578 int longest_section_name
= *((int *) data
);
580 /* Ignore linker created section. See elfNN_ia64_object_p in
582 if (section
->flags
& SEC_LINKER_CREATED
)
585 /* PR 10413: Skip sections that we are ignoring. */
586 if (! process_section_p (section
))
589 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
590 sanitize_string (bfd_section_name (section
)),
591 (unsigned long) bfd_section_size (section
) / opb
);
592 bfd_printf_vma (abfd
, bfd_section_vma (section
));
594 bfd_printf_vma (abfd
, section
->lma
);
595 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
596 bfd_section_alignment (section
));
602 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
604 PF (SEC_HAS_CONTENTS
, "CONTENTS");
605 PF (SEC_ALLOC
, "ALLOC");
606 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
607 PF (SEC_LOAD
, "LOAD");
608 PF (SEC_RELOC
, "RELOC");
609 PF (SEC_READONLY
, "READONLY");
610 PF (SEC_CODE
, "CODE");
611 PF (SEC_DATA
, "DATA");
613 PF (SEC_DEBUGGING
, "DEBUGGING");
614 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
615 PF (SEC_EXCLUDE
, "EXCLUDE");
616 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
617 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
619 PF (SEC_TIC54X_BLOCK
, "BLOCK");
620 PF (SEC_TIC54X_CLINK
, "CLINK");
622 PF (SEC_SMALL_DATA
, "SMALL_DATA");
623 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
625 PF (SEC_COFF_SHARED
, "SHARED");
626 PF (SEC_COFF_NOREAD
, "NOREAD");
628 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
630 PF (SEC_ELF_OCTETS
, "OCTETS");
631 PF (SEC_ELF_PURECODE
, "PURECODE");
633 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
634 PF (SEC_GROUP
, "GROUP");
635 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
637 PF (SEC_MEP_VLIW
, "VLIW");
640 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
643 struct coff_comdat_info
*comdat
;
645 switch (section
->flags
& SEC_LINK_DUPLICATES
)
649 case SEC_LINK_DUPLICATES_DISCARD
:
650 ls
= "LINK_ONCE_DISCARD";
652 case SEC_LINK_DUPLICATES_ONE_ONLY
:
653 ls
= "LINK_ONCE_ONE_ONLY";
655 case SEC_LINK_DUPLICATES_SAME_SIZE
:
656 ls
= "LINK_ONCE_SAME_SIZE";
658 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
659 ls
= "LINK_ONCE_SAME_CONTENTS";
662 printf ("%s%s", comma
, ls
);
664 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
666 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
675 /* Called on each SECTION in ABFD, update the int variable pointed to by
676 DATA which contains the string length of the longest section name. */
679 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
680 asection
*section
, void *data
)
682 int *longest_so_far
= (int *) data
;
686 /* Ignore linker created section. */
687 if (section
->flags
& SEC_LINKER_CREATED
)
690 /* Skip sections that we are ignoring. */
691 if (! process_section_p (section
))
694 name
= bfd_section_name (section
);
695 len
= (int) strlen (name
);
696 if (len
> *longest_so_far
)
697 *longest_so_far
= len
;
701 dump_headers (bfd
*abfd
)
703 /* The default width of 13 is just an arbitrary choice. */
704 int max_section_name_length
= 13;
710 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
711 if (bfd_get_arch_size (abfd
) == 32)
717 printf (_("Sections:\n"));
720 bfd_map_over_sections (abfd
, find_longest_section_name
,
721 &max_section_name_length
);
723 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
724 max_section_name_length
, "Name",
725 bfd_vma_width
, "VMA",
726 bfd_vma_width
, "LMA");
729 printf (_(" Flags"));
732 bfd_map_over_sections (abfd
, dump_section_header
,
733 &max_section_name_length
);
737 slurp_symtab (bfd
*abfd
)
742 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
748 storage
= bfd_get_symtab_upper_bound (abfd
);
751 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
752 bfd_fatal (_("error message was"));
757 off_t filesize
= bfd_get_file_size (abfd
);
761 && filesize
< storage
762 /* The MMO file format supports its own special compression
763 technique, so its sections can be larger than the file size. */
764 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
766 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
767 _("error: symbol table size (%#lx) "
768 "is larger than filesize (%#lx)"),
769 storage
, (long) filesize
);
775 sy
= (asymbol
**) xmalloc (storage
);
778 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
780 bfd_fatal (bfd_get_filename (abfd
));
784 /* Read in the dynamic symbols. */
787 slurp_dynamic_symtab (bfd
*abfd
)
792 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
795 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
797 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
803 bfd_fatal (bfd_get_filename (abfd
));
807 sy
= (asymbol
**) xmalloc (storage
);
809 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
811 bfd_fatal (bfd_get_filename (abfd
));
815 /* Some symbol names are significant and should be kept in the
816 table of sorted symbol names, even if they are marked as
817 debugging/section symbols. */
820 is_significant_symbol_name (const char * name
)
822 return startswith (name
, ".plt") || startswith (name
, ".got");
825 /* Filter out (in place) symbols that are useless for disassembly.
826 COUNT is the number of elements in SYMBOLS.
827 Return the number of useful symbols. */
830 remove_useless_symbols (asymbol
**symbols
, long count
)
832 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
836 asymbol
*sym
= *in_ptr
++;
838 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
840 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
841 && ! is_significant_symbol_name (sym
->name
))
843 if (bfd_is_und_section (sym
->section
)
844 || bfd_is_com_section (sym
->section
))
849 return out_ptr
- symbols
;
852 static const asection
*compare_section
;
854 /* Sort symbols into value order. */
857 compare_symbols (const void *ap
, const void *bp
)
859 const asymbol
*a
= * (const asymbol
**) ap
;
860 const asymbol
*b
= * (const asymbol
**) bp
;
869 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
871 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
874 /* Prefer symbols from the section currently being disassembled.
875 Don't sort symbols from other sections by section, since there
876 isn't much reason to prefer one section over another otherwise.
877 See sym_ok comment for why we compare by section name. */
878 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
879 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
885 an
= bfd_asymbol_name (a
);
886 bn
= bfd_asymbol_name (b
);
890 /* The symbols gnu_compiled and gcc2_compiled convey no real
891 information, so put them after other symbols with the same value. */
892 af
= (strstr (an
, "gnu_compiled") != NULL
893 || strstr (an
, "gcc2_compiled") != NULL
);
894 bf
= (strstr (bn
, "gnu_compiled") != NULL
895 || strstr (bn
, "gcc2_compiled") != NULL
);
902 /* We use a heuristic for the file name, to try to sort it after
903 more useful symbols. It may not work on non Unix systems, but it
904 doesn't really matter; the only difference is precisely which
905 symbol names get printed. */
907 #define file_symbol(s, sn, snl) \
908 (((s)->flags & BSF_FILE) != 0 \
910 && (sn)[(snl) - 2] == '.' \
911 && ((sn)[(snl) - 1] == 'o' \
912 || (sn)[(snl) - 1] == 'a')))
914 af
= file_symbol (a
, an
, anl
);
915 bf
= file_symbol (b
, bn
, bnl
);
922 /* Sort function and object symbols before global symbols before
923 local symbols before section symbols before debugging symbols. */
928 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
930 if ((aflags
& BSF_DEBUGGING
) != 0)
935 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
937 if ((aflags
& BSF_SECTION_SYM
) != 0)
942 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
944 if ((aflags
& BSF_FUNCTION
) != 0)
949 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
951 if ((aflags
& BSF_OBJECT
) != 0)
956 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
958 if ((aflags
& BSF_LOCAL
) != 0)
963 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
965 if ((aflags
& BSF_GLOBAL
) != 0)
971 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
972 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
977 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
978 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
980 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
981 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
983 return asz
> bsz
? -1 : 1;
986 /* Symbols that start with '.' might be section names, so sort them
987 after symbols that don't start with '.'. */
988 if (an
[0] == '.' && bn
[0] != '.')
990 if (an
[0] != '.' && bn
[0] == '.')
993 /* Finally, if we can't distinguish them in any other way, try to
994 get consistent results by sorting the symbols by name. */
995 return strcmp (an
, bn
);
998 /* Sort relocs into address order. */
1001 compare_relocs (const void *ap
, const void *bp
)
1003 const arelent
*a
= * (const arelent
**) ap
;
1004 const arelent
*b
= * (const arelent
**) bp
;
1006 if (a
->address
> b
->address
)
1008 else if (a
->address
< b
->address
)
1011 /* So that associated relocations tied to the same address show up
1012 in the correct order, we don't do any further sorting. */
1021 /* Print an address (VMA) to the output stream in INFO.
1022 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1025 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1030 struct objdump_disasm_info
*aux
;
1032 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1033 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1038 for (p
= buf
; *p
== '0'; ++p
)
1043 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1046 /* Print the name of a symbol. */
1049 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1053 const char *name
, *version_string
= NULL
;
1054 bool hidden
= false;
1057 name
= bfd_asymbol_name (sym
);
1058 if (do_demangle
&& name
[0] != '\0')
1060 /* Demangle the name. */
1061 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1066 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1067 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1070 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1073 name
= sanitize_string (name
);
1077 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1078 if (version_string
&& *version_string
!= '\0')
1079 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1084 printf ("%s", name
);
1085 if (version_string
&& *version_string
!= '\0')
1086 printf (hidden
? "@%s" : "@@%s", version_string
);
1094 sym_ok (bool want_section
,
1095 bfd
*abfd ATTRIBUTE_UNUSED
,
1098 struct disassemble_info
*inf
)
1102 /* NB: An object file can have different sections with the same
1103 section name. Compare compare section pointers if they have
1105 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1106 && sorted_syms
[place
]->section
!= sec
)
1109 /* Note - we cannot just compare section pointers because they could
1110 be different, but the same... Ie the symbol that we are trying to
1111 find could have come from a separate debug info file. Under such
1112 circumstances the symbol will be associated with a section in the
1113 debug info file, whilst the section we want is in a normal file.
1114 So the section pointers will be different, but the section names
1115 will be the same. */
1116 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1117 bfd_section_name (sec
)) != 0)
1121 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1124 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1125 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1126 require the symbol to be in the section. Returns NULL if there is no
1127 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1128 of the symbol in sorted_syms. */
1131 find_symbol_for_address (bfd_vma vma
,
1132 struct disassemble_info
*inf
,
1135 /* @@ Would it speed things up to cache the last two symbols returned,
1136 and maybe their address ranges? For many processors, only one memory
1137 operand can be present at a time, so the 2-entry cache wouldn't be
1138 constantly churned by code doing heavy memory accesses. */
1140 /* Indices in `sorted_syms'. */
1142 long max_count
= sorted_symcount
;
1144 struct objdump_disasm_info
*aux
;
1151 if (sorted_symcount
< 1)
1154 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1157 opb
= inf
->octets_per_byte
;
1159 /* Perform a binary search looking for the closest symbol to the
1160 required value. We are searching the range (min, max_count]. */
1161 while (min
+ 1 < max_count
)
1165 thisplace
= (max_count
+ min
) / 2;
1166 sym
= sorted_syms
[thisplace
];
1168 if (bfd_asymbol_value (sym
) > vma
)
1169 max_count
= thisplace
;
1170 else if (bfd_asymbol_value (sym
) < vma
)
1179 /* The symbol we want is now in min, the low end of the range we
1180 were searching. If there are several symbols with the same
1181 value, we want the first one. */
1183 while (thisplace
> 0
1184 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1185 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1188 /* Prefer a symbol in the current section if we have multple symbols
1189 with the same value, as can occur with overlays or zero size
1192 while (min
< max_count
1193 && (bfd_asymbol_value (sorted_syms
[min
])
1194 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1196 if (sym_ok (true, abfd
, min
, sec
, inf
))
1203 return sorted_syms
[thisplace
];
1208 /* If the file is relocatable, and the symbol could be from this
1209 section, prefer a symbol from this section over symbols from
1210 others, even if the other symbol's value might be closer.
1212 Note that this may be wrong for some symbol references if the
1213 sections have overlapping memory ranges, but in that case there's
1214 no way to tell what's desired without looking at the relocation
1217 Also give the target a chance to reject symbols. */
1218 want_section
= (aux
->require_sec
1219 || ((abfd
->flags
& HAS_RELOC
) != 0
1220 && vma
>= bfd_section_vma (sec
)
1221 && vma
< (bfd_section_vma (sec
)
1222 + bfd_section_size (sec
) / opb
)));
1224 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1227 long newplace
= sorted_symcount
;
1229 for (i
= min
- 1; i
>= 0; i
--)
1231 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1233 if (newplace
== sorted_symcount
)
1236 if (bfd_asymbol_value (sorted_syms
[i
])
1237 != bfd_asymbol_value (sorted_syms
[newplace
]))
1240 /* Remember this symbol and keep searching until we reach
1241 an earlier address. */
1246 if (newplace
!= sorted_symcount
)
1247 thisplace
= newplace
;
1250 /* We didn't find a good symbol with a smaller value.
1251 Look for one with a larger value. */
1252 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1254 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1262 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1263 /* There is no suitable symbol. */
1267 /* If we have not found an exact match for the specified address
1268 and we have dynamic relocations available, then we can produce
1269 a better result by matching a relocation to the address and
1270 using the symbol associated with that relocation. */
1271 rel_count
= inf
->dynrelcount
;
1273 && sorted_syms
[thisplace
]->value
!= vma
1275 && inf
->dynrelbuf
!= NULL
1276 && inf
->dynrelbuf
[0]->address
<= vma
1277 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1278 /* If we have matched a synthetic symbol, then stick with that. */
1279 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1282 arelent
** rel_high
;
1284 rel_low
= inf
->dynrelbuf
;
1285 rel_high
= rel_low
+ rel_count
- 1;
1286 while (rel_low
<= rel_high
)
1288 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1289 arelent
* rel
= *rel_mid
;
1291 if (rel
->address
== vma
)
1293 /* Absolute relocations do not provide a more helpful
1294 symbolic address. Find a non-absolute relocation
1295 with the same address. */
1296 arelent
**rel_vma
= rel_mid
;
1298 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1302 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1306 if (rel
->sym_ptr_ptr
!= NULL
1307 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1310 * place
= thisplace
;
1311 return * rel
->sym_ptr_ptr
;
1317 if (vma
< rel
->address
)
1319 else if (vma
>= rel_mid
[1]->address
)
1320 rel_low
= rel_mid
+ 1;
1329 return sorted_syms
[thisplace
];
1332 /* Print an address and the offset to the nearest symbol. */
1335 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1336 bfd_vma vma
, struct disassemble_info
*inf
,
1341 objdump_print_value (vma
, inf
, skip_zeroes
);
1342 (*inf
->fprintf_func
) (inf
->stream
, " ");
1349 (*inf
->fprintf_func
) (inf
->stream
, "<%s",
1350 sanitize_string (bfd_section_name (sec
)));
1351 secaddr
= bfd_section_vma (sec
);
1354 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1355 objdump_print_value (secaddr
- vma
, inf
, true);
1357 else if (vma
> secaddr
)
1359 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1360 objdump_print_value (vma
- secaddr
, inf
, true);
1362 (*inf
->fprintf_func
) (inf
->stream
, ">");
1366 (*inf
->fprintf_func
) (inf
->stream
, "<");
1368 objdump_print_symname (abfd
, inf
, sym
);
1370 if (bfd_asymbol_value (sym
) == vma
)
1372 /* Undefined symbols in an executables and dynamic objects do not have
1373 a value associated with them, so it does not make sense to display
1374 an offset relative to them. Normally we would not be provided with
1375 this kind of symbol, but the target backend might choose to do so,
1376 and the code in find_symbol_for_address might return an as yet
1377 unresolved symbol associated with a dynamic reloc. */
1378 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1379 && bfd_is_und_section (sym
->section
))
1381 else if (bfd_asymbol_value (sym
) > vma
)
1383 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1384 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1386 else if (vma
> bfd_asymbol_value (sym
))
1388 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1389 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1392 (*inf
->fprintf_func
) (inf
->stream
, ">");
1395 if (display_file_offsets
)
1396 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1397 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1400 /* Print an address (VMA), symbolically if possible.
1401 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1404 objdump_print_addr (bfd_vma vma
,
1405 struct disassemble_info
*inf
,
1408 struct objdump_disasm_info
*aux
;
1409 asymbol
*sym
= NULL
;
1410 bool skip_find
= false;
1412 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1414 if (sorted_symcount
< 1)
1418 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1419 objdump_print_value (vma
, inf
, skip_zeroes
);
1422 if (display_file_offsets
)
1423 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1424 (long int) (inf
->section
->filepos
1425 + (vma
- inf
->section
->vma
)));
1429 if (aux
->reloc
!= NULL
1430 && aux
->reloc
->sym_ptr_ptr
!= NULL
1431 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1433 sym
= * aux
->reloc
->sym_ptr_ptr
;
1435 /* Adjust the vma to the reloc. */
1436 vma
+= bfd_asymbol_value (sym
);
1438 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1443 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1445 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1449 /* Print VMA to INFO. This function is passed to the disassembler
1453 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1455 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1458 /* Determine if the given address has a symbol associated with it. */
1461 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1465 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1466 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1472 /* Hold the last function name and the last line number we displayed
1473 in a disassembly. */
1475 static char *prev_functionname
;
1476 static unsigned int prev_line
;
1477 static unsigned int prev_discriminator
;
1479 /* We keep a list of all files that we have seen when doing a
1480 disassembly with source, so that we know how much of the file to
1481 display. This can be important for inlined functions. */
1483 struct print_file_list
1485 struct print_file_list
*next
;
1486 const char *filename
;
1487 const char *modname
;
1490 const char **linemap
;
1493 unsigned max_printed
;
1497 static struct print_file_list
*print_files
;
1499 /* The number of preceding context lines to show when we start
1500 displaying a file for the first time. */
1502 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1504 /* Read a complete file into memory. */
1507 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1510 int ps
= getpagesize ();
1514 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1518 if (fstat (fd
, fst
) < 0)
1523 *size
= fst
->st_size
;
1525 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1526 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1527 if (map
!= (char *) -1L)
1533 map
= (const char *) malloc (*size
);
1534 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1536 free ((void *) map
);
1543 #define line_map_decrease 5
1545 /* Precompute array of lines for a mapped file. */
1547 static const char **
1548 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1550 const char *p
, *lstart
, *end
;
1551 int chars_per_line
= 45; /* First iteration will use 40. */
1552 unsigned int lineno
;
1553 const char **linemap
= NULL
;
1554 unsigned long line_map_size
= 0;
1560 for (p
= map
; p
< end
; p
++)
1564 if (p
+ 1 < end
&& p
[1] == '\r')
1567 else if (*p
== '\r')
1569 if (p
+ 1 < end
&& p
[1] == '\n')
1575 /* End of line found. */
1577 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1579 unsigned long newsize
;
1581 chars_per_line
-= line_map_decrease
;
1582 if (chars_per_line
<= 1)
1584 line_map_size
= size
/ chars_per_line
+ 1;
1585 if (line_map_size
< lineno
+ 1)
1586 line_map_size
= lineno
+ 1;
1587 newsize
= line_map_size
* sizeof (char *);
1588 linemap
= (const char **) xrealloc (linemap
, newsize
);
1591 linemap
[lineno
++] = lstart
;
1599 /* Tries to open MODNAME, and if successful adds a node to print_files
1600 linked list and returns that node. Returns NULL on failure. */
1602 static struct print_file_list
*
1603 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1605 struct print_file_list
*p
;
1607 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1609 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1616 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1619 p
->filename
= origname
;
1620 p
->modname
= modname
;
1621 p
->next
= print_files
;
1627 /* If the source file, as described in the symtab, is not found
1628 try to locate it in one of the paths specified with -I
1629 If found, add location to print_files linked list. */
1631 static struct print_file_list
*
1632 update_source_path (const char *filename
, bfd
*abfd
)
1634 struct print_file_list
*p
;
1639 p
= try_print_file_open (filename
, filename
, &fst
);
1642 if (include_path_count
== 0)
1645 /* Get the name of the file. */
1646 fname
= lbasename (filename
);
1648 /* If file exists under a new path, we need to add it to the list
1649 so that show_line knows about it. */
1650 for (i
= 0; i
< include_path_count
; i
++)
1652 char *modname
= concat (include_paths
[i
], "/", fname
,
1655 p
= try_print_file_open (filename
, modname
, &fst
);
1665 long mtime
= bfd_get_mtime (abfd
);
1667 if (fst
.st_mtime
> mtime
)
1668 warn (_("source file %s is more recent than object file\n"),
1675 /* Print a source file line. */
1678 print_line (struct print_file_list
*p
, unsigned int linenum
)
1684 if (linenum
>= p
->maxline
)
1686 l
= p
->linemap
[linenum
];
1687 if (source_comment
!= NULL
&& strlen (l
) > 0)
1688 printf ("%s", source_comment
);
1689 len
= strcspn (l
, "\n\r");
1690 /* Test fwrite return value to quiet glibc warning. */
1691 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1695 /* Print a range of source code lines. */
1698 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1702 while (start
<= end
)
1704 print_line (p
, start
);
1709 /* Show the line number, or the source line, in a disassembly
1713 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1715 const char *filename
;
1716 const char *functionname
;
1717 unsigned int linenumber
;
1718 unsigned int discriminator
;
1722 if (! with_line_numbers
&& ! with_source_code
)
1725 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1726 &filename
, &functionname
,
1727 &linenumber
, &discriminator
))
1730 if (filename
!= NULL
&& *filename
== '\0')
1732 if (functionname
!= NULL
&& *functionname
== '\0')
1733 functionname
= NULL
;
1736 && IS_ABSOLUTE_PATH (filename
)
1740 const char *fname
= filename
;
1742 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
1745 memcpy (path
, prefix
, prefix_length
);
1746 path_up
= path
+ prefix_length
;
1748 /* Build relocated filename, stripping off leading directories
1749 from the initial filename if requested. */
1750 if (prefix_strip
> 0)
1755 /* Skip selected directory levels. */
1756 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1757 if (IS_DIR_SEPARATOR (*s
))
1764 /* Update complete filename. */
1765 strcpy (path_up
, fname
);
1773 if (with_line_numbers
)
1775 if (functionname
!= NULL
1776 && (prev_functionname
== NULL
1777 || strcmp (functionname
, prev_functionname
) != 0))
1779 char *demangle_alloc
= NULL
;
1780 if (do_demangle
&& functionname
[0] != '\0')
1782 /* Demangle the name. */
1783 demangle_alloc
= bfd_demangle (abfd
, functionname
,
1787 /* Demangling adds trailing parens, so don't print those. */
1788 if (demangle_alloc
!= NULL
)
1789 printf ("%s:\n", sanitize_string (demangle_alloc
));
1791 printf ("%s():\n", sanitize_string (functionname
));
1794 free (demangle_alloc
);
1797 && (linenumber
!= prev_line
1798 || discriminator
!= prev_discriminator
))
1800 if (discriminator
> 0)
1801 printf ("%s:%u (discriminator %u)\n",
1802 filename
== NULL
? "???" : sanitize_string (filename
),
1803 linenumber
, discriminator
);
1805 printf ("%s:%u\n", filename
== NULL
1806 ? "???" : sanitize_string (filename
),
1811 const char *filename2
;
1812 const char *functionname2
;
1815 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1818 printf ("inlined by %s:%u",
1819 sanitize_string (filename2
), line2
);
1820 printf (" (%s)\n", sanitize_string (functionname2
));
1825 if (with_source_code
1829 struct print_file_list
**pp
, *p
;
1832 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1833 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1840 filename
= xstrdup (filename
);
1841 p
= update_source_path (filename
, abfd
);
1844 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1846 if (file_start_context
&& p
->first
)
1850 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1851 if (l
>= linenumber
)
1853 if (p
->max_printed
>= l
)
1855 if (p
->max_printed
< linenumber
)
1856 l
= p
->max_printed
+ 1;
1861 dump_lines (p
, l
, linenumber
);
1862 if (p
->max_printed
< linenumber
)
1863 p
->max_printed
= linenumber
;
1864 p
->last_line
= linenumber
;
1869 if (functionname
!= NULL
1870 && (prev_functionname
== NULL
1871 || strcmp (functionname
, prev_functionname
) != 0))
1873 if (prev_functionname
!= NULL
)
1874 free (prev_functionname
);
1875 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1876 strcpy (prev_functionname
, functionname
);
1879 if (linenumber
> 0 && linenumber
!= prev_line
)
1880 prev_line
= linenumber
;
1882 if (discriminator
!= prev_discriminator
)
1883 prev_discriminator
= discriminator
;
1889 /* Pseudo FILE object for strings. */
1897 /* sprintf to a "stream". */
1899 static int ATTRIBUTE_PRINTF_2
1900 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1907 size_t space
= f
->alloc
- f
->pos
;
1909 va_start (args
, format
);
1910 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1916 f
->alloc
= (f
->alloc
+ n
) * 2;
1917 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1924 /* Code for generating (colored) diagrams of control flow start and end
1927 /* Structure used to store the properties of a jump. */
1931 /* The next jump, or NULL if this is the last object. */
1932 struct jump_info
*next
;
1933 /* The previous jump, or NULL if this is the first object. */
1934 struct jump_info
*prev
;
1935 /* The start addresses of the jump. */
1938 /* The list of start addresses. */
1940 /* The number of elements. */
1942 /* The maximum number of elements that fit into the array. */
1945 /* The end address of the jump. */
1947 /* The drawing level of the jump. */
1951 /* Construct a jump object for a jump from start
1952 to end with the corresponding level. */
1954 static struct jump_info
*
1955 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1957 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1959 result
->next
= NULL
;
1960 result
->prev
= NULL
;
1961 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1962 result
->start
.addresses
[0] = start
;
1963 result
->start
.count
= 1;
1964 result
->start
.max_count
= 2;
1966 result
->level
= level
;
1971 /* Free a jump object and return the next object
1972 or NULL if this was the last one. */
1974 static struct jump_info
*
1975 jump_info_free (struct jump_info
*ji
)
1977 struct jump_info
*result
= NULL
;
1982 if (ji
->start
.addresses
)
1983 free (ji
->start
.addresses
);
1990 /* Get the smallest value of all start and end addresses. */
1993 jump_info_min_address (const struct jump_info
*ji
)
1995 bfd_vma min_address
= ji
->end
;
1998 for (i
= ji
->start
.count
; i
-- > 0;)
1999 if (ji
->start
.addresses
[i
] < min_address
)
2000 min_address
= ji
->start
.addresses
[i
];
2004 /* Get the largest value of all start and end addresses. */
2007 jump_info_max_address (const struct jump_info
*ji
)
2009 bfd_vma max_address
= ji
->end
;
2012 for (i
= ji
->start
.count
; i
-- > 0;)
2013 if (ji
->start
.addresses
[i
] > max_address
)
2014 max_address
= ji
->start
.addresses
[i
];
2018 /* Get the target address of a jump. */
2021 jump_info_end_address (const struct jump_info
*ji
)
2026 /* Test if an address is one of the start addresses of a jump. */
2029 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2031 bool result
= false;
2034 for (i
= ji
->start
.count
; i
-- > 0;)
2035 if (address
== ji
->start
.addresses
[i
])
2044 /* Test if an address is the target address of a jump. */
2047 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2049 return (address
== ji
->end
);
2052 /* Get the difference between the smallest and largest address of a jump. */
2055 jump_info_size (const struct jump_info
*ji
)
2057 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2060 /* Unlink a jump object from a list. */
2063 jump_info_unlink (struct jump_info
*node
,
2064 struct jump_info
**base
)
2067 node
->next
->prev
= node
->prev
;
2069 node
->prev
->next
= node
->next
;
2076 /* Insert unlinked jump info node into a list. */
2079 jump_info_insert (struct jump_info
*node
,
2080 struct jump_info
*target
,
2081 struct jump_info
**base
)
2083 node
->next
= target
;
2084 node
->prev
= target
->prev
;
2085 target
->prev
= node
;
2087 node
->prev
->next
= node
;
2092 /* Add unlinked node to the front of a list. */
2095 jump_info_add_front (struct jump_info
*node
,
2096 struct jump_info
**base
)
2100 node
->next
->prev
= node
;
2105 /* Move linked node to target position. */
2108 jump_info_move_linked (struct jump_info
*node
,
2109 struct jump_info
*target
,
2110 struct jump_info
**base
)
2113 jump_info_unlink (node
, base
);
2114 /* Insert node at target position. */
2115 jump_info_insert (node
, target
, base
);
2118 /* Test if two jumps intersect. */
2121 jump_info_intersect (const struct jump_info
*a
,
2122 const struct jump_info
*b
)
2124 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2125 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2128 /* Merge two compatible jump info objects. */
2131 jump_info_merge (struct jump_info
**base
)
2133 struct jump_info
*a
;
2135 for (a
= *base
; a
; a
= a
->next
)
2137 struct jump_info
*b
;
2139 for (b
= a
->next
; b
; b
= b
->next
)
2141 /* Merge both jumps into one. */
2142 if (a
->end
== b
->end
)
2144 /* Reallocate addresses. */
2145 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2148 if (needed_size
> a
->start
.max_count
)
2150 a
->start
.max_count
+= b
->start
.max_count
;
2151 a
->start
.addresses
=
2152 xrealloc (a
->start
.addresses
,
2153 a
->start
.max_count
* sizeof (bfd_vma
*));
2156 /* Append start addresses. */
2157 for (i
= 0; i
< b
->start
.count
; ++i
)
2158 a
->start
.addresses
[a
->start
.count
++] =
2159 b
->start
.addresses
[i
];
2161 /* Remove and delete jump. */
2162 struct jump_info
*tmp
= b
->prev
;
2163 jump_info_unlink (b
, base
);
2171 /* Sort jumps by their size and starting point using a stable
2172 minsort. This could be improved if sorting performance is
2173 an issue, for example by using mergesort. */
2176 jump_info_sort (struct jump_info
**base
)
2178 struct jump_info
*current_element
= *base
;
2180 while (current_element
)
2182 struct jump_info
*best_match
= current_element
;
2183 struct jump_info
*runner
= current_element
->next
;
2184 bfd_vma best_size
= jump_info_size (best_match
);
2188 bfd_vma runner_size
= jump_info_size (runner
);
2190 if ((runner_size
< best_size
)
2191 || ((runner_size
== best_size
)
2192 && (jump_info_min_address (runner
)
2193 < jump_info_min_address (best_match
))))
2195 best_match
= runner
;
2196 best_size
= runner_size
;
2199 runner
= runner
->next
;
2202 if (best_match
== current_element
)
2203 current_element
= current_element
->next
;
2205 jump_info_move_linked (best_match
, current_element
, base
);
2209 /* Visualize all jumps at a given address. */
2212 jump_info_visualize_address (bfd_vma address
,
2215 uint8_t *color_buffer
)
2217 struct jump_info
*ji
= detected_jumps
;
2218 size_t len
= (max_level
+ 1) * 3;
2220 /* Clear line buffer. */
2221 memset (line_buffer
, ' ', len
);
2222 memset (color_buffer
, 0, len
);
2224 /* Iterate over jumps and add their ASCII art. */
2227 /* Discard jumps that are never needed again. */
2228 if (jump_info_max_address (ji
) < address
)
2230 struct jump_info
*tmp
= ji
;
2233 jump_info_unlink (tmp
, &detected_jumps
);
2234 jump_info_free (tmp
);
2238 /* This jump intersects with the current address. */
2239 if (jump_info_min_address (ji
) <= address
)
2241 /* Hash target address to get an even
2242 distribution between all values. */
2243 bfd_vma hash_address
= jump_info_end_address (ji
);
2244 uint8_t color
= iterative_hash_object (hash_address
, 0);
2245 /* Fetch line offset. */
2246 int offset
= (max_level
- ji
->level
) * 3;
2248 /* Draw start line. */
2249 if (jump_info_is_start_address (ji
, address
))
2251 size_t i
= offset
+ 1;
2253 for (; i
< len
- 1; ++i
)
2254 if (line_buffer
[i
] == ' ')
2256 line_buffer
[i
] = '-';
2257 color_buffer
[i
] = color
;
2260 if (line_buffer
[i
] == ' ')
2262 line_buffer
[i
] = '-';
2263 color_buffer
[i
] = color
;
2265 else if (line_buffer
[i
] == '>')
2267 line_buffer
[i
] = 'X';
2268 color_buffer
[i
] = color
;
2271 if (line_buffer
[offset
] == ' ')
2273 if (address
<= ji
->end
)
2274 line_buffer
[offset
] =
2275 (jump_info_min_address (ji
) == address
) ? '/': '+';
2277 line_buffer
[offset
] =
2278 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2279 color_buffer
[offset
] = color
;
2282 /* Draw jump target. */
2283 else if (jump_info_is_end_address (ji
, address
))
2285 size_t i
= offset
+ 1;
2287 for (; i
< len
- 1; ++i
)
2288 if (line_buffer
[i
] == ' ')
2290 line_buffer
[i
] = '-';
2291 color_buffer
[i
] = color
;
2294 if (line_buffer
[i
] == ' ')
2296 line_buffer
[i
] = '>';
2297 color_buffer
[i
] = color
;
2299 else if (line_buffer
[i
] == '-')
2301 line_buffer
[i
] = 'X';
2302 color_buffer
[i
] = color
;
2305 if (line_buffer
[offset
] == ' ')
2307 if (jump_info_min_address (ji
) < address
)
2308 line_buffer
[offset
] =
2309 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2311 line_buffer
[offset
] = '/';
2312 color_buffer
[offset
] = color
;
2315 /* Draw intermediate line segment. */
2316 else if (line_buffer
[offset
] == ' ')
2318 line_buffer
[offset
] = '|';
2319 color_buffer
[offset
] = color
;
2327 /* Clone of disassemble_bytes to detect jumps inside a function. */
2328 /* FIXME: is this correct? Can we strip it down even further? */
2330 static struct jump_info
*
2331 disassemble_jumps (struct disassemble_info
* inf
,
2332 disassembler_ftype disassemble_fn
,
2333 bfd_vma start_offset
,
2334 bfd_vma stop_offset
,
2337 arelent
** relppend
)
2339 struct objdump_disasm_info
*aux
;
2340 struct jump_info
*jumps
= NULL
;
2342 bfd_vma addr_offset
;
2343 unsigned int opb
= inf
->octets_per_byte
;
2347 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2348 section
= inf
->section
;
2351 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2354 inf
->insn_info_valid
= 0;
2355 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2356 inf
->stream
= &sfile
;
2358 addr_offset
= start_offset
;
2359 while (addr_offset
< stop_offset
)
2361 int previous_octets
;
2363 /* Remember the length of the previous instruction. */
2364 previous_octets
= octets
;
2368 inf
->bytes_per_line
= 0;
2369 inf
->bytes_per_chunk
= 0;
2370 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2371 | (wide_output
? WIDE_OUTPUT
: 0));
2373 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2375 if (inf
->disassembler_needs_relocs
2376 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2377 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2378 && *relppp
< relppend
)
2380 bfd_signed_vma distance_to_rel
;
2382 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2384 /* Check to see if the current reloc is associated with
2385 the instruction that we are about to disassemble. */
2386 if (distance_to_rel
== 0
2387 /* FIXME: This is wrong. We are trying to catch
2388 relocs that are addressed part way through the
2389 current instruction, as might happen with a packed
2390 VLIW instruction. Unfortunately we do not know the
2391 length of the current instruction since we have not
2392 disassembled it yet. Instead we take a guess based
2393 upon the length of the previous instruction. The
2394 proper solution is to have a new target-specific
2395 disassembler function which just returns the length
2396 of an instruction at a given address without trying
2397 to display its disassembly. */
2398 || (distance_to_rel
> 0
2399 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2401 inf
->flags
|= INSN_HAS_RELOC
;
2405 if (! disassemble_all
2406 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2407 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2408 /* Set a stop_vma so that the disassembler will not read
2409 beyond the next symbol. We assume that symbols appear on
2410 the boundaries between instructions. We only do this when
2411 disassembling code of course, and when -D is in effect. */
2412 inf
->stop_vma
= section
->vma
+ stop_offset
;
2414 inf
->stop_offset
= stop_offset
;
2416 /* Extract jump information. */
2417 inf
->insn_info_valid
= 0;
2418 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2419 /* Test if a jump was detected. */
2420 if (inf
->insn_info_valid
2421 && ((inf
->insn_type
== dis_branch
)
2422 || (inf
->insn_type
== dis_condbranch
)
2423 || (inf
->insn_type
== dis_jsr
)
2424 || (inf
->insn_type
== dis_condjsr
))
2425 && (inf
->target
>= section
->vma
+ start_offset
)
2426 && (inf
->target
< section
->vma
+ stop_offset
))
2428 struct jump_info
*ji
=
2429 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2430 jump_info_add_front (ji
, &jumps
);
2435 addr_offset
+= octets
/ opb
;
2438 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2439 inf
->stream
= stdout
;
2441 free (sfile
.buffer
);
2444 jump_info_merge (&jumps
);
2445 /* Process jumps. */
2446 jump_info_sort (&jumps
);
2448 /* Group jumps by level. */
2449 struct jump_info
*last_jump
= jumps
;
2454 /* The last jump is part of the next group. */
2455 struct jump_info
*base
= last_jump
;
2456 /* Increment level. */
2457 base
->level
= ++max_level
;
2459 /* Find jumps that can be combined on the same
2460 level, with the largest jumps tested first.
2461 This has the advantage that large jumps are on
2462 lower levels and do not intersect with small
2463 jumps that get grouped on higher levels. */
2464 struct jump_info
*exchange_item
= last_jump
->next
;
2465 struct jump_info
*it
= exchange_item
;
2467 for (; it
; it
= it
->next
)
2469 /* Test if the jump intersects with any
2470 jump from current group. */
2472 struct jump_info
*it_collision
;
2474 for (it_collision
= base
;
2475 it_collision
!= exchange_item
;
2476 it_collision
= it_collision
->next
)
2478 /* This jump intersects so we leave it out. */
2479 if (jump_info_intersect (it_collision
, it
))
2486 /* Add jump to group. */
2489 /* Move current element to the front. */
2490 if (it
!= exchange_item
)
2492 struct jump_info
*save
= it
->prev
;
2493 jump_info_move_linked (it
, exchange_item
, &jumps
);
2499 last_jump
= exchange_item
;
2500 exchange_item
= exchange_item
->next
;
2502 last_jump
->level
= max_level
;
2506 /* Move to next group. */
2507 last_jump
= exchange_item
;
2513 /* The number of zeroes we want to see before we start skipping them.
2514 The number is arbitrarily chosen. */
2516 #define DEFAULT_SKIP_ZEROES 8
2518 /* The number of zeroes to skip at the end of a section. If the
2519 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2520 SKIP_ZEROES, they will be disassembled. If there are fewer than
2521 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2522 attempt to avoid disassembling zeroes inserted by section
2525 #define DEFAULT_SKIP_ZEROES_AT_END 3
2528 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2533 /* Print out jump visualization. */
2536 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2537 uint8_t *color_buffer
)
2542 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2544 size_t line_buffer_size
= strlen (line_buffer
);
2545 char last_color
= 0;
2548 for (i
= 0; i
<= line_buffer_size
; ++i
)
2552 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2554 if (color
!= last_color
)
2557 if (extended_color_output
)
2558 /* Use extended 8bit color, but
2559 do not choose dark colors. */
2560 printf ("\033[38;5;%dm", 124 + (color
% 108));
2562 /* Use simple terminal colors. */
2563 printf ("\033[%dm", 31 + (color
% 7));
2570 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2574 /* Disassemble some data in memory between given values. */
2577 disassemble_bytes (struct disassemble_info
*inf
,
2578 disassembler_ftype disassemble_fn
,
2581 bfd_vma start_offset
,
2582 bfd_vma stop_offset
,
2587 struct objdump_disasm_info
*aux
;
2589 unsigned int octets_per_line
;
2590 unsigned int skip_addr_chars
;
2591 bfd_vma addr_offset
;
2592 unsigned int opb
= inf
->octets_per_byte
;
2593 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2594 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2598 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2599 section
= inf
->section
;
2602 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2606 octets_per_line
= insn_width
;
2608 octets_per_line
= 4;
2610 octets_per_line
= 16;
2612 /* Figure out how many characters to skip at the start of an
2613 address, to make the disassembly look nicer. We discard leading
2614 zeroes in chunks of 4, ensuring that there is always a leading
2616 skip_addr_chars
= 0;
2617 if (!no_addresses
&& !prefix_addresses
)
2621 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2623 while (buf
[skip_addr_chars
] == '0')
2626 /* Don't discard zeros on overflow. */
2627 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2628 skip_addr_chars
= 0;
2630 if (skip_addr_chars
!= 0)
2631 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2634 inf
->insn_info_valid
= 0;
2636 /* Determine maximum level. */
2637 uint8_t *color_buffer
= NULL
;
2638 char *line_buffer
= NULL
;
2641 /* Some jumps were detected. */
2644 struct jump_info
*ji
;
2646 /* Find maximum jump level. */
2647 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2649 if (ji
->level
> max_level
)
2650 max_level
= ji
->level
;
2653 /* Allocate buffers. */
2654 size_t len
= (max_level
+ 1) * 3 + 1;
2655 line_buffer
= xmalloc (len
);
2656 line_buffer
[len
- 1] = 0;
2657 color_buffer
= xmalloc (len
);
2658 color_buffer
[len
- 1] = 0;
2661 addr_offset
= start_offset
;
2662 while (addr_offset
< stop_offset
)
2664 bool need_nl
= false;
2668 /* Make sure we don't use relocs from previous instructions. */
2671 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2673 if (! disassemble_zeroes
)
2674 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
2675 if (data
[addr_offset
* opb
+ octets
] != 0)
2677 if (! disassemble_zeroes
2678 && (inf
->insn_info_valid
== 0
2679 || inf
->branch_delay_insns
== 0)
2680 && (octets
>= skip_zeroes
2681 || (addr_offset
* opb
+ octets
== stop_offset
* opb
2682 && octets
< skip_zeroes_at_end
)))
2684 /* If there are more nonzero octets to follow, we only skip
2685 zeroes in multiples of 4, to try to avoid running over
2686 the start of an instruction which happens to start with
2688 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
2691 /* If we are going to display more data, and we are displaying
2692 file offsets, then tell the user how many zeroes we skip
2693 and the file offset from where we resume dumping. */
2694 if (display_file_offsets
2695 && addr_offset
+ octets
/ opb
< stop_offset
)
2696 printf (_("\t... (skipping %lu zeroes, "
2697 "resuming at file offset: 0x%lx)\n"),
2698 (unsigned long) (octets
/ opb
),
2699 (unsigned long) (section
->filepos
2700 + addr_offset
+ octets
/ opb
));
2707 unsigned int bpc
= 0;
2708 unsigned int pb
= 0;
2710 if (with_line_numbers
|| with_source_code
)
2711 show_line (aux
->abfd
, section
, addr_offset
);
2715 else if (!prefix_addresses
)
2719 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2720 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2724 printf ("%s:\t", buf
+ skip_addr_chars
);
2728 aux
->require_sec
= true;
2729 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2730 aux
->require_sec
= false;
2734 print_jump_visualisation (section
->vma
+ addr_offset
,
2735 max_level
, line_buffer
,
2743 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2744 inf
->stream
= &sfile
;
2745 inf
->bytes_per_line
= 0;
2746 inf
->bytes_per_chunk
= 0;
2747 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2748 | (wide_output
? WIDE_OUTPUT
: 0));
2750 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2752 if (inf
->disassembler_needs_relocs
2753 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2754 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2755 && *relppp
< relppend
)
2757 bfd_signed_vma distance_to_rel
;
2758 int max_reloc_offset
2759 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2761 distance_to_rel
= ((**relppp
)->address
- rel_offset
2765 if (distance_to_rel
> 0
2766 && (max_reloc_offset
< 0
2767 || distance_to_rel
<= max_reloc_offset
))
2769 /* This reloc *might* apply to the current insn,
2770 starting somewhere inside it. Discover the length
2771 of the current insn so that the check below will
2774 insn_size
= insn_width
;
2777 /* We find the length by calling the dissassembler
2778 function with a dummy print handler. This should
2779 work unless the disassembler is not expecting to
2780 be called multiple times for the same address.
2782 This does mean disassembling the instruction
2783 twice, but we only do this when there is a high
2784 probability that there is a reloc that will
2785 affect the instruction. */
2786 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2787 insn_size
= disassemble_fn (section
->vma
2788 + addr_offset
, inf
);
2789 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2793 /* Check to see if the current reloc is associated with
2794 the instruction that we are about to disassemble. */
2795 if (distance_to_rel
== 0
2796 || (distance_to_rel
> 0
2797 && distance_to_rel
< insn_size
/ (int) opb
))
2799 inf
->flags
|= INSN_HAS_RELOC
;
2800 aux
->reloc
= **relppp
;
2804 if (! disassemble_all
2805 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2806 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
2807 /* Set a stop_vma so that the disassembler will not read
2808 beyond the next symbol. We assume that symbols appear on
2809 the boundaries between instructions. We only do this when
2810 disassembling code of course, and when -D is in effect. */
2811 inf
->stop_vma
= section
->vma
+ stop_offset
;
2813 inf
->stop_offset
= stop_offset
;
2814 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2818 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2819 inf
->stream
= stdout
;
2820 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2821 octets_per_line
= inf
->bytes_per_line
;
2822 if (insn_size
< (int) opb
)
2825 printf ("%s\n", sfile
.buffer
);
2828 non_fatal (_("disassemble_fn returned length %d"),
2839 octets
= octets_per_line
;
2840 if (addr_offset
+ octets
/ opb
> stop_offset
)
2841 octets
= (stop_offset
- addr_offset
) * opb
;
2843 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2845 if (ISPRINT (data
[j
]))
2846 buf
[j
- addr_offset
* opb
] = data
[j
];
2848 buf
[j
- addr_offset
* opb
] = '.';
2850 buf
[j
- addr_offset
* opb
] = '\0';
2853 if (prefix_addresses
2855 : show_raw_insn
>= 0)
2859 /* If ! prefix_addresses and ! wide_output, we print
2860 octets_per_line octets per line. */
2862 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2863 pb
= octets_per_line
;
2865 if (inf
->bytes_per_chunk
)
2866 bpc
= inf
->bytes_per_chunk
;
2870 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2872 /* PR 21580: Check for a buffer ending early. */
2873 if (j
+ bpc
<= stop_offset
* opb
)
2877 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2879 for (k
= bpc
; k
-- != 0; )
2880 printf ("%02x", (unsigned) data
[j
+ k
]);
2884 for (k
= 0; k
< bpc
; k
++)
2885 printf ("%02x", (unsigned) data
[j
+ k
]);
2891 for (; pb
< octets_per_line
; pb
+= bpc
)
2895 for (k
= 0; k
< bpc
; k
++)
2900 /* Separate raw data from instruction by extra space. */
2910 printf ("%s", sfile
.buffer
);
2912 if (prefix_addresses
2914 : show_raw_insn
>= 0)
2922 j
= addr_offset
* opb
+ pb
;
2928 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2929 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2933 printf ("%s:\t", buf
+ skip_addr_chars
);
2936 print_jump_visualisation (section
->vma
+ j
/ opb
,
2937 max_level
, line_buffer
,
2940 pb
+= octets_per_line
;
2943 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2945 /* PR 21619: Check for a buffer ending early. */
2946 if (j
+ bpc
<= stop_offset
* opb
)
2950 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2952 for (k
= bpc
; k
-- != 0; )
2953 printf ("%02x", (unsigned) data
[j
+ k
]);
2957 for (k
= 0; k
< bpc
; k
++)
2958 printf ("%02x", (unsigned) data
[j
+ k
]);
2972 while ((*relppp
) < relppend
2973 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2975 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2988 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2993 if (q
->howto
== NULL
)
2994 printf ("*unknown*\t");
2995 else if (q
->howto
->name
)
2996 printf ("%s\t", q
->howto
->name
);
2998 printf ("%d\t", q
->howto
->type
);
3000 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3001 printf ("*unknown*");
3004 const char *sym_name
;
3006 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3007 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3008 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3013 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3014 sym_name
= bfd_section_name (sym_sec
);
3015 if (sym_name
== NULL
|| *sym_name
== '\0')
3016 sym_name
= "*unknown*";
3017 printf ("%s", sanitize_string (sym_name
));
3023 bfd_vma addend
= q
->addend
;
3024 if ((bfd_signed_vma
) addend
< 0)
3031 objdump_print_value (addend
, inf
, true);
3043 addr_offset
+= octets
/ opb
;
3046 free (sfile
.buffer
);
3048 free (color_buffer
);
3052 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3054 const struct elf_backend_data
*bed
;
3055 bfd_vma sign_adjust
= 0;
3056 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3057 struct objdump_disasm_info
*paux
;
3058 unsigned int opb
= pinfo
->octets_per_byte
;
3059 bfd_byte
*data
= NULL
;
3060 bfd_size_type datasize
= 0;
3061 arelent
**rel_pp
= NULL
;
3062 arelent
**rel_ppstart
= NULL
;
3063 arelent
**rel_ppend
;
3064 bfd_vma stop_offset
;
3065 asymbol
*sym
= NULL
;
3069 unsigned long addr_offset
;
3073 stop_offset_reached
,
3078 /* Sections that do not contain machine
3079 code are not normally disassembled. */
3080 if (! disassemble_all
3081 && only_list
== NULL
3082 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3083 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3086 if (! process_section_p (section
))
3089 datasize
= bfd_section_size (section
);
3093 if (start_address
== (bfd_vma
) -1
3094 || start_address
< section
->vma
)
3097 addr_offset
= start_address
- section
->vma
;
3099 if (stop_address
== (bfd_vma
) -1)
3100 stop_offset
= datasize
/ opb
;
3103 if (stop_address
< section
->vma
)
3106 stop_offset
= stop_address
- section
->vma
;
3107 if (stop_offset
> datasize
/ opb
)
3108 stop_offset
= datasize
/ opb
;
3111 if (addr_offset
>= stop_offset
)
3114 /* Decide which set of relocs to use. Load them if necessary. */
3115 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3116 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3118 rel_pp
= pinfo
->dynrelbuf
;
3119 rel_count
= pinfo
->dynrelcount
;
3120 /* Dynamic reloc addresses are absolute, non-dynamic are section
3121 relative. REL_OFFSET specifies the reloc address corresponding
3122 to the start of this section. */
3123 rel_offset
= section
->vma
;
3131 if ((section
->flags
& SEC_RELOC
) != 0
3132 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3136 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3138 bfd_fatal (bfd_get_filename (abfd
));
3142 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3143 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3145 bfd_fatal (bfd_get_filename (abfd
));
3147 /* Sort the relocs by address. */
3148 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3152 rel_ppend
= rel_pp
+ rel_count
;
3154 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3156 non_fatal (_("Reading section %s failed because: %s"),
3157 section
->name
, bfd_errmsg (bfd_get_error ()));
3161 pinfo
->buffer
= data
;
3162 pinfo
->buffer_vma
= section
->vma
;
3163 pinfo
->buffer_length
= datasize
;
3164 pinfo
->section
= section
;
3166 /* Sort the symbols into value and section order. */
3167 compare_section
= section
;
3168 if (sorted_symcount
> 1)
3169 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3171 /* Skip over the relocs belonging to addresses below the
3173 while (rel_pp
< rel_ppend
3174 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3177 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3179 /* Find the nearest symbol forwards from our current position. */
3180 paux
->require_sec
= true;
3181 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3182 (struct disassemble_info
*) inf
,
3184 paux
->require_sec
= false;
3186 /* PR 9774: If the target used signed addresses then we must make
3187 sure that we sign extend the value that we calculate for 'addr'
3188 in the loop below. */
3189 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3190 && (bed
= get_elf_backend_data (abfd
)) != NULL
3191 && bed
->sign_extend_vma
)
3192 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3194 /* Disassemble a block of instructions up to the address associated with
3195 the symbol we have just found. Then print the symbol and find the
3196 next symbol on. Repeat until we have disassembled the entire section
3197 or we have reached the end of the address range we are interested in. */
3198 do_print
= paux
->symbol
== NULL
;
3199 loop_until
= stop_offset_reached
;
3201 while (addr_offset
< stop_offset
)
3205 bfd_vma nextstop_offset
;
3208 addr
= section
->vma
+ addr_offset
;
3209 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3211 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3216 (x
< sorted_symcount
3217 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3221 pinfo
->symbols
= sorted_syms
+ place
;
3222 pinfo
->num_symbols
= x
- place
;
3223 pinfo
->symtab_pos
= place
;
3227 pinfo
->symbols
= NULL
;
3228 pinfo
->num_symbols
= 0;
3229 pinfo
->symtab_pos
= -1;
3232 /* If we are only disassembling from a specific symbol,
3233 check to see if we should start or stop displaying. */
3234 if (sym
&& paux
->symbol
)
3238 /* See if we should stop printing. */
3242 if (sym
->flags
& BSF_FUNCTION
)
3246 case stop_offset_reached
:
3247 /* Handled by the while loop. */
3251 /* FIXME: There is an implicit assumption here
3252 that the name of sym is different from
3254 if (! bfd_is_local_label (abfd
, sym
))
3261 const char * name
= bfd_asymbol_name (sym
);
3262 char * alloc
= NULL
;
3264 if (do_demangle
&& name
[0] != '\0')
3266 /* Demangle the name. */
3267 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3272 /* We are not currently printing. Check to see
3273 if the current symbol matches the requested symbol. */
3274 if (streq (name
, paux
->symbol
))
3278 if (sym
->flags
& BSF_FUNCTION
)
3280 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3281 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3283 /* Sym is a function symbol with a size associated
3284 with it. Turn on automatic disassembly for the
3285 next VALUE bytes. */
3286 stop_offset
= addr_offset
3287 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3288 loop_until
= stop_offset_reached
;
3292 /* Otherwise we need to tell the loop heuristic to
3293 loop until the next function symbol is encountered. */
3294 loop_until
= function_sym
;
3299 /* Otherwise loop until the next symbol is encountered. */
3300 loop_until
= next_sym
;
3308 if (! prefix_addresses
&& do_print
)
3310 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3311 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3313 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3316 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3318 else if (sym
== NULL
)
3322 #define is_valid_next_sym(SYM) \
3323 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3324 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3325 && pinfo->symbol_is_valid (SYM, pinfo))
3327 /* Search forward for the next appropriate symbol in
3328 SECTION. Note that all the symbols are sorted
3329 together into one big array, and that some sections
3330 may have overlapping addresses. */
3331 while (place
< sorted_symcount
3332 && ! is_valid_next_sym (sorted_syms
[place
]))
3335 if (place
>= sorted_symcount
)
3338 nextsym
= sorted_syms
[place
];
3341 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3342 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3343 else if (nextsym
== NULL
)
3344 nextstop_offset
= stop_offset
;
3346 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3348 if (nextstop_offset
> stop_offset
3349 || nextstop_offset
<= addr_offset
)
3350 nextstop_offset
= stop_offset
;
3352 /* If a symbol is explicitly marked as being an object
3353 rather than a function, just dump the bytes without
3354 disassembling them. */
3357 || sym
->section
!= section
3358 || bfd_asymbol_value (sym
) > addr
3359 || ((sym
->flags
& BSF_OBJECT
) == 0
3360 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3362 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3364 || (sym
->flags
& BSF_FUNCTION
) != 0)
3371 /* Resolve symbol name. */
3372 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3374 struct disassemble_info di
;
3377 sf
.alloc
= strlen (sym
->name
) + 40;
3378 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3380 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3383 objdump_print_symname (abfd
, &di
, sym
);
3385 /* Fetch jump information. */
3386 detected_jumps
= disassemble_jumps
3387 (pinfo
, paux
->disassemble_fn
,
3388 addr_offset
, nextstop_offset
,
3389 rel_offset
, &rel_pp
, rel_ppend
);
3391 /* Free symbol name. */
3395 /* Add jumps to output. */
3396 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3397 addr_offset
, nextstop_offset
,
3398 rel_offset
, &rel_pp
, rel_ppend
);
3401 while (detected_jumps
)
3403 detected_jumps
= jump_info_free (detected_jumps
);
3407 addr_offset
= nextstop_offset
;
3413 if (rel_ppstart
!= NULL
)
3417 /* Disassemble the contents of an object file. */
3420 disassemble_data (bfd
*abfd
)
3422 struct disassemble_info disasm_info
;
3423 struct objdump_disasm_info aux
;
3427 prev_functionname
= NULL
;
3429 prev_discriminator
= 0;
3431 /* We make a copy of syms to sort. We don't want to sort syms
3432 because that will screw up the relocs. */
3433 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3434 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3435 * sizeof (asymbol
*));
3436 if (sorted_symcount
!= 0)
3438 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3439 sorted_symcount
* sizeof (asymbol
*));
3441 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3444 for (i
= 0; i
< synthcount
; ++i
)
3446 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3450 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3452 disasm_info
.application_data
= (void *) &aux
;
3454 aux
.require_sec
= false;
3455 disasm_info
.dynrelbuf
= NULL
;
3456 disasm_info
.dynrelcount
= 0;
3458 aux
.symbol
= disasm_sym
;
3460 disasm_info
.print_address_func
= objdump_print_address
;
3461 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3463 if (machine
!= NULL
)
3465 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3468 fatal (_("can't use supplied machine %s"), machine
);
3470 abfd
->arch_info
= inf
;
3473 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3475 struct bfd_target
*xvec
;
3477 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3478 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3479 xvec
->byteorder
= endian
;
3483 /* Use libopcodes to locate a suitable disassembler. */
3484 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3485 bfd_big_endian (abfd
),
3486 bfd_get_mach (abfd
), abfd
);
3487 if (!aux
.disassemble_fn
)
3489 non_fatal (_("can't disassemble for architecture %s\n"),
3490 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3495 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3496 disasm_info
.arch
= bfd_get_arch (abfd
);
3497 disasm_info
.mach
= bfd_get_mach (abfd
);
3498 disasm_info
.disassembler_options
= disassembler_options
;
3499 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3500 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3501 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3502 disasm_info
.disassembler_needs_relocs
= false;
3504 if (bfd_big_endian (abfd
))
3505 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3506 else if (bfd_little_endian (abfd
))
3507 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3509 /* ??? Aborting here seems too drastic. We could default to big or little
3511 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3513 disasm_info
.endian_code
= disasm_info
.endian
;
3515 /* Allow the target to customize the info structure. */
3516 disassemble_init_for_target (& disasm_info
);
3518 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3519 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3521 if (relsize
< 0 && dump_dynamic_reloc_info
)
3522 bfd_fatal (bfd_get_filename (abfd
));
3526 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3527 disasm_info
.dynrelcount
3528 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
3529 if (disasm_info
.dynrelcount
< 0)
3530 bfd_fatal (bfd_get_filename (abfd
));
3532 /* Sort the relocs by address. */
3533 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
3537 disasm_info
.symtab
= sorted_syms
;
3538 disasm_info
.symtab_size
= sorted_symcount
;
3540 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3542 free (disasm_info
.dynrelbuf
);
3543 disasm_info
.dynrelbuf
= NULL
;
3545 disassemble_free_target (&disasm_info
);
3549 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3550 asection
*sec
, void *file
)
3552 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3553 bfd
*abfd
= (bfd
*) file
;
3559 if (section
->start
!= NULL
)
3561 /* If it is already loaded, do nothing. */
3562 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3564 free (section
->start
);
3567 section
->filename
= bfd_get_filename (abfd
);
3568 section
->reloc_info
= NULL
;
3569 section
->num_relocs
= 0;
3570 section
->address
= bfd_section_vma (sec
);
3571 section
->size
= bfd_section_size (sec
);
3572 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3573 alloced
= amt
= section
->size
+ 1;
3574 if (alloced
!= amt
|| alloced
== 0)
3576 section
->start
= NULL
;
3577 free_debug_section (debug
);
3578 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3579 sanitize_string (section
->name
),
3580 (unsigned long long) section
->size
);
3584 section
->start
= contents
= xmalloc (alloced
);
3585 /* Ensure any string section has a terminating NUL. */
3586 section
->start
[section
->size
] = 0;
3588 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3589 && debug_displays
[debug
].relocate
)
3591 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3597 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3601 unsigned long reloc_count
;
3604 relocs
= (arelent
**) xmalloc (reloc_size
);
3606 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3607 if (reloc_count
== 0)
3611 section
->reloc_info
= relocs
;
3612 section
->num_relocs
= reloc_count
;
3618 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
3622 free_debug_section (debug
);
3623 printf (_("\nCan't get contents for section '%s'.\n"),
3624 sanitize_string (section
->name
));
3632 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3637 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3640 relocs
= (arelent
**) dsec
->reloc_info
;
3642 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3643 if (rp
->address
== offset
)
3650 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3652 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3653 bfd
*abfd
= (bfd
*) file
;
3656 /* If it is already loaded, do nothing. */
3657 if (section
->start
!= NULL
)
3659 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3663 /* Locate the debug section. */
3664 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3666 section
->name
= section
->uncompressed_name
;
3669 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3671 section
->name
= section
->compressed_name
;
3676 return load_specific_debug_section (debug
, sec
, file
);
3680 free_debug_section (enum dwarf_section_display_enum debug
)
3682 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3684 free ((char *) section
->start
);
3685 section
->start
= NULL
;
3686 section
->address
= 0;
3691 close_debug_file (void * file
)
3693 bfd
* abfd
= (bfd
*) file
;
3699 open_debug_file (const char * pathname
)
3703 data
= bfd_openr (pathname
, NULL
);
3707 if (! bfd_check_format (data
, bfd_object
))
3713 #if HAVE_LIBDEBUGINFOD
3714 /* Return a hex string represention of the build-id. */
3717 get_build_id (void * data
)
3720 char * build_id_str
;
3721 bfd
* abfd
= (bfd
*) data
;
3722 const struct bfd_build_id
* build_id
;
3724 build_id
= abfd
->build_id
;
3725 if (build_id
== NULL
)
3728 build_id_str
= malloc (build_id
->size
* 2 + 1);
3729 if (build_id_str
== NULL
)
3732 for (i
= 0; i
< build_id
->size
; i
++)
3733 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3734 build_id_str
[build_id
->size
* 2] = '\0';
3736 return (unsigned char *)build_id_str
;
3738 #endif /* HAVE_LIBDEBUGINFOD */
3741 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3742 void *arg ATTRIBUTE_UNUSED
)
3744 const char *name
= bfd_section_name (section
);
3748 if (startswith (name
, ".gnu.linkonce.wi."))
3749 match
= ".debug_info";
3753 for (i
= 0; i
< max
; i
++)
3754 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3755 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3756 && debug_displays
[i
].enabled
!= NULL
3757 && *debug_displays
[i
].enabled
)
3759 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3761 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3762 sec
->name
= sec
->uncompressed_name
;
3764 sec
->name
= sec
->compressed_name
;
3765 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3768 debug_displays
[i
].display (sec
, abfd
);
3770 if (i
!= info
&& i
!= abbrev
)
3771 free_debug_section ((enum dwarf_section_display_enum
) i
);
3777 /* Dump the dwarf debugging information. */
3780 dump_dwarf (bfd
*abfd
)
3782 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3783 if (byte_get
== NULL
)
3785 warn (_("File %s does not contain any dwarf debug information\n"),
3786 bfd_get_filename (abfd
));
3790 switch (bfd_get_arch (abfd
))
3793 /* S12Z has a 24 bit address space. But the only known
3794 producer of dwarf_info encodes addresses into 32 bits. */
3799 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3803 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3804 bfd_get_mach (abfd
));
3806 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3809 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3810 it. Return NULL on failure. */
3813 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3814 bfd_size_type
*entsize_ptr
)
3819 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3820 if (stabsect
== NULL
)
3822 printf (_("No %s section present\n\n"),
3823 sanitize_string (sect_name
));
3827 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3829 non_fatal (_("reading %s section of %s failed: %s"),
3830 sect_name
, bfd_get_filename (abfd
),
3831 bfd_errmsg (bfd_get_error ()));
3837 *size_ptr
= bfd_section_size (stabsect
);
3839 *entsize_ptr
= stabsect
->entsize
;
3844 /* Stabs entries use a 12 byte format:
3845 4 byte string table index
3847 1 byte stab other field
3848 2 byte stab desc field
3850 FIXME: This will have to change for a 64 bit object format. */
3852 #define STRDXOFF (0)
3854 #define OTHEROFF (5)
3857 #define STABSIZE (12)
3859 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3860 using string table section STRSECT_NAME (in `strtab'). */
3863 print_section_stabs (bfd
*abfd
,
3864 const char *stabsect_name
,
3865 unsigned *string_offset_ptr
)
3868 unsigned file_string_table_offset
= 0;
3869 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3870 bfd_byte
*stabp
, *stabs_end
;
3873 stabs_end
= stabp
+ stab_size
;
3875 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3876 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3878 /* Loop through all symbols and print them.
3880 We start the index at -1 because there is a dummy symbol on
3881 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3882 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3886 unsigned char type
, other
;
3887 unsigned short desc
;
3890 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3891 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3892 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3893 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3894 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3896 printf ("\n%-6d ", i
);
3897 /* Either print the stab name, or, if unnamed, print its number
3898 again (makes consistent formatting for tools like awk). */
3899 name
= bfd_get_stab_name (type
);
3901 printf ("%-6s", sanitize_string (name
));
3902 else if (type
== N_UNDF
)
3905 printf ("%-6d", type
);
3906 printf (" %-6d %-6d ", other
, desc
);
3907 bfd_printf_vma (abfd
, value
);
3908 printf (" %-6lu", strx
);
3910 /* Symbols with type == 0 (N_UNDF) specify the length of the
3911 string table associated with this file. We use that info
3912 to know how to relocate the *next* file's string table indices. */
3915 file_string_table_offset
= next_file_string_table_offset
;
3916 next_file_string_table_offset
+= value
;
3920 bfd_size_type amt
= strx
+ file_string_table_offset
;
3922 /* Using the (possibly updated) string table offset, print the
3923 string (if any) associated with this symbol. */
3924 if (amt
< stabstr_size
)
3925 /* PR 17512: file: 079-79389-0.001:0.1.
3926 FIXME: May need to sanitize this string before displaying. */
3927 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3933 *string_offset_ptr
= next_file_string_table_offset
;
3938 const char * section_name
;
3939 const char * string_section_name
;
3940 unsigned string_offset
;
3945 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3948 stab_section_names
* sought
= (stab_section_names
*) names
;
3950 /* Check for section names for which stabsect_name is a prefix, to
3951 handle .stab.N, etc. */
3952 len
= strlen (sought
->section_name
);
3954 /* If the prefix matches, and the files section name ends with a
3955 nul or a digit, then we match. I.e., we want either an exact
3956 match or a section followed by a number. */
3957 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3958 && (section
->name
[len
] == 0
3959 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3962 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3963 &stabstr_size
, NULL
);
3967 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3969 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3975 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3977 stab_section_names s
;
3979 s
.section_name
= stabsect_name
;
3980 s
.string_section_name
= strsect_name
;
3981 s
.string_offset
= 0;
3983 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3989 /* Dump the any sections containing stabs debugging information. */
3992 dump_stabs (bfd
*abfd
)
3994 dump_stabs_section (abfd
, ".stab", ".stabstr");
3995 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3996 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3999 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4001 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4005 dump_bfd_header (bfd
*abfd
)
4009 printf (_("architecture: %s, "),
4010 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4011 bfd_get_mach (abfd
)));
4012 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4014 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4015 PF (HAS_RELOC
, "HAS_RELOC");
4016 PF (EXEC_P
, "EXEC_P");
4017 PF (HAS_LINENO
, "HAS_LINENO");
4018 PF (HAS_DEBUG
, "HAS_DEBUG");
4019 PF (HAS_SYMS
, "HAS_SYMS");
4020 PF (HAS_LOCALS
, "HAS_LOCALS");
4021 PF (DYNAMIC
, "DYNAMIC");
4022 PF (WP_TEXT
, "WP_TEXT");
4023 PF (D_PAGED
, "D_PAGED");
4024 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4025 printf (_("\nstart address 0x"));
4026 bfd_printf_vma (abfd
, abfd
->start_address
);
4031 #ifdef ENABLE_LIBCTF
4032 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4033 it is passed, or a pointer to newly-allocated storage, in which case
4034 dump_ctf() will free it when it no longer needs it. */
4037 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4040 const char *blanks
= arg
;
4043 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4048 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4050 make_ctfsect (const char *name
, bfd_byte
*data
,
4055 ctfsect
.cts_name
= name
;
4056 ctfsect
.cts_entsize
= 1;
4057 ctfsect
.cts_size
= size
;
4058 ctfsect
.cts_data
= data
;
4063 /* Dump CTF errors/warnings. */
4065 dump_ctf_errs (ctf_dict_t
*fp
)
4067 ctf_next_t
*it
= NULL
;
4072 /* Dump accumulated errors and warnings. */
4073 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4075 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4079 if (err
!= ECTF_NEXT_END
)
4081 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4086 /* Dump one CTF archive member. */
4089 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
4091 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
4092 const char *things
[] = {"Header", "Labels", "Data objects",
4093 "Function objects", "Variables", "Types", "Strings",
4098 /* Only print out the name of non-default-named archive members.
4099 The name .ctf appears everywhere, even for things that aren't
4100 really archives, so printing it out is liable to be confusing.
4102 The parent, if there is one, is the default-owned archive member:
4103 avoid importing it into itself. (This does no harm, but looks
4106 if (strcmp (name
, ".ctf") != 0)
4108 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4109 ctf_import (ctf
, parent
);
4112 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4114 ctf_dump_state_t
*s
= NULL
;
4117 printf ("\n %s:\n", *thing
);
4118 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4119 (void *) " ")) != NULL
)
4121 printf ("%s\n", item
);
4125 if (ctf_errno (ctf
))
4127 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4128 ctf_errmsg (ctf_errno (ctf
)));
4133 dump_ctf_errs (ctf
);
4138 /* Dump the CTF debugging information. */
4141 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4143 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4144 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4145 bfd_size_type ctfsize
, parentsize
;
4147 ctf_dict_t
*parent
= NULL
;
4150 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4151 bfd_fatal (bfd_get_filename (abfd
));
4154 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4156 bfd_fatal (bfd_get_filename (abfd
));
4158 /* Load the CTF file and dump it. */
4160 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4161 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4163 dump_ctf_errs (NULL
);
4164 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4165 bfd_fatal (bfd_get_filename (abfd
));
4170 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4171 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4173 dump_ctf_errs (NULL
);
4174 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4175 bfd_fatal (bfd_get_filename (abfd
));
4178 lookparent
= parenta
;
4183 /* Assume that the applicable parent archive member is the default one.
4184 (This is what all known implementations are expected to do, if they
4185 put CTFs and their parents in archives together.) */
4186 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
4188 dump_ctf_errs (NULL
);
4189 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4190 bfd_fatal (bfd_get_filename (abfd
));
4193 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4195 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
4197 dump_ctf_errs (NULL
);
4198 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4199 bfd_fatal (bfd_get_filename (abfd
));
4201 ctf_dict_close (parent
);
4203 ctf_close (parenta
);
4209 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4210 const char *parent_name ATTRIBUTE_UNUSED
) {}
4215 dump_bfd_private_header (bfd
*abfd
)
4217 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4218 non_fatal (_("warning: private headers incomplete: %s"),
4219 bfd_errmsg (bfd_get_error ()));
4223 dump_target_specific (bfd
*abfd
)
4225 const struct objdump_private_desc
* const *desc
;
4226 struct objdump_private_option
*opt
;
4229 /* Find the desc. */
4230 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4231 if ((*desc
)->filter (abfd
))
4236 non_fatal (_("option -P/--private not supported by this file"));
4240 /* Clear all options. */
4241 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4242 opt
->selected
= false;
4244 /* Decode options. */
4245 b
= dump_private_options
;
4248 e
= strchr (b
, ',');
4253 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4254 if (strcmp (opt
->name
, b
) == 0)
4256 opt
->selected
= true;
4259 if (opt
->name
== NULL
)
4260 non_fatal (_("target specific dump '%s' not supported"), b
);
4271 (*desc
)->dump (abfd
);
4274 /* Display a section in hexadecimal format with associated characters.
4275 Each line prefixed by the zero padded address. */
4278 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4280 bfd_byte
*data
= NULL
;
4281 bfd_size_type datasize
;
4282 bfd_vma addr_offset
;
4283 bfd_vma start_offset
;
4284 bfd_vma stop_offset
;
4285 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4286 /* Bytes per line. */
4287 const int onaline
= 16;
4292 if (! process_section_p (section
))
4295 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4298 if ((datasize
= bfd_section_size (section
)) == 0)
4301 /* Compute the address range to display. */
4302 if (start_address
== (bfd_vma
) -1
4303 || start_address
< section
->vma
)
4306 start_offset
= start_address
- section
->vma
;
4308 if (stop_address
== (bfd_vma
) -1)
4309 stop_offset
= datasize
/ opb
;
4312 if (stop_address
< section
->vma
)
4315 stop_offset
= stop_address
- section
->vma
;
4317 if (stop_offset
> datasize
/ opb
)
4318 stop_offset
= datasize
/ opb
;
4321 if (start_offset
>= stop_offset
)
4324 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4325 if (display_file_offsets
)
4326 printf (_(" (Starting at file offset: 0x%lx)"),
4327 (unsigned long) (section
->filepos
+ start_offset
));
4330 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4332 non_fatal (_("Reading section %s failed because: %s"),
4333 section
->name
, bfd_errmsg (bfd_get_error ()));
4339 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4340 if (strlen (buf
) >= sizeof (buf
))
4344 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4346 count
= strlen (buf
) - count
;
4350 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4351 if (strlen (buf
) >= sizeof (buf
))
4355 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4357 count
= strlen (buf
) - count
;
4361 for (addr_offset
= start_offset
;
4362 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4366 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4367 count
= strlen (buf
);
4368 if ((size_t) count
>= sizeof (buf
))
4372 while (count
< width
)
4377 fputs (buf
+ count
- width
, stdout
);
4380 for (j
= addr_offset
* opb
;
4381 j
< addr_offset
* opb
+ onaline
; j
++)
4383 if (j
< stop_offset
* opb
)
4384 printf ("%02x", (unsigned) (data
[j
]));
4392 for (j
= addr_offset
* opb
;
4393 j
< addr_offset
* opb
+ onaline
; j
++)
4395 if (j
>= stop_offset
* opb
)
4398 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4405 /* Actually display the various requested regions. */
4408 dump_data (bfd
*abfd
)
4410 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4413 /* Should perhaps share code and display with nm? */
4416 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
4425 max_count
= dynsymcount
;
4426 printf ("DYNAMIC SYMBOL TABLE:\n");
4431 max_count
= symcount
;
4432 printf ("SYMBOL TABLE:\n");
4436 printf (_("no symbols\n"));
4438 for (count
= 0; count
< max_count
; count
++)
4442 if (*current
== NULL
)
4443 printf (_("no information for symbol number %ld\n"), count
);
4445 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4446 printf (_("could not determine the type of symbol number %ld\n"),
4449 else if (process_section_p ((* current
)->section
)
4450 && (dump_special_syms
4451 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4453 const char *name
= (*current
)->name
;
4455 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4459 /* If we want to demangle the name, we demangle it
4460 here, and temporarily clobber it while calling
4461 bfd_print_symbol. FIXME: This is a gross hack. */
4462 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4464 (*current
)->name
= alloc
;
4465 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4466 bfd_print_symbol_all
);
4469 (*current
)->name
= name
;
4474 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4475 bfd_print_symbol_all
);
4485 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4488 char *last_filename
, *last_functionname
;
4489 unsigned int last_line
;
4490 unsigned int last_discriminator
;
4492 /* Get column headers lined up reasonably. */
4500 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4501 width
= strlen (buf
) - 7;
4503 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4506 last_filename
= NULL
;
4507 last_functionname
= NULL
;
4509 last_discriminator
= 0;
4511 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4514 const char *filename
, *functionname
;
4515 unsigned int linenumber
;
4516 unsigned int discriminator
;
4517 const char *sym_name
;
4518 const char *section_name
;
4519 bfd_vma addend2
= 0;
4521 if (start_address
!= (bfd_vma
) -1
4522 && q
->address
< start_address
)
4524 if (stop_address
!= (bfd_vma
) -1
4525 && q
->address
> stop_address
)
4528 if (with_line_numbers
4530 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4531 &filename
, &functionname
,
4532 &linenumber
, &discriminator
))
4534 if (functionname
!= NULL
4535 && (last_functionname
== NULL
4536 || strcmp (functionname
, last_functionname
) != 0))
4538 printf ("%s():\n", sanitize_string (functionname
));
4539 if (last_functionname
!= NULL
)
4540 free (last_functionname
);
4541 last_functionname
= xstrdup (functionname
);
4545 && (linenumber
!= last_line
4546 || (filename
!= NULL
4547 && last_filename
!= NULL
4548 && filename_cmp (filename
, last_filename
) != 0)
4549 || (discriminator
!= last_discriminator
)))
4551 if (discriminator
> 0)
4552 printf ("%s:%u\n", filename
== NULL
? "???" :
4553 sanitize_string (filename
), linenumber
);
4555 printf ("%s:%u (discriminator %u)\n",
4556 filename
== NULL
? "???" : sanitize_string (filename
),
4557 linenumber
, discriminator
);
4558 last_line
= linenumber
;
4559 last_discriminator
= discriminator
;
4560 if (last_filename
!= NULL
)
4561 free (last_filename
);
4562 if (filename
== NULL
)
4563 last_filename
= NULL
;
4565 last_filename
= xstrdup (filename
);
4569 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4571 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4572 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4577 section_name
= NULL
;
4580 bfd_printf_vma (abfd
, q
->address
);
4581 if (q
->howto
== NULL
)
4582 printf (" *unknown* ");
4583 else if (q
->howto
->name
)
4585 const char *name
= q
->howto
->name
;
4587 /* R_SPARC_OLO10 relocations contain two addends.
4588 But because 'arelent' lacks enough storage to
4589 store them both, the 64-bit ELF Sparc backend
4590 records this as two relocations. One R_SPARC_LO10
4591 and one R_SPARC_13, both pointing to the same
4592 address. This is merely so that we have some
4593 place to store both addend fields.
4595 Undo this transformation, otherwise the output
4596 will be confusing. */
4597 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4598 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4600 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4602 arelent
*q2
= *(p
+ 1);
4605 && q
->address
== q2
->address
4606 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4608 name
= "R_SPARC_OLO10";
4609 addend2
= q2
->addend
;
4613 printf (" %-16s ", name
);
4616 printf (" %-16d ", q
->howto
->type
);
4620 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4624 if (section_name
== NULL
)
4625 section_name
= "*unknown*";
4626 printf ("[%s]", sanitize_string (section_name
));
4631 bfd_signed_vma addend
= q
->addend
;
4639 bfd_printf_vma (abfd
, addend
);
4644 bfd_printf_vma (abfd
, addend2
);
4650 if (last_filename
!= NULL
)
4651 free (last_filename
);
4652 if (last_functionname
!= NULL
)
4653 free (last_functionname
);
4657 dump_relocs_in_section (bfd
*abfd
,
4659 void *dummy ATTRIBUTE_UNUSED
)
4661 arelent
**relpp
= NULL
;
4665 if ( bfd_is_abs_section (section
)
4666 || bfd_is_und_section (section
)
4667 || bfd_is_com_section (section
)
4668 || (! process_section_p (section
))
4669 || ((section
->flags
& SEC_RELOC
) == 0))
4672 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4674 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4677 printf (" (none)\n\n");
4685 relpp
= (arelent
**) xmalloc (relsize
);
4686 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4692 non_fatal (_("failed to read relocs in: %s"),
4693 sanitize_string (bfd_get_filename (abfd
)));
4694 bfd_fatal (_("error message was"));
4696 else if (relcount
== 0)
4697 printf (" (none)\n\n");
4701 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4708 dump_relocs (bfd
*abfd
)
4710 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4714 dump_dynamic_relocs (bfd
*abfd
)
4720 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4722 bfd_fatal (bfd_get_filename (abfd
));
4724 printf ("DYNAMIC RELOCATION RECORDS");
4727 printf (" (none)\n\n");
4730 relpp
= (arelent
**) xmalloc (relsize
);
4731 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4734 bfd_fatal (bfd_get_filename (abfd
));
4735 else if (relcount
== 0)
4736 printf (" (none)\n\n");
4740 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4747 /* Creates a table of paths, to search for source files. */
4750 add_include_path (const char *path
)
4754 include_path_count
++;
4755 include_paths
= (const char **)
4756 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4757 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4758 if (path
[1] == ':' && path
[2] == 0)
4759 path
= concat (path
, ".", (const char *) 0);
4761 include_paths
[include_path_count
- 1] = path
;
4765 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4769 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4771 bool *has_reloc_p
= (bool *) arg
;
4772 section
->vma
+= adjust_section_vma
;
4774 section
->lma
+= adjust_section_vma
;
4778 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4781 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4786 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4787 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4790 /* Dump selected contents of ABFD. */
4793 dump_bfd (bfd
*abfd
, bool is_mainfile
)
4795 const struct elf_backend_data
* bed
;
4797 if (bfd_big_endian (abfd
))
4798 byte_get
= byte_get_big_endian
;
4799 else if (bfd_little_endian (abfd
))
4800 byte_get
= byte_get_little_endian
;
4804 /* Load any separate debug information files.
4805 We do this now and without checking do_follow_links because separate
4806 debug info files may contain symbol tables that we will need when
4807 displaying information about the main file. Any memory allocated by
4808 load_separate_debug_files will be released when we call
4809 free_debug_memory below.
4811 The test on is_mainfile is there because the chain of separate debug
4812 info files is a global variable shared by all invocations of dump_bfd. */
4815 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4817 /* If asked to do so, recursively dump the separate files. */
4818 if (do_follow_links
)
4822 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4823 dump_bfd (i
->handle
, false);
4827 /* Adjust user-specified start and stop limits for targets that use
4828 signed addresses. */
4829 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4830 && (bed
= get_elf_backend_data (abfd
)) != NULL
4831 && bed
->sign_extend_vma
)
4833 start_address
= sign_extend_address (abfd
, start_address
,
4835 stop_address
= sign_extend_address (abfd
, stop_address
,
4839 /* If we are adjusting section VMA's, change them all now. Changing
4840 the BFD information is a hack. However, we must do it, or
4841 bfd_find_nearest_line will not do the right thing. */
4842 if (adjust_section_vma
!= 0)
4844 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
4845 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4848 if (! is_mainfile
&& ! process_links
)
4851 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4852 printf (_("\n%s: file format %s\n"),
4853 sanitize_string (bfd_get_filename (abfd
)),
4856 print_arelt_descr (stdout
, abfd
, true, false);
4857 if (dump_file_header
)
4858 dump_bfd_header (abfd
);
4859 if (dump_private_headers
)
4860 dump_bfd_private_header (abfd
);
4861 if (dump_private_options
!= NULL
)
4862 dump_target_specific (abfd
);
4863 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4870 || dump_dwarf_section_info
)
4872 syms
= slurp_symtab (abfd
);
4874 /* If following links, load any symbol tables from the linked files as well. */
4875 if (do_follow_links
&& is_mainfile
)
4879 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4881 asymbol
** extra_syms
;
4882 long old_symcount
= symcount
;
4884 extra_syms
= slurp_symtab (i
->handle
);
4888 if (old_symcount
== 0)
4894 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
4895 * sizeof (asymbol
*)));
4896 memcpy (syms
+ old_symcount
,
4898 (symcount
+ 1) * sizeof (asymbol
*));
4902 symcount
+= old_symcount
;
4907 if (dump_section_headers
)
4908 dump_headers (abfd
);
4910 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4911 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4912 dynsyms
= slurp_dynamic_symtab (abfd
);
4916 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4917 dynsymcount
, dynsyms
, &synthsyms
);
4923 dump_symbols (abfd
, false);
4924 if (dump_dynamic_symtab
)
4925 dump_symbols (abfd
, true);
4926 if (dump_dwarf_section_info
)
4928 if (dump_ctf_section_info
)
4929 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4930 if (dump_stab_section_info
)
4932 if (dump_reloc_info
&& ! disassemble
)
4934 if (dump_dynamic_reloc_info
&& ! disassemble
)
4935 dump_dynamic_relocs (abfd
);
4936 if (dump_section_contents
)
4939 disassemble_data (abfd
);
4945 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
4946 if (dhandle
!= NULL
)
4948 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4950 dump_debugging_tags
!= 0))
4952 non_fatal (_("%s: printing debugging information failed"),
4953 bfd_get_filename (abfd
));
4959 /* PR 6483: If there was no STABS debug info in the file, try
4961 else if (! dump_dwarf_section_info
)
4963 dwarf_select_sections_all ();
4991 free_debug_memory ();
4995 display_object_bfd (bfd
*abfd
)
4999 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5001 dump_bfd (abfd
, true);
5005 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5007 nonfatal (bfd_get_filename (abfd
));
5008 list_matching_formats (matching
);
5013 if (bfd_get_error () != bfd_error_file_not_recognized
)
5015 nonfatal (bfd_get_filename (abfd
));
5019 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5021 dump_bfd (abfd
, true);
5025 nonfatal (bfd_get_filename (abfd
));
5027 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5029 list_matching_formats (matching
);
5035 display_any_bfd (bfd
*file
, int level
)
5037 /* Decompress sections unless dumping the section contents. */
5038 if (!dump_section_contents
)
5039 file
->flags
|= BFD_DECOMPRESS
;
5041 /* If the file is an archive, process all of its elements. */
5042 if (bfd_check_format (file
, bfd_archive
))
5045 bfd
*last_arfile
= NULL
;
5048 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5049 else if (level
> 100)
5051 /* Prevent corrupted files from spinning us into an
5052 infinite loop. 100 is an arbitrary heuristic. */
5053 fatal (_("Archive nesting is too deep"));
5057 printf (_("In nested archive %s:\n"),
5058 sanitize_string (bfd_get_filename (file
)));
5062 bfd_set_error (bfd_error_no_error
);
5064 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5067 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5068 nonfatal (bfd_get_filename (file
));
5072 display_any_bfd (arfile
, level
+ 1);
5074 if (last_arfile
!= NULL
)
5076 bfd_close (last_arfile
);
5077 /* PR 17512: file: ac585d01. */
5078 if (arfile
== last_arfile
)
5084 last_arfile
= arfile
;
5087 if (last_arfile
!= NULL
)
5088 bfd_close (last_arfile
);
5091 display_object_bfd (file
);
5095 display_file (char *filename
, char *target
, bool last_file
)
5099 if (get_file_size (filename
) < 1)
5105 file
= bfd_openr (filename
, target
);
5108 nonfatal (filename
);
5112 display_any_bfd (file
, 0);
5114 /* This is an optimization to improve the speed of objdump, especially when
5115 dumping a file with lots of associated debug informatiom. Calling
5116 bfd_close on such a file can take a non-trivial amount of time as there
5117 are lots of lists to walk and buffers to free. This is only really
5118 necessary however if we are about to load another file and we need the
5119 memory back. Otherwise, if we are about to exit, then we can save (a lot
5120 of) time by only doing a quick close, and allowing the OS to reclaim the
5125 bfd_close_all_done (file
);
5129 main (int argc
, char **argv
)
5132 char *target
= default_target
;
5133 bool seenflag
= false;
5135 #ifdef HAVE_LC_MESSAGES
5136 setlocale (LC_MESSAGES
, "");
5138 setlocale (LC_CTYPE
, "");
5140 bindtextdomain (PACKAGE
, LOCALEDIR
);
5141 textdomain (PACKAGE
);
5143 program_name
= *argv
;
5144 xmalloc_set_program_name (program_name
);
5145 bfd_set_error_program_name (program_name
);
5147 START_PROGRESS (program_name
, 0);
5149 expandargv (&argc
, &argv
);
5151 if (bfd_init () != BFD_INIT_MAGIC
)
5152 fatal (_("fatal error: libbfd ABI mismatch"));
5153 set_default_bfd_target ();
5155 while ((c
= getopt_long (argc
, argv
,
5156 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5157 long_options
, (int *) 0))
5163 break; /* We've been given a long option. */
5170 if (disassembler_options
)
5171 /* Ignore potential memory leak for now. */
5172 options
= concat (disassembler_options
, ",",
5173 optarg
, (const char *) NULL
);
5176 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5183 display_file_offsets
= true;
5186 with_line_numbers
= true;
5195 enum demangling_styles style
;
5197 style
= cplus_demangle_name_to_style (optarg
);
5198 if (style
== unknown_demangling
)
5199 fatal (_("unknown demangling style `%s'"),
5202 cplus_demangle_set_style (style
);
5205 case OPTION_RECURSE_LIMIT
:
5206 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5208 case OPTION_NO_RECURSE_LIMIT
:
5209 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5212 do_wide
= wide_output
= true;
5214 case OPTION_ADJUST_VMA
:
5215 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5217 case OPTION_START_ADDRESS
:
5218 start_address
= parse_vma (optarg
, "--start-address");
5219 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5220 fatal (_("error: the start address should be before the end address"));
5222 case OPTION_STOP_ADDRESS
:
5223 stop_address
= parse_vma (optarg
, "--stop-address");
5224 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5225 fatal (_("error: the stop address should be after the start address"));
5229 prefix_length
= strlen (prefix
);
5230 /* Remove an unnecessary trailing '/' */
5231 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5234 case OPTION_PREFIX_STRIP
:
5235 prefix_strip
= atoi (optarg
);
5236 if (prefix_strip
< 0)
5237 fatal (_("error: prefix strip must be non-negative"));
5239 case OPTION_INSN_WIDTH
:
5240 insn_width
= strtoul (optarg
, NULL
, 0);
5241 if (insn_width
<= 0)
5242 fatal (_("error: instruction width must be positive"));
5244 case OPTION_INLINES
:
5245 unwind_inlines
= true;
5247 case OPTION_VISUALIZE_JUMPS
:
5248 visualize_jumps
= true;
5249 color_output
= false;
5250 extended_color_output
= false;
5253 if (streq (optarg
, "color"))
5254 color_output
= true;
5255 else if (streq (optarg
, "extended-color"))
5257 color_output
= true;
5258 extended_color_output
= true;
5260 else if (streq (optarg
, "off"))
5261 visualize_jumps
= false;
5263 nonfatal (_("unrecognized argument to --visualize-option"));
5267 if (strcmp (optarg
, "B") == 0)
5268 endian
= BFD_ENDIAN_BIG
;
5269 else if (strcmp (optarg
, "L") == 0)
5270 endian
= BFD_ENDIAN_LITTLE
;
5273 nonfatal (_("unrecognized -E option"));
5278 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5279 endian
= BFD_ENDIAN_BIG
;
5280 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5281 endian
= BFD_ENDIAN_LITTLE
;
5284 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5291 dump_file_header
= true;
5295 formats_info
= true;
5299 add_include_path (optarg
);
5302 dump_private_headers
= true;
5306 dump_private_options
= optarg
;
5310 dump_private_headers
= true;
5312 dump_reloc_info
= true;
5313 dump_file_header
= true;
5314 dump_ar_hdrs
= true;
5315 dump_section_headers
= true;
5323 dump_dynamic_symtab
= true;
5329 disasm_sym
= optarg
;
5332 disassemble_zeroes
= true;
5336 disassemble_all
= true;
5341 with_source_code
= true;
5344 case OPTION_SOURCE_COMMENT
:
5346 with_source_code
= true;
5349 source_comment
= xstrdup (sanitize_string (optarg
));
5351 source_comment
= xstrdup ("# ");
5359 dump_debugging_tags
= 1;
5364 process_links
= true;
5365 do_follow_links
= true;
5368 dump_dwarf_section_info
= true;
5371 dwarf_select_sections_by_letters (optarg
);
5373 dwarf_select_sections_all ();
5376 dump_dwarf_section_info
= true;
5379 dwarf_select_sections_by_names (optarg
);
5381 dwarf_select_sections_all ();
5383 case OPTION_DWARF_DEPTH
:
5386 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5389 case OPTION_DWARF_START
:
5392 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5393 suppress_bfd_header
= 1;
5396 case OPTION_DWARF_CHECK
:
5399 #ifdef ENABLE_LIBCTF
5401 dump_ctf_section_info
= true;
5402 dump_ctf_section_name
= xstrdup (optarg
);
5405 case OPTION_CTF_PARENT
:
5406 dump_ctf_parent_name
= xstrdup (optarg
);
5410 dump_stab_section_info
= true;
5414 dump_section_contents
= true;
5418 dump_reloc_info
= true;
5422 dump_dynamic_reloc_info
= true;
5426 dump_ar_hdrs
= true;
5430 dump_section_headers
= true;
5435 show_version
= true;
5441 /* No need to set seenflag or to break - usage() does not return. */
5448 print_version ("objdump");
5454 exit_status
= display_info ();
5458 display_file ("a.out", target
, true);
5460 for (; optind
< argc
;)
5462 display_file (argv
[optind
], target
, optind
== argc
- 1);
5468 free (dump_ctf_section_name
);
5469 free (dump_ctf_parent_name
);
5470 free ((void *) source_comment
);
5472 END_PROGRESS (program_name
);