1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
127 static bfd_boolean visualize_jumps
= FALSE
; /* --visualize-jumps. */
128 static bfd_boolean color_output
= FALSE
; /* --visualize-jumps=color. */
129 static bfd_boolean extended_color_output
= FALSE
; /* --visualize-jumps=extended-color. */
131 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
133 /* A structure to record the sections mentioned in -j switches. */
136 const char * name
; /* The name of the section. */
137 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
138 struct only
* next
; /* Pointer to the next structure in the list. */
140 /* Pointer to an array of 'only' structures.
141 This pointer is NULL if the -j switch has not been used. */
142 static struct only
* only_list
= NULL
;
144 /* Variables for handling include file path table. */
145 static const char **include_paths
;
146 static int include_path_count
;
148 /* Extra info to pass to the section disassembler and address printing
150 struct objdump_disasm_info
153 bfd_boolean require_sec
;
154 arelent
** dynrelbuf
;
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[lLiaprmfFsoRtUuTgAckK] or\n\
232 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
233 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
234 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
235 =addr,=cu_index,=links,=follow-links]\n\
236 Display DWARF info in the file\n\
237 --ctf=SECTION Display CTF info from SECTION\n\
238 -t, --syms Display the contents of the symbol table(s)\n\
239 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
240 -r, --reloc Display the relocation entries in the file\n\
241 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
242 @<file> Read options from <file>\n\
243 -v, --version Display this program's version number\n\
244 -i, --info List object formats and architectures supported\n\
245 -H, --help Display this information\n\
249 const struct objdump_private_desc
* const *desc
;
251 fprintf (stream
, _("\n The following switches are optional:\n"));
252 fprintf (stream
, _("\
253 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
254 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
255 -j, --section=NAME Only display information for section NAME\n\
256 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
257 -EB --endian=big Assume big endian format when disassembling\n\
258 -EL --endian=little Assume little endian format when disassembling\n\
259 --file-start-context Include context from start of file (with -S)\n\
260 -I, --include=DIR Add DIR to search list for source files\n\
261 -l, --line-numbers Include line numbers and filenames in output\n\
262 -F, --file-offsets Include file offsets when displaying information\n\
263 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
264 The STYLE, if specified, can be `auto', `gnu',\n\
265 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
267 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
268 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
269 -w, --wide Format output for more than 80 columns\n\
270 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
271 --start-address=ADDR Only process data whose address is >= ADDR\n\
272 --stop-address=ADDR Only process data whose address is < ADDR\n\
273 --prefix-addresses Print complete address alongside disassembly\n\
274 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
275 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
276 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
277 --special-syms Include special symbols in symbol dumps\n\
278 --inlines Print all inlines for source line (with -l)\n\
279 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
280 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
281 fprintf (stream
, _("\
282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
285 --dwarf-check Make additional dwarf internal consistency checks.\
287 --ctf-parent=SECTION Use SECTION as the CTF parent\n\
288 --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
289 --visualize-jumps=color Use colors in the ASCII art\n\
290 --visualize-jumps=extended-color Use extended 8-bit color codes\n\
291 --visualize-jumps=off Disable jump visualization\n\n"));
293 list_supported_targets (program_name
, stream
);
294 list_supported_architectures (program_name
, stream
);
296 disassembler_usage (stream
);
298 if (objdump_private_vectors
[0] != NULL
)
301 _("\nOptions supported for -P/--private switch:\n"));
302 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
303 (*desc
)->help (stream
);
306 if (REPORT_BUGS_TO
[0] && status
== 0)
307 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
311 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
315 OPTION_START_ADDRESS
,
325 OPTION_RECURSE_LIMIT
,
326 OPTION_NO_RECURSE_LIMIT
,
328 OPTION_SOURCE_COMMENT
,
331 OPTION_VISUALIZE_JUMPS
334 static struct option long_options
[]=
336 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
337 {"all-headers", no_argument
, NULL
, 'x'},
338 {"private-headers", no_argument
, NULL
, 'p'},
339 {"private", required_argument
, NULL
, 'P'},
340 {"architecture", required_argument
, NULL
, 'm'},
341 {"archive-headers", no_argument
, NULL
, 'a'},
342 {"debugging", no_argument
, NULL
, 'g'},
343 {"debugging-tags", no_argument
, NULL
, 'e'},
344 {"demangle", optional_argument
, NULL
, 'C'},
345 {"disassemble", optional_argument
, NULL
, 'd'},
346 {"disassemble-all", no_argument
, NULL
, 'D'},
347 {"disassembler-options", required_argument
, NULL
, 'M'},
348 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
349 {"dynamic-reloc", no_argument
, NULL
, 'R'},
350 {"dynamic-syms", no_argument
, NULL
, 'T'},
351 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
352 {"file-headers", no_argument
, NULL
, 'f'},
353 {"file-offsets", no_argument
, NULL
, 'F'},
354 {"file-start-context", no_argument
, &file_start_context
, 1},
355 {"full-contents", no_argument
, NULL
, 's'},
356 {"headers", no_argument
, NULL
, 'h'},
357 {"help", no_argument
, NULL
, 'H'},
358 {"info", no_argument
, NULL
, 'i'},
359 {"line-numbers", no_argument
, NULL
, 'l'},
360 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
361 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
362 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
363 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
364 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
365 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
366 {"reloc", no_argument
, NULL
, 'r'},
367 {"section", required_argument
, NULL
, 'j'},
368 {"section-headers", no_argument
, NULL
, 'h'},
369 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
370 {"source", no_argument
, NULL
, 'S'},
371 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
372 {"special-syms", no_argument
, &dump_special_syms
, 1},
373 {"include", required_argument
, NULL
, 'I'},
374 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
375 {"ctf", required_argument
, NULL
, OPTION_CTF
},
376 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
377 {"stabs", no_argument
, NULL
, 'G'},
378 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
379 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
380 {"syms", no_argument
, NULL
, 't'},
381 {"target", required_argument
, NULL
, 'b'},
382 {"version", no_argument
, NULL
, 'V'},
383 {"wide", no_argument
, NULL
, 'w'},
384 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
385 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
386 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
387 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
388 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
389 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
390 {"inlines", no_argument
, 0, OPTION_INLINES
},
391 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
392 {0, no_argument
, 0, 0}
396 nonfatal (const char *msg
)
402 /* Returns a version of IN with any control characters
403 replaced by escape sequences. Uses a static buffer
407 sanitize_string (const char * in
)
409 static char * buffer
= NULL
;
410 static size_t buffer_len
= 0;
411 const char * original
= in
;
418 /* See if any conversion is necessary. In the majority
419 of cases it will not be needed. */
432 /* Copy the input, translating as needed. */
434 if (buffer_len
< (strlen (in
) * 2))
436 free ((void *) buffer
);
437 buffer_len
= strlen (in
) * 2;
438 buffer
= xmalloc (buffer_len
+ 1);
464 /* Returns TRUE if the specified section should be dumped. */
467 process_section_p (asection
* section
)
471 if (only_list
== NULL
)
474 for (only
= only_list
; only
; only
= only
->next
)
475 if (strcmp (only
->name
, section
->name
) == 0)
484 /* Add an entry to the 'only' list. */
487 add_only (char * name
)
491 /* First check to make sure that we do not
492 already have an entry for this name. */
493 for (only
= only_list
; only
; only
= only
->next
)
494 if (strcmp (only
->name
, name
) == 0)
497 only
= xmalloc (sizeof * only
);
500 only
->next
= only_list
;
504 /* Release the memory used by the 'only' list.
505 PR 11225: Issue a warning message for unseen sections.
506 Only do this if none of the sections were seen. This is mainly to support
507 tools like the GAS testsuite where an object file is dumped with a list of
508 generic section names known to be present in a range of different file
512 free_only_list (void)
514 bfd_boolean at_least_one_seen
= FALSE
;
518 if (only_list
== NULL
)
521 for (only
= only_list
; only
; only
= only
->next
)
524 at_least_one_seen
= TRUE
;
528 for (only
= only_list
; only
; only
= next
)
530 if (! at_least_one_seen
)
532 non_fatal (_("section '%s' mentioned in a -j option, "
533 "but not found in any input file"),
544 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
547 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
548 int longest_section_name
= *((int *) data
);
550 /* Ignore linker created section. See elfNN_ia64_object_p in
552 if (section
->flags
& SEC_LINKER_CREATED
)
555 /* PR 10413: Skip sections that we are ignoring. */
556 if (! process_section_p (section
))
559 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
560 sanitize_string (bfd_section_name (section
)),
561 (unsigned long) bfd_section_size (section
) / opb
);
562 bfd_printf_vma (abfd
, bfd_section_vma (section
));
564 bfd_printf_vma (abfd
, section
->lma
);
565 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
566 bfd_section_alignment (section
));
572 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
574 PF (SEC_HAS_CONTENTS
, "CONTENTS");
575 PF (SEC_ALLOC
, "ALLOC");
576 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
577 PF (SEC_LOAD
, "LOAD");
578 PF (SEC_RELOC
, "RELOC");
579 PF (SEC_READONLY
, "READONLY");
580 PF (SEC_CODE
, "CODE");
581 PF (SEC_DATA
, "DATA");
583 PF (SEC_DEBUGGING
, "DEBUGGING");
584 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
585 PF (SEC_EXCLUDE
, "EXCLUDE");
586 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
587 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
589 PF (SEC_TIC54X_BLOCK
, "BLOCK");
590 PF (SEC_TIC54X_CLINK
, "CLINK");
592 PF (SEC_SMALL_DATA
, "SMALL_DATA");
593 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
595 PF (SEC_COFF_SHARED
, "SHARED");
596 PF (SEC_COFF_NOREAD
, "NOREAD");
598 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
600 PF (SEC_ELF_OCTETS
, "OCTETS");
601 PF (SEC_ELF_PURECODE
, "PURECODE");
603 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
604 PF (SEC_GROUP
, "GROUP");
605 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
607 PF (SEC_MEP_VLIW
, "VLIW");
610 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
613 struct coff_comdat_info
*comdat
;
615 switch (section
->flags
& SEC_LINK_DUPLICATES
)
619 case SEC_LINK_DUPLICATES_DISCARD
:
620 ls
= "LINK_ONCE_DISCARD";
622 case SEC_LINK_DUPLICATES_ONE_ONLY
:
623 ls
= "LINK_ONCE_ONE_ONLY";
625 case SEC_LINK_DUPLICATES_SAME_SIZE
:
626 ls
= "LINK_ONCE_SAME_SIZE";
628 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
629 ls
= "LINK_ONCE_SAME_CONTENTS";
632 printf ("%s%s", comma
, ls
);
634 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
636 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
645 /* Called on each SECTION in ABFD, update the int variable pointed to by
646 DATA which contains the string length of the longest section name. */
649 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
650 asection
*section
, void *data
)
652 int *longest_so_far
= (int *) data
;
656 /* Ignore linker created section. */
657 if (section
->flags
& SEC_LINKER_CREATED
)
660 /* Skip sections that we are ignoring. */
661 if (! process_section_p (section
))
664 name
= bfd_section_name (section
);
665 len
= (int) strlen (name
);
666 if (len
> *longest_so_far
)
667 *longest_so_far
= len
;
671 dump_headers (bfd
*abfd
)
673 /* The default width of 13 is just an arbitrary choice. */
674 int max_section_name_length
= 13;
680 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
681 if (bfd_get_arch_size (abfd
) == 32)
687 printf (_("Sections:\n"));
690 bfd_map_over_sections (abfd
, find_longest_section_name
,
691 &max_section_name_length
);
693 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
694 max_section_name_length
, "Name",
695 bfd_vma_width
, "VMA",
696 bfd_vma_width
, "LMA");
699 printf (_(" Flags"));
702 bfd_map_over_sections (abfd
, dump_section_header
,
703 &max_section_name_length
);
707 slurp_symtab (bfd
*abfd
)
712 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
718 storage
= bfd_get_symtab_upper_bound (abfd
);
721 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
722 bfd_fatal (_("error message was"));
726 off_t filesize
= bfd_get_file_size (abfd
);
730 && filesize
< storage
731 /* The MMO file format supports its own special compression
732 technique, so its sections can be larger than the file size. */
733 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
735 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
736 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
737 storage
, (long) filesize
);
743 sy
= (asymbol
**) xmalloc (storage
);
746 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
748 bfd_fatal (bfd_get_filename (abfd
));
752 /* Read in the dynamic symbols. */
755 slurp_dynamic_symtab (bfd
*abfd
)
760 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
763 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
765 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
771 bfd_fatal (bfd_get_filename (abfd
));
774 sy
= (asymbol
**) xmalloc (storage
);
776 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
778 bfd_fatal (bfd_get_filename (abfd
));
782 /* Some symbol names are significant and should be kept in the
783 table of sorted symbol names, even if they are marked as
784 debugging/section symbols. */
787 is_significant_symbol_name (const char * name
)
789 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
792 /* Filter out (in place) symbols that are useless for disassembly.
793 COUNT is the number of elements in SYMBOLS.
794 Return the number of useful symbols. */
797 remove_useless_symbols (asymbol
**symbols
, long count
)
799 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
803 asymbol
*sym
= *in_ptr
++;
805 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
807 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
808 && ! is_significant_symbol_name (sym
->name
))
810 if (bfd_is_und_section (sym
->section
)
811 || bfd_is_com_section (sym
->section
))
816 return out_ptr
- symbols
;
819 static const asection
*compare_section
;
821 /* Sort symbols into value order. */
824 compare_symbols (const void *ap
, const void *bp
)
826 const asymbol
*a
= * (const asymbol
**) ap
;
827 const asymbol
*b
= * (const asymbol
**) bp
;
832 bfd_boolean as
, af
, bs
, bf
;
836 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
838 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
841 /* Prefer symbols from the section currently being disassembled.
842 Don't sort symbols from other sections by section, since there
843 isn't much reason to prefer one section over another otherwise.
844 See sym_ok comment for why we compare by section name. */
845 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
846 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
852 an
= bfd_asymbol_name (a
);
853 bn
= bfd_asymbol_name (b
);
857 /* The symbols gnu_compiled and gcc2_compiled convey no real
858 information, so put them after other symbols with the same value. */
859 af
= (strstr (an
, "gnu_compiled") != NULL
860 || strstr (an
, "gcc2_compiled") != NULL
);
861 bf
= (strstr (bn
, "gnu_compiled") != NULL
862 || strstr (bn
, "gcc2_compiled") != NULL
);
869 /* We use a heuristic for the file name, to try to sort it after
870 more useful symbols. It may not work on non Unix systems, but it
871 doesn't really matter; the only difference is precisely which
872 symbol names get printed. */
874 #define file_symbol(s, sn, snl) \
875 (((s)->flags & BSF_FILE) != 0 \
877 && (sn)[(snl) - 2] == '.' \
878 && ((sn)[(snl) - 1] == 'o' \
879 || (sn)[(snl) - 1] == 'a')))
881 af
= file_symbol (a
, an
, anl
);
882 bf
= file_symbol (b
, bn
, bnl
);
889 /* Sort function and object symbols before global symbols before
890 local symbols before section symbols before debugging symbols. */
895 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
897 if ((aflags
& BSF_DEBUGGING
) != 0)
902 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
904 if ((aflags
& BSF_SECTION_SYM
) != 0)
909 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
911 if ((aflags
& BSF_FUNCTION
) != 0)
916 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
918 if ((aflags
& BSF_OBJECT
) != 0)
923 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
925 if ((aflags
& BSF_LOCAL
) != 0)
930 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
932 if ((aflags
& BSF_GLOBAL
) != 0)
938 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
939 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
944 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
945 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
947 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
948 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
950 return asz
> bsz
? -1 : 1;
953 /* Symbols that start with '.' might be section names, so sort them
954 after symbols that don't start with '.'. */
955 if (an
[0] == '.' && bn
[0] != '.')
957 if (an
[0] != '.' && bn
[0] == '.')
960 /* Finally, if we can't distinguish them in any other way, try to
961 get consistent results by sorting the symbols by name. */
962 return strcmp (an
, bn
);
965 /* Sort relocs into address order. */
968 compare_relocs (const void *ap
, const void *bp
)
970 const arelent
*a
= * (const arelent
**) ap
;
971 const arelent
*b
= * (const arelent
**) bp
;
973 if (a
->address
> b
->address
)
975 else if (a
->address
< b
->address
)
978 /* So that associated relocations tied to the same address show up
979 in the correct order, we don't do any further sorting. */
988 /* Print an address (VMA) to the output stream in INFO.
989 If SKIP_ZEROES is TRUE, omit leading zeroes. */
992 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
993 bfd_boolean skip_zeroes
)
997 struct objdump_disasm_info
*aux
;
999 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1000 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1005 for (p
= buf
; *p
== '0'; ++p
)
1010 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1013 /* Print the name of a symbol. */
1016 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1020 const char *name
, *version_string
= NULL
;
1021 bfd_boolean hidden
= FALSE
;
1024 name
= bfd_asymbol_name (sym
);
1025 if (do_demangle
&& name
[0] != '\0')
1027 /* Demangle the name. */
1028 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1033 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1034 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1036 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1039 name
= sanitize_string (name
);
1043 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1044 if (version_string
&& *version_string
!= '\0')
1045 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1050 printf ("%s", name
);
1051 if (version_string
&& *version_string
!= '\0')
1052 printf (hidden
? "@%s" : "@@%s", version_string
);
1059 static inline bfd_boolean
1060 sym_ok (bfd_boolean want_section
,
1061 bfd
* abfd ATTRIBUTE_UNUSED
,
1064 struct disassemble_info
* inf
)
1068 /* NB: An object file can have different sections with the same
1069 section name. Compare compare section pointers if they have
1071 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1072 && sorted_syms
[place
]->section
!= sec
)
1075 /* Note - we cannot just compare section pointers because they could
1076 be different, but the same... Ie the symbol that we are trying to
1077 find could have come from a separate debug info file. Under such
1078 circumstances the symbol will be associated with a section in the
1079 debug info file, whilst the section we want is in a normal file.
1080 So the section pointers will be different, but the section names
1081 will be the same. */
1082 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1083 bfd_section_name (sec
)) != 0)
1087 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1090 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1091 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1092 require the symbol to be in the section. Returns NULL if there is no
1093 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1094 of the symbol in sorted_syms. */
1097 find_symbol_for_address (bfd_vma vma
,
1098 struct disassemble_info
*inf
,
1101 /* @@ Would it speed things up to cache the last two symbols returned,
1102 and maybe their address ranges? For many processors, only one memory
1103 operand can be present at a time, so the 2-entry cache wouldn't be
1104 constantly churned by code doing heavy memory accesses. */
1106 /* Indices in `sorted_syms'. */
1108 long max_count
= sorted_symcount
;
1110 struct objdump_disasm_info
*aux
;
1114 bfd_boolean want_section
;
1117 if (sorted_symcount
< 1)
1120 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1123 opb
= inf
->octets_per_byte
;
1125 /* Perform a binary search looking for the closest symbol to the
1126 required value. We are searching the range (min, max_count]. */
1127 while (min
+ 1 < max_count
)
1131 thisplace
= (max_count
+ min
) / 2;
1132 sym
= sorted_syms
[thisplace
];
1134 if (bfd_asymbol_value (sym
) > vma
)
1135 max_count
= thisplace
;
1136 else if (bfd_asymbol_value (sym
) < vma
)
1145 /* The symbol we want is now in min, the low end of the range we
1146 were searching. If there are several symbols with the same
1147 value, we want the first one. */
1149 while (thisplace
> 0
1150 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1151 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1154 /* Prefer a symbol in the current section if we have multple symbols
1155 with the same value, as can occur with overlays or zero size
1158 while (min
< max_count
1159 && (bfd_asymbol_value (sorted_syms
[min
])
1160 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1162 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1169 return sorted_syms
[thisplace
];
1174 /* If the file is relocatable, and the symbol could be from this
1175 section, prefer a symbol from this section over symbols from
1176 others, even if the other symbol's value might be closer.
1178 Note that this may be wrong for some symbol references if the
1179 sections have overlapping memory ranges, but in that case there's
1180 no way to tell what's desired without looking at the relocation
1183 Also give the target a chance to reject symbols. */
1184 want_section
= (aux
->require_sec
1185 || ((abfd
->flags
& HAS_RELOC
) != 0
1186 && vma
>= bfd_section_vma (sec
)
1187 && vma
< (bfd_section_vma (sec
)
1188 + bfd_section_size (sec
) / opb
)));
1190 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1193 long newplace
= sorted_symcount
;
1195 for (i
= min
- 1; i
>= 0; i
--)
1197 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1199 if (newplace
== sorted_symcount
)
1202 if (bfd_asymbol_value (sorted_syms
[i
])
1203 != bfd_asymbol_value (sorted_syms
[newplace
]))
1206 /* Remember this symbol and keep searching until we reach
1207 an earlier address. */
1212 if (newplace
!= sorted_symcount
)
1213 thisplace
= newplace
;
1216 /* We didn't find a good symbol with a smaller value.
1217 Look for one with a larger value. */
1218 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1220 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1228 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1229 /* There is no suitable symbol. */
1233 /* If we have not found an exact match for the specified address
1234 and we have dynamic relocations available, then we can produce
1235 a better result by matching a relocation to the address and
1236 using the symbol associated with that relocation. */
1237 rel_count
= aux
->dynrelcount
;
1239 && sorted_syms
[thisplace
]->value
!= vma
1241 && aux
->dynrelbuf
!= NULL
1242 && aux
->dynrelbuf
[0]->address
<= vma
1243 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1244 /* If we have matched a synthetic symbol, then stick with that. */
1245 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1248 arelent
** rel_high
;
1250 rel_low
= aux
->dynrelbuf
;
1251 rel_high
= rel_low
+ rel_count
- 1;
1252 while (rel_low
<= rel_high
)
1254 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1255 arelent
* rel
= *rel_mid
;
1257 if (rel
->address
== vma
)
1259 /* Absolute relocations do not provide a more helpful
1260 symbolic address. Find a non-absolute relocation
1261 with the same address. */
1262 arelent
**rel_vma
= rel_mid
;
1264 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1268 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1272 if (rel
->sym_ptr_ptr
!= NULL
1273 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1276 * place
= thisplace
;
1277 return * rel
->sym_ptr_ptr
;
1283 if (vma
< rel
->address
)
1285 else if (vma
>= rel_mid
[1]->address
)
1286 rel_low
= rel_mid
+ 1;
1295 return sorted_syms
[thisplace
];
1298 /* Print an address and the offset to the nearest symbol. */
1301 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1302 bfd_vma vma
, struct disassemble_info
*inf
,
1303 bfd_boolean skip_zeroes
)
1305 objdump_print_value (vma
, inf
, skip_zeroes
);
1311 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1312 sanitize_string (bfd_section_name (sec
)));
1313 secaddr
= bfd_section_vma (sec
);
1316 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1317 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1319 else if (vma
> secaddr
)
1321 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1322 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1324 (*inf
->fprintf_func
) (inf
->stream
, ">");
1328 (*inf
->fprintf_func
) (inf
->stream
, " <");
1330 objdump_print_symname (abfd
, inf
, sym
);
1332 if (bfd_asymbol_value (sym
) == vma
)
1334 /* Undefined symbols in an executables and dynamic objects do not have
1335 a value associated with them, so it does not make sense to display
1336 an offset relative to them. Normally we would not be provided with
1337 this kind of symbol, but the target backend might choose to do so,
1338 and the code in find_symbol_for_address might return an as yet
1339 unresolved symbol associated with a dynamic reloc. */
1340 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1341 && bfd_is_und_section (sym
->section
))
1343 else if (bfd_asymbol_value (sym
) > vma
)
1345 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1346 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1348 else if (vma
> bfd_asymbol_value (sym
))
1350 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1351 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1354 (*inf
->fprintf_func
) (inf
->stream
, ">");
1357 if (display_file_offsets
)
1358 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1359 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1362 /* Print an address (VMA), symbolically if possible.
1363 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1366 objdump_print_addr (bfd_vma vma
,
1367 struct disassemble_info
*inf
,
1368 bfd_boolean skip_zeroes
)
1370 struct objdump_disasm_info
*aux
;
1371 asymbol
*sym
= NULL
;
1372 bfd_boolean skip_find
= FALSE
;
1374 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1376 if (sorted_symcount
< 1)
1378 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1379 objdump_print_value (vma
, inf
, skip_zeroes
);
1381 if (display_file_offsets
)
1382 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1383 (long int) (inf
->section
->filepos
1384 + (vma
- inf
->section
->vma
)));
1388 if (aux
->reloc
!= NULL
1389 && aux
->reloc
->sym_ptr_ptr
!= NULL
1390 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1392 sym
= * aux
->reloc
->sym_ptr_ptr
;
1394 /* Adjust the vma to the reloc. */
1395 vma
+= bfd_asymbol_value (sym
);
1397 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1402 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1404 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1408 /* Print VMA to INFO. This function is passed to the disassembler
1412 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1414 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1417 /* Determine if the given address has a symbol associated with it. */
1420 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1424 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1426 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1429 /* Hold the last function name and the last line number we displayed
1430 in a disassembly. */
1432 static char *prev_functionname
;
1433 static unsigned int prev_line
;
1434 static unsigned int prev_discriminator
;
1436 /* We keep a list of all files that we have seen when doing a
1437 disassembly with source, so that we know how much of the file to
1438 display. This can be important for inlined functions. */
1440 struct print_file_list
1442 struct print_file_list
*next
;
1443 const char *filename
;
1444 const char *modname
;
1447 const char **linemap
;
1450 unsigned max_printed
;
1454 static struct print_file_list
*print_files
;
1456 /* The number of preceding context lines to show when we start
1457 displaying a file for the first time. */
1459 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1461 /* Read a complete file into memory. */
1464 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1467 int ps
= getpagesize ();
1471 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1475 if (fstat (fd
, fst
) < 0)
1480 *size
= fst
->st_size
;
1482 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1483 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1484 if (map
!= (char *) -1L)
1490 map
= (const char *) malloc (*size
);
1491 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1493 free ((void *) map
);
1500 #define line_map_decrease 5
1502 /* Precompute array of lines for a mapped file. */
1504 static const char **
1505 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1507 const char *p
, *lstart
, *end
;
1508 int chars_per_line
= 45; /* First iteration will use 40. */
1509 unsigned int lineno
;
1510 const char **linemap
= NULL
;
1511 unsigned long line_map_size
= 0;
1517 for (p
= map
; p
< end
; p
++)
1521 if (p
+ 1 < end
&& p
[1] == '\r')
1524 else if (*p
== '\r')
1526 if (p
+ 1 < end
&& p
[1] == '\n')
1532 /* End of line found. */
1534 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1536 unsigned long newsize
;
1538 chars_per_line
-= line_map_decrease
;
1539 if (chars_per_line
<= 1)
1541 line_map_size
= size
/ chars_per_line
+ 1;
1542 if (line_map_size
< lineno
+ 1)
1543 line_map_size
= lineno
+ 1;
1544 newsize
= line_map_size
* sizeof (char *);
1545 linemap
= (const char **) xrealloc (linemap
, newsize
);
1548 linemap
[lineno
++] = lstart
;
1556 /* Tries to open MODNAME, and if successful adds a node to print_files
1557 linked list and returns that node. Returns NULL on failure. */
1559 static struct print_file_list
*
1560 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1562 struct print_file_list
*p
;
1564 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1566 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1573 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1576 p
->filename
= origname
;
1577 p
->modname
= modname
;
1578 p
->next
= print_files
;
1584 /* If the source file, as described in the symtab, is not found
1585 try to locate it in one of the paths specified with -I
1586 If found, add location to print_files linked list. */
1588 static struct print_file_list
*
1589 update_source_path (const char *filename
, bfd
*abfd
)
1591 struct print_file_list
*p
;
1596 p
= try_print_file_open (filename
, filename
, &fst
);
1599 if (include_path_count
== 0)
1602 /* Get the name of the file. */
1603 fname
= lbasename (filename
);
1605 /* If file exists under a new path, we need to add it to the list
1606 so that show_line knows about it. */
1607 for (i
= 0; i
< include_path_count
; i
++)
1609 char *modname
= concat (include_paths
[i
], "/", fname
,
1612 p
= try_print_file_open (filename
, modname
, &fst
);
1622 long mtime
= bfd_get_mtime (abfd
);
1624 if (fst
.st_mtime
> mtime
)
1625 warn (_("source file %s is more recent than object file\n"),
1632 /* Print a source file line. */
1635 print_line (struct print_file_list
*p
, unsigned int linenum
)
1641 if (linenum
>= p
->maxline
)
1643 l
= p
->linemap
[linenum
];
1644 if (source_comment
!= NULL
&& strlen (l
) > 0)
1645 printf ("%s", source_comment
);
1646 len
= strcspn (l
, "\n\r");
1647 /* Test fwrite return value to quiet glibc warning. */
1648 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1652 /* Print a range of source code lines. */
1655 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1659 while (start
<= end
)
1661 print_line (p
, start
);
1666 /* Show the line number, or the source line, in a disassembly
1670 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1672 const char *filename
;
1673 const char *functionname
;
1674 unsigned int linenumber
;
1675 unsigned int discriminator
;
1679 if (! with_line_numbers
&& ! with_source_code
)
1682 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1683 &filename
, &functionname
,
1684 &linenumber
, &discriminator
))
1687 if (filename
!= NULL
&& *filename
== '\0')
1689 if (functionname
!= NULL
&& *functionname
== '\0')
1690 functionname
= NULL
;
1693 && IS_ABSOLUTE_PATH (filename
)
1697 const char *fname
= filename
;
1699 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1702 memcpy (path
, prefix
, prefix_length
);
1703 path_up
= path
+ prefix_length
;
1705 /* Build relocated filename, stripping off leading directories
1706 from the initial filename if requested. */
1707 if (prefix_strip
> 0)
1712 /* Skip selected directory levels. */
1713 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1714 if (IS_DIR_SEPARATOR (*s
))
1721 /* Update complete filename. */
1722 strncpy (path_up
, fname
, PATH_MAX
);
1723 path_up
[PATH_MAX
] = '\0';
1731 if (with_line_numbers
)
1733 if (functionname
!= NULL
1734 && (prev_functionname
== NULL
1735 || strcmp (functionname
, prev_functionname
) != 0))
1737 printf ("%s():\n", sanitize_string (functionname
));
1741 && (linenumber
!= prev_line
1742 || discriminator
!= prev_discriminator
))
1744 if (discriminator
> 0)
1745 printf ("%s:%u (discriminator %u)\n",
1746 filename
== NULL
? "???" : sanitize_string (filename
),
1747 linenumber
, discriminator
);
1749 printf ("%s:%u\n", filename
== NULL
1750 ? "???" : sanitize_string (filename
),
1755 const char *filename2
;
1756 const char *functionname2
;
1759 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1762 printf ("inlined by %s:%u",
1763 sanitize_string (filename2
), line2
);
1764 printf (" (%s)\n", sanitize_string (functionname2
));
1769 if (with_source_code
1773 struct print_file_list
**pp
, *p
;
1776 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1777 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1784 filename
= xstrdup (filename
);
1785 p
= update_source_path (filename
, abfd
);
1788 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1790 if (file_start_context
&& p
->first
)
1794 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1795 if (l
>= linenumber
)
1797 if (p
->max_printed
>= l
)
1799 if (p
->max_printed
< linenumber
)
1800 l
= p
->max_printed
+ 1;
1805 dump_lines (p
, l
, linenumber
);
1806 if (p
->max_printed
< linenumber
)
1807 p
->max_printed
= linenumber
;
1808 p
->last_line
= linenumber
;
1813 if (functionname
!= NULL
1814 && (prev_functionname
== NULL
1815 || strcmp (functionname
, prev_functionname
) != 0))
1817 if (prev_functionname
!= NULL
)
1818 free (prev_functionname
);
1819 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1820 strcpy (prev_functionname
, functionname
);
1823 if (linenumber
> 0 && linenumber
!= prev_line
)
1824 prev_line
= linenumber
;
1826 if (discriminator
!= prev_discriminator
)
1827 prev_discriminator
= discriminator
;
1833 /* Pseudo FILE object for strings. */
1841 /* sprintf to a "stream". */
1843 static int ATTRIBUTE_PRINTF_2
1844 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1851 size_t space
= f
->alloc
- f
->pos
;
1853 va_start (args
, format
);
1854 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1860 f
->alloc
= (f
->alloc
+ n
) * 2;
1861 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1868 /* Code for generating (colored) diagrams of control flow start and end
1871 /* Structure used to store the properties of a jump. */
1875 /* The next jump, or NULL if this is the last object. */
1876 struct jump_info
*next
;
1877 /* The previous jump, or NULL if this is the first object. */
1878 struct jump_info
*prev
;
1879 /* The start addresses of the jump. */
1882 /* The list of start addresses. */
1884 /* The number of elements. */
1886 /* The maximum number of elements that fit into the array. */
1889 /* The end address of the jump. */
1891 /* The drawing level of the jump. */
1895 /* Construct a jump object for a jump from start
1896 to end with the corresponding level. */
1898 static struct jump_info
*
1899 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1901 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1903 result
->next
= NULL
;
1904 result
->prev
= NULL
;
1905 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1906 result
->start
.addresses
[0] = start
;
1907 result
->start
.count
= 1;
1908 result
->start
.max_count
= 2;
1910 result
->level
= level
;
1915 /* Free a jump object and return the next object
1916 or NULL if this was the last one. */
1918 static struct jump_info
*
1919 jump_info_free (struct jump_info
*ji
)
1921 struct jump_info
*result
= NULL
;
1926 if (ji
->start
.addresses
)
1927 free (ji
->start
.addresses
);
1934 /* Get the smallest value of all start and end addresses. */
1937 jump_info_min_address (const struct jump_info
*ji
)
1939 bfd_vma min_address
= ji
->end
;
1942 for (i
= ji
->start
.count
; i
-- > 0;)
1943 if (ji
->start
.addresses
[i
] < min_address
)
1944 min_address
= ji
->start
.addresses
[i
];
1948 /* Get the largest value of all start and end addresses. */
1951 jump_info_max_address (const struct jump_info
*ji
)
1953 bfd_vma max_address
= ji
->end
;
1956 for (i
= ji
->start
.count
; i
-- > 0;)
1957 if (ji
->start
.addresses
[i
] > max_address
)
1958 max_address
= ji
->start
.addresses
[i
];
1962 /* Get the target address of a jump. */
1965 jump_info_end_address (const struct jump_info
*ji
)
1970 /* Test if an address is one of the start addresses of a jump. */
1973 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
1975 bfd_boolean result
= FALSE
;
1978 for (i
= ji
->start
.count
; i
-- > 0;)
1979 if (address
== ji
->start
.addresses
[i
])
1988 /* Test if an address is the target address of a jump. */
1991 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
1993 return (address
== ji
->end
);
1996 /* Get the difference between the smallest and largest address of a jump. */
1999 jump_info_size (const struct jump_info
*ji
)
2001 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2004 /* Unlink a jump object from a list. */
2007 jump_info_unlink (struct jump_info
*node
,
2008 struct jump_info
**base
)
2011 node
->next
->prev
= node
->prev
;
2013 node
->prev
->next
= node
->next
;
2020 /* Insert unlinked jump info node into a list. */
2023 jump_info_insert (struct jump_info
*node
,
2024 struct jump_info
*target
,
2025 struct jump_info
**base
)
2027 node
->next
= target
;
2028 node
->prev
= target
->prev
;
2029 target
->prev
= node
;
2031 node
->prev
->next
= node
;
2036 /* Add unlinked node to the front of a list. */
2039 jump_info_add_front (struct jump_info
*node
,
2040 struct jump_info
**base
)
2044 node
->next
->prev
= node
;
2049 /* Move linked node to target position. */
2052 jump_info_move_linked (struct jump_info
*node
,
2053 struct jump_info
*target
,
2054 struct jump_info
**base
)
2057 jump_info_unlink (node
, base
);
2058 /* Insert node at target position. */
2059 jump_info_insert (node
, target
, base
);
2062 /* Test if two jumps intersect. */
2065 jump_info_intersect (const struct jump_info
*a
,
2066 const struct jump_info
*b
)
2068 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2069 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2072 /* Merge two compatible jump info objects. */
2075 jump_info_merge (struct jump_info
**base
)
2077 struct jump_info
*a
;
2079 for (a
= *base
; a
; a
= a
->next
)
2081 struct jump_info
*b
;
2083 for (b
= a
->next
; b
; b
= b
->next
)
2085 /* Merge both jumps into one. */
2086 if (a
->end
== b
->end
)
2088 /* Reallocate addresses. */
2089 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2092 if (needed_size
> a
->start
.max_count
)
2094 a
->start
.max_count
+= b
->start
.max_count
;
2095 a
->start
.addresses
=
2096 xrealloc (a
->start
.addresses
,
2097 a
->start
.max_count
* sizeof (bfd_vma
*));
2100 /* Append start addresses. */
2101 for (i
= 0; i
< b
->start
.count
; ++i
)
2102 a
->start
.addresses
[a
->start
.count
++] =
2103 b
->start
.addresses
[i
];
2105 /* Remove and delete jump. */
2106 struct jump_info
*tmp
= b
->prev
;
2107 jump_info_unlink (b
, base
);
2115 /* Sort jumps by their size and starting point using a stable
2116 minsort. This could be improved if sorting performance is
2117 an issue, for example by using mergesort. */
2120 jump_info_sort (struct jump_info
**base
)
2122 struct jump_info
*current_element
= *base
;
2124 while (current_element
)
2126 struct jump_info
*best_match
= current_element
;
2127 struct jump_info
*runner
= current_element
->next
;
2128 bfd_vma best_size
= jump_info_size (best_match
);
2132 bfd_vma runner_size
= jump_info_size (runner
);
2134 if ((runner_size
< best_size
)
2135 || ((runner_size
== best_size
)
2136 && (jump_info_min_address (runner
)
2137 < jump_info_min_address (best_match
))))
2139 best_match
= runner
;
2140 best_size
= runner_size
;
2143 runner
= runner
->next
;
2146 if (best_match
== current_element
)
2147 current_element
= current_element
->next
;
2149 jump_info_move_linked (best_match
, current_element
, base
);
2153 /* Visualize all jumps at a given address. */
2156 jump_info_visualize_address (bfd_vma address
,
2159 uint8_t *color_buffer
)
2161 struct jump_info
*ji
= detected_jumps
;
2162 size_t len
= (max_level
+ 1) * 3;
2164 /* Clear line buffer. */
2165 memset (line_buffer
, ' ', len
);
2166 memset (color_buffer
, 0, len
);
2168 /* Iterate over jumps and add their ASCII art. */
2171 /* Discard jumps that are never needed again. */
2172 if (jump_info_max_address (ji
) < address
)
2174 struct jump_info
*tmp
= ji
;
2177 jump_info_unlink (tmp
, &detected_jumps
);
2178 jump_info_free (tmp
);
2182 /* This jump intersects with the current address. */
2183 if (jump_info_min_address (ji
) <= address
)
2185 /* Hash target address to get an even
2186 distribution between all values. */
2187 bfd_vma hash_address
= jump_info_end_address (ji
);
2188 uint8_t color
= iterative_hash_object (hash_address
, 0);
2189 /* Fetch line offset. */
2190 int offset
= (max_level
- ji
->level
) * 3;
2192 /* Draw start line. */
2193 if (jump_info_is_start_address (ji
, address
))
2195 size_t i
= offset
+ 1;
2197 for (; i
< len
- 1; ++i
)
2198 if (line_buffer
[i
] == ' ')
2200 line_buffer
[i
] = '-';
2201 color_buffer
[i
] = color
;
2204 if (line_buffer
[i
] == ' ')
2206 line_buffer
[i
] = '-';
2207 color_buffer
[i
] = color
;
2209 else if (line_buffer
[i
] == '>')
2211 line_buffer
[i
] = 'X';
2212 color_buffer
[i
] = color
;
2215 if (line_buffer
[offset
] == ' ')
2217 if (address
<= ji
->end
)
2218 line_buffer
[offset
] =
2219 (jump_info_min_address (ji
) == address
) ? '/': '+';
2221 line_buffer
[offset
] =
2222 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2223 color_buffer
[offset
] = color
;
2226 /* Draw jump target. */
2227 else if (jump_info_is_end_address (ji
, address
))
2229 size_t i
= offset
+ 1;
2231 for (; i
< len
- 1; ++i
)
2232 if (line_buffer
[i
] == ' ')
2234 line_buffer
[i
] = '-';
2235 color_buffer
[i
] = color
;
2238 if (line_buffer
[i
] == ' ')
2240 line_buffer
[i
] = '>';
2241 color_buffer
[i
] = color
;
2243 else if (line_buffer
[i
] == '-')
2245 line_buffer
[i
] = 'X';
2246 color_buffer
[i
] = color
;
2249 if (line_buffer
[offset
] == ' ')
2251 if (jump_info_min_address (ji
) < address
)
2252 line_buffer
[offset
] =
2253 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2255 line_buffer
[offset
] = '/';
2256 color_buffer
[offset
] = color
;
2259 /* Draw intermediate line segment. */
2260 else if (line_buffer
[offset
] == ' ')
2262 line_buffer
[offset
] = '|';
2263 color_buffer
[offset
] = color
;
2271 /* Clone of disassemble_bytes to detect jumps inside a function. */
2272 /* FIXME: is this correct? Can we strip it down even further? */
2274 static struct jump_info
*
2275 disassemble_jumps (struct disassemble_info
* inf
,
2276 disassembler_ftype disassemble_fn
,
2277 bfd_vma start_offset
,
2278 bfd_vma stop_offset
,
2281 arelent
** relppend
)
2283 struct objdump_disasm_info
*aux
;
2284 struct jump_info
*jumps
= NULL
;
2286 bfd_vma addr_offset
;
2287 unsigned int opb
= inf
->octets_per_byte
;
2291 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2292 section
= inf
->section
;
2295 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2298 inf
->insn_info_valid
= 0;
2299 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2300 inf
->stream
= &sfile
;
2302 addr_offset
= start_offset
;
2303 while (addr_offset
< stop_offset
)
2305 int previous_octets
;
2307 /* Remember the length of the previous instruction. */
2308 previous_octets
= octets
;
2312 inf
->bytes_per_line
= 0;
2313 inf
->bytes_per_chunk
= 0;
2314 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2315 | (wide_output
? WIDE_OUTPUT
: 0));
2317 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2319 if (inf
->disassembler_needs_relocs
2320 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2321 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2322 && *relppp
< relppend
)
2324 bfd_signed_vma distance_to_rel
;
2326 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2328 /* Check to see if the current reloc is associated with
2329 the instruction that we are about to disassemble. */
2330 if (distance_to_rel
== 0
2331 /* FIXME: This is wrong. We are trying to catch
2332 relocs that are addressed part way through the
2333 current instruction, as might happen with a packed
2334 VLIW instruction. Unfortunately we do not know the
2335 length of the current instruction since we have not
2336 disassembled it yet. Instead we take a guess based
2337 upon the length of the previous instruction. The
2338 proper solution is to have a new target-specific
2339 disassembler function which just returns the length
2340 of an instruction at a given address without trying
2341 to display its disassembly. */
2342 || (distance_to_rel
> 0
2343 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2345 inf
->flags
|= INSN_HAS_RELOC
;
2349 if (! disassemble_all
2350 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2351 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2352 /* Set a stop_vma so that the disassembler will not read
2353 beyond the next symbol. We assume that symbols appear on
2354 the boundaries between instructions. We only do this when
2355 disassembling code of course, and when -D is in effect. */
2356 inf
->stop_vma
= section
->vma
+ stop_offset
;
2358 inf
->stop_offset
= stop_offset
;
2360 /* Extract jump information. */
2361 inf
->insn_info_valid
= 0;
2362 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2363 /* Test if a jump was detected. */
2364 if (inf
->insn_info_valid
2365 && ((inf
->insn_type
== dis_branch
)
2366 || (inf
->insn_type
== dis_condbranch
)
2367 || (inf
->insn_type
== dis_jsr
)
2368 || (inf
->insn_type
== dis_condjsr
))
2369 && (inf
->target
>= section
->vma
+ start_offset
)
2370 && (inf
->target
< section
->vma
+ stop_offset
))
2372 struct jump_info
*ji
=
2373 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2374 jump_info_add_front (ji
, &jumps
);
2379 addr_offset
+= octets
/ opb
;
2382 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2383 inf
->stream
= stdout
;
2385 free (sfile
.buffer
);
2388 jump_info_merge (&jumps
);
2389 /* Process jumps. */
2390 jump_info_sort (&jumps
);
2392 /* Group jumps by level. */
2393 struct jump_info
*last_jump
= jumps
;
2398 /* The last jump is part of the next group. */
2399 struct jump_info
*base
= last_jump
;
2400 /* Increment level. */
2401 base
->level
= ++max_level
;
2403 /* Find jumps that can be combined on the same
2404 level, with the largest jumps tested first.
2405 This has the advantage that large jumps are on
2406 lower levels and do not intersect with small
2407 jumps that get grouped on higher levels. */
2408 struct jump_info
*exchange_item
= last_jump
->next
;
2409 struct jump_info
*it
= exchange_item
;
2411 for (; it
; it
= it
->next
)
2413 /* Test if the jump intersects with any
2414 jump from current group. */
2415 bfd_boolean ok
= TRUE
;
2416 struct jump_info
*it_collision
;
2418 for (it_collision
= base
;
2419 it_collision
!= exchange_item
;
2420 it_collision
= it_collision
->next
)
2422 /* This jump intersects so we leave it out. */
2423 if (jump_info_intersect (it_collision
, it
))
2430 /* Add jump to group. */
2433 /* Move current element to the front. */
2434 if (it
!= exchange_item
)
2436 struct jump_info
*save
= it
->prev
;
2437 jump_info_move_linked (it
, exchange_item
, &jumps
);
2443 last_jump
= exchange_item
;
2444 exchange_item
= exchange_item
->next
;
2446 last_jump
->level
= max_level
;
2450 /* Move to next group. */
2451 last_jump
= exchange_item
;
2457 /* The number of zeroes we want to see before we start skipping them.
2458 The number is arbitrarily chosen. */
2460 #define DEFAULT_SKIP_ZEROES 8
2462 /* The number of zeroes to skip at the end of a section. If the
2463 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2464 SKIP_ZEROES, they will be disassembled. If there are fewer than
2465 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2466 attempt to avoid disassembling zeroes inserted by section
2469 #define DEFAULT_SKIP_ZEROES_AT_END 3
2472 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2477 /* Print out jump visualization. */
2480 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2481 uint8_t *color_buffer
)
2486 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2488 size_t line_buffer_size
= strlen (line_buffer
);
2489 char last_color
= 0;
2492 for (i
= 0; i
<= line_buffer_size
; ++i
)
2496 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2498 if (color
!= last_color
)
2501 if (extended_color_output
)
2502 /* Use extended 8bit color, but
2503 do not choose dark colors. */
2504 printf ("\033[38;5;%dm", 124 + (color
% 108));
2506 /* Use simple terminal colors. */
2507 printf ("\033[%dm", 31 + (color
% 7));
2514 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2518 /* Disassemble some data in memory between given values. */
2521 disassemble_bytes (struct disassemble_info
* inf
,
2522 disassembler_ftype disassemble_fn
,
2525 bfd_vma start_offset
,
2526 bfd_vma stop_offset
,
2529 arelent
** relppend
)
2531 struct objdump_disasm_info
*aux
;
2533 int octets_per_line
;
2534 int skip_addr_chars
;
2535 bfd_vma addr_offset
;
2536 unsigned int opb
= inf
->octets_per_byte
;
2537 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2538 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2542 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2543 section
= inf
->section
;
2546 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2550 octets_per_line
= insn_width
;
2552 octets_per_line
= 4;
2554 octets_per_line
= 16;
2556 /* Figure out how many characters to skip at the start of an
2557 address, to make the disassembly look nicer. We discard leading
2558 zeroes in chunks of 4, ensuring that there is always a leading
2560 skip_addr_chars
= 0;
2561 if (! prefix_addresses
)
2565 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2567 while (buf
[skip_addr_chars
] == '0')
2570 /* Don't discard zeros on overflow. */
2571 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2572 skip_addr_chars
= 0;
2574 if (skip_addr_chars
!= 0)
2575 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2578 inf
->insn_info_valid
= 0;
2580 /* Determine maximum level. */
2581 uint8_t *color_buffer
= NULL
;
2582 char *line_buffer
= NULL
;
2585 /* Some jumps were detected. */
2588 struct jump_info
*ji
;
2590 /* Find maximum jump level. */
2591 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2593 if (ji
->level
> max_level
)
2594 max_level
= ji
->level
;
2597 /* Allocate buffers. */
2598 size_t len
= (max_level
+ 1) * 3 + 1;
2599 line_buffer
= xmalloc (len
);
2600 line_buffer
[len
- 1] = 0;
2601 color_buffer
= xmalloc (len
);
2602 color_buffer
[len
- 1] = 0;
2605 addr_offset
= start_offset
;
2606 while (addr_offset
< stop_offset
)
2609 bfd_boolean need_nl
= FALSE
;
2613 /* Make sure we don't use relocs from previous instructions. */
2616 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2618 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2621 if (! disassemble_zeroes
2622 && (inf
->insn_info_valid
== 0
2623 || inf
->branch_delay_insns
== 0)
2624 && (z
- addr_offset
* opb
>= skip_zeroes
2625 || (z
== stop_offset
* opb
&&
2626 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2628 /* If there are more nonzero octets to follow, we only skip
2629 zeroes in multiples of 4, to try to avoid running over
2630 the start of an instruction which happens to start with
2632 if (z
!= stop_offset
* opb
)
2633 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2635 octets
= z
- addr_offset
* opb
;
2637 /* If we are going to display more data, and we are displaying
2638 file offsets, then tell the user how many zeroes we skip
2639 and the file offset from where we resume dumping. */
2640 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2641 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2643 (unsigned long) (section
->filepos
2644 + (addr_offset
+ (octets
/ opb
))));
2654 if (with_line_numbers
|| with_source_code
)
2655 show_line (aux
->abfd
, section
, addr_offset
);
2657 if (! prefix_addresses
)
2661 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2662 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2666 printf ("%s:\t", buf
+ skip_addr_chars
);
2670 aux
->require_sec
= TRUE
;
2671 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2672 aux
->require_sec
= FALSE
;
2676 print_jump_visualisation (section
->vma
+ addr_offset
,
2677 max_level
, line_buffer
,
2683 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2684 inf
->stream
= &sfile
;
2685 inf
->bytes_per_line
= 0;
2686 inf
->bytes_per_chunk
= 0;
2687 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2688 | (wide_output
? WIDE_OUTPUT
: 0));
2690 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2692 if (inf
->disassembler_needs_relocs
2693 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2694 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2695 && *relppp
< relppend
)
2697 bfd_signed_vma distance_to_rel
;
2699 int max_reloc_offset
2700 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2702 distance_to_rel
= ((**relppp
)->address
- rel_offset
2705 if (distance_to_rel
> 0
2706 && (max_reloc_offset
< 0
2707 || distance_to_rel
<= max_reloc_offset
))
2709 /* This reloc *might* apply to the current insn,
2710 starting somewhere inside it. Discover the length
2711 of the current insn so that the check below will
2714 insn_size
= insn_width
;
2717 /* We find the length by calling the dissassembler
2718 function with a dummy print handler. This should
2719 work unless the disassembler is not expecting to
2720 be called multiple times for the same address.
2722 This does mean disassembling the instruction
2723 twice, but we only do this when there is a high
2724 probability that there is a reloc that will
2725 affect the instruction. */
2726 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2727 insn_size
= disassemble_fn (section
->vma
2728 + addr_offset
, inf
);
2729 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2733 /* Check to see if the current reloc is associated with
2734 the instruction that we are about to disassemble. */
2735 if (distance_to_rel
== 0
2736 || (distance_to_rel
> 0
2737 && distance_to_rel
< insn_size
/ (int) opb
))
2739 inf
->flags
|= INSN_HAS_RELOC
;
2740 aux
->reloc
= **relppp
;
2744 if (! disassemble_all
2745 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2746 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2747 /* Set a stop_vma so that the disassembler will not read
2748 beyond the next symbol. We assume that symbols appear on
2749 the boundaries between instructions. We only do this when
2750 disassembling code of course, and when -D is in effect. */
2751 inf
->stop_vma
= section
->vma
+ stop_offset
;
2753 inf
->stop_offset
= stop_offset
;
2754 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2757 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2758 inf
->stream
= stdout
;
2759 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2760 octets_per_line
= inf
->bytes_per_line
;
2761 if (octets
< (int) opb
)
2764 printf ("%s\n", sfile
.buffer
);
2767 non_fatal (_("disassemble_fn returned length %d"),
2778 octets
= octets_per_line
;
2779 if (addr_offset
+ octets
/ opb
> stop_offset
)
2780 octets
= (stop_offset
- addr_offset
) * opb
;
2782 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2784 if (ISPRINT (data
[j
]))
2785 buf
[j
- addr_offset
* opb
] = data
[j
];
2787 buf
[j
- addr_offset
* opb
] = '.';
2789 buf
[j
- addr_offset
* opb
] = '\0';
2792 if (prefix_addresses
2794 : show_raw_insn
>= 0)
2798 /* If ! prefix_addresses and ! wide_output, we print
2799 octets_per_line octets per line. */
2801 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2802 pb
= octets_per_line
;
2804 if (inf
->bytes_per_chunk
)
2805 bpc
= inf
->bytes_per_chunk
;
2809 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2811 /* PR 21580: Check for a buffer ending early. */
2812 if (j
+ bpc
<= stop_offset
* opb
)
2816 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2818 for (k
= bpc
- 1; k
>= 0; k
--)
2819 printf ("%02x", (unsigned) data
[j
+ k
]);
2823 for (k
= 0; k
< bpc
; k
++)
2824 printf ("%02x", (unsigned) data
[j
+ k
]);
2830 for (; pb
< octets_per_line
; pb
+= bpc
)
2834 for (k
= 0; k
< bpc
; k
++)
2839 /* Separate raw data from instruction by extra space. */
2849 printf ("%s", sfile
.buffer
);
2851 if (prefix_addresses
2853 : show_raw_insn
>= 0)
2861 j
= addr_offset
* opb
+ pb
;
2863 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2864 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2868 printf ("%s:\t", buf
+ skip_addr_chars
);
2870 print_jump_visualisation (section
->vma
+ j
/ opb
,
2871 max_level
, line_buffer
,
2874 pb
+= octets_per_line
;
2877 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2879 /* PR 21619: Check for a buffer ending early. */
2880 if (j
+ bpc
<= stop_offset
* opb
)
2884 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2886 for (k
= bpc
- 1; k
>= 0; k
--)
2887 printf ("%02x", (unsigned) data
[j
+ k
]);
2891 for (k
= 0; k
< bpc
; k
++)
2892 printf ("%02x", (unsigned) data
[j
+ k
]);
2906 while ((*relppp
) < relppend
2907 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2909 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2920 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2923 if (q
->howto
== NULL
)
2924 printf (": *unknown*\t");
2925 else if (q
->howto
->name
)
2926 printf (": %s\t", q
->howto
->name
);
2928 printf (": %d\t", q
->howto
->type
);
2930 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2931 printf ("*unknown*");
2934 const char *sym_name
;
2936 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2937 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2938 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2943 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2944 sym_name
= bfd_section_name (sym_sec
);
2945 if (sym_name
== NULL
|| *sym_name
== '\0')
2946 sym_name
= "*unknown*";
2947 printf ("%s", sanitize_string (sym_name
));
2953 bfd_signed_vma addend
= q
->addend
;
2961 objdump_print_value (addend
, inf
, TRUE
);
2973 addr_offset
+= octets
/ opb
;
2976 free (sfile
.buffer
);
2978 free (color_buffer
);
2982 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2984 const struct elf_backend_data
* bed
;
2985 bfd_vma sign_adjust
= 0;
2986 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2987 struct objdump_disasm_info
* paux
;
2988 unsigned int opb
= pinfo
->octets_per_byte
;
2989 bfd_byte
* data
= NULL
;
2990 bfd_size_type datasize
= 0;
2991 arelent
** rel_pp
= NULL
;
2992 arelent
** rel_ppstart
= NULL
;
2993 arelent
** rel_ppend
;
2994 bfd_vma stop_offset
;
2995 asymbol
* sym
= NULL
;
2999 unsigned long addr_offset
;
3000 bfd_boolean do_print
;
3003 stop_offset_reached
,
3008 /* Sections that do not contain machine
3009 code are not normally disassembled. */
3010 if (! disassemble_all
3011 && only_list
== NULL
3012 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3013 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3016 if (! process_section_p (section
))
3019 datasize
= bfd_section_size (section
);
3023 if (start_address
== (bfd_vma
) -1
3024 || start_address
< section
->vma
)
3027 addr_offset
= start_address
- section
->vma
;
3029 if (stop_address
== (bfd_vma
) -1)
3030 stop_offset
= datasize
/ opb
;
3033 if (stop_address
< section
->vma
)
3036 stop_offset
= stop_address
- section
->vma
;
3037 if (stop_offset
> datasize
/ opb
)
3038 stop_offset
= datasize
/ opb
;
3041 if (addr_offset
>= stop_offset
)
3044 /* Decide which set of relocs to use. Load them if necessary. */
3045 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3046 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3048 rel_pp
= paux
->dynrelbuf
;
3049 rel_count
= paux
->dynrelcount
;
3050 /* Dynamic reloc addresses are absolute, non-dynamic are section
3051 relative. REL_OFFSET specifies the reloc address corresponding
3052 to the start of this section. */
3053 rel_offset
= section
->vma
;
3061 if ((section
->flags
& SEC_RELOC
) != 0
3062 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3066 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3068 bfd_fatal (bfd_get_filename (abfd
));
3072 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3073 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3075 bfd_fatal (bfd_get_filename (abfd
));
3077 /* Sort the relocs by address. */
3078 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3082 rel_ppend
= rel_pp
+ rel_count
;
3084 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3086 non_fatal (_("Reading section %s failed because: %s"),
3087 section
->name
, bfd_errmsg (bfd_get_error ()));
3091 pinfo
->buffer
= data
;
3092 pinfo
->buffer_vma
= section
->vma
;
3093 pinfo
->buffer_length
= datasize
;
3094 pinfo
->section
= section
;
3096 /* Sort the symbols into value and section order. */
3097 compare_section
= section
;
3098 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3100 /* Skip over the relocs belonging to addresses below the
3102 while (rel_pp
< rel_ppend
3103 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3106 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3108 /* Find the nearest symbol forwards from our current position. */
3109 paux
->require_sec
= TRUE
;
3110 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3111 (struct disassemble_info
*) inf
,
3113 paux
->require_sec
= FALSE
;
3115 /* PR 9774: If the target used signed addresses then we must make
3116 sure that we sign extend the value that we calculate for 'addr'
3117 in the loop below. */
3118 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3119 && (bed
= get_elf_backend_data (abfd
)) != NULL
3120 && bed
->sign_extend_vma
)
3121 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3123 /* Disassemble a block of instructions up to the address associated with
3124 the symbol we have just found. Then print the symbol and find the
3125 next symbol on. Repeat until we have disassembled the entire section
3126 or we have reached the end of the address range we are interested in. */
3127 do_print
= paux
->symbol
== NULL
;
3128 loop_until
= stop_offset_reached
;
3130 while (addr_offset
< stop_offset
)
3134 bfd_vma nextstop_offset
;
3137 addr
= section
->vma
+ addr_offset
;
3138 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3140 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3145 (x
< sorted_symcount
3146 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3150 pinfo
->symbols
= sorted_syms
+ place
;
3151 pinfo
->num_symbols
= x
- place
;
3152 pinfo
->symtab_pos
= place
;
3156 pinfo
->symbols
= NULL
;
3157 pinfo
->num_symbols
= 0;
3158 pinfo
->symtab_pos
= -1;
3161 /* If we are only disassembling from a specific symbol,
3162 check to see if we should start or stop displaying. */
3163 if (sym
&& paux
->symbol
)
3167 /* See if we should stop printing. */
3171 if (sym
->flags
& BSF_FUNCTION
)
3175 case stop_offset_reached
:
3176 /* Handled by the while loop. */
3180 /* FIXME: There is an implicit assumption here
3181 that the name of sym is different from
3183 if (! bfd_is_local_label (abfd
, sym
))
3190 const char * name
= bfd_asymbol_name (sym
);
3191 char * alloc
= NULL
;
3193 if (do_demangle
&& name
[0] != '\0')
3195 /* Demangle the name. */
3196 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3201 /* We are not currently printing. Check to see
3202 if the current symbol matches the requested symbol. */
3203 if (streq (name
, paux
->symbol
))
3207 if (sym
->flags
& BSF_FUNCTION
)
3209 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3210 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3212 /* Sym is a function symbol with a size associated
3213 with it. Turn on automatic disassembly for the
3214 next VALUE bytes. */
3215 stop_offset
= addr_offset
3216 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3217 loop_until
= stop_offset_reached
;
3221 /* Otherwise we need to tell the loop heuristic to
3222 loop until the next function symbol is encountered. */
3223 loop_until
= function_sym
;
3228 /* Otherwise loop until the next symbol is encountered. */
3229 loop_until
= next_sym
;
3237 if (! prefix_addresses
&& do_print
)
3239 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3240 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3242 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3245 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3247 else if (sym
== NULL
)
3251 #define is_valid_next_sym(SYM) \
3252 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3253 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3254 && pinfo->symbol_is_valid (SYM, pinfo))
3256 /* Search forward for the next appropriate symbol in
3257 SECTION. Note that all the symbols are sorted
3258 together into one big array, and that some sections
3259 may have overlapping addresses. */
3260 while (place
< sorted_symcount
3261 && ! is_valid_next_sym (sorted_syms
[place
]))
3264 if (place
>= sorted_symcount
)
3267 nextsym
= sorted_syms
[place
];
3270 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3271 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3272 else if (nextsym
== NULL
)
3273 nextstop_offset
= stop_offset
;
3275 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3277 if (nextstop_offset
> stop_offset
3278 || nextstop_offset
<= addr_offset
)
3279 nextstop_offset
= stop_offset
;
3281 /* If a symbol is explicitly marked as being an object
3282 rather than a function, just dump the bytes without
3283 disassembling them. */
3286 || sym
->section
!= section
3287 || bfd_asymbol_value (sym
) > addr
3288 || ((sym
->flags
& BSF_OBJECT
) == 0
3289 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3291 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3293 || (sym
->flags
& BSF_FUNCTION
) != 0)
3300 /* Resolve symbol name. */
3301 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3303 struct disassemble_info di
;
3306 sf
.alloc
= strlen (sym
->name
) + 40;
3307 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3309 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3312 objdump_print_symname (abfd
, &di
, sym
);
3314 /* Fetch jump information. */
3315 detected_jumps
= disassemble_jumps
3316 (pinfo
, paux
->disassemble_fn
,
3317 addr_offset
, nextstop_offset
,
3318 rel_offset
, &rel_pp
, rel_ppend
);
3320 /* Free symbol name. */
3324 /* Add jumps to output. */
3325 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3326 addr_offset
, nextstop_offset
,
3327 rel_offset
, &rel_pp
, rel_ppend
);
3330 while (detected_jumps
)
3332 detected_jumps
= jump_info_free (detected_jumps
);
3336 addr_offset
= nextstop_offset
;
3342 if (rel_ppstart
!= NULL
)
3346 /* Disassemble the contents of an object file. */
3349 disassemble_data (bfd
*abfd
)
3351 struct disassemble_info disasm_info
;
3352 struct objdump_disasm_info aux
;
3356 prev_functionname
= NULL
;
3358 prev_discriminator
= 0;
3360 /* We make a copy of syms to sort. We don't want to sort syms
3361 because that will screw up the relocs. */
3362 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3363 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3364 * sizeof (asymbol
*));
3365 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3366 sorted_symcount
* sizeof (asymbol
*));
3368 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3370 for (i
= 0; i
< synthcount
; ++i
)
3372 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3376 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3378 disasm_info
.application_data
= (void *) &aux
;
3380 aux
.require_sec
= FALSE
;
3381 aux
.dynrelbuf
= NULL
;
3382 aux
.dynrelcount
= 0;
3384 aux
.symbol
= disasm_sym
;
3386 disasm_info
.print_address_func
= objdump_print_address
;
3387 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3389 if (machine
!= NULL
)
3391 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3394 fatal (_("can't use supplied machine %s"), machine
);
3396 abfd
->arch_info
= inf
;
3399 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3401 struct bfd_target
*xvec
;
3403 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3404 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3405 xvec
->byteorder
= endian
;
3409 /* Use libopcodes to locate a suitable disassembler. */
3410 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3411 bfd_big_endian (abfd
),
3412 bfd_get_mach (abfd
), abfd
);
3413 if (!aux
.disassemble_fn
)
3415 non_fatal (_("can't disassemble for architecture %s\n"),
3416 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3421 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3422 disasm_info
.arch
= bfd_get_arch (abfd
);
3423 disasm_info
.mach
= bfd_get_mach (abfd
);
3424 disasm_info
.disassembler_options
= disassembler_options
;
3425 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3426 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3427 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3428 disasm_info
.disassembler_needs_relocs
= FALSE
;
3430 if (bfd_big_endian (abfd
))
3431 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3432 else if (bfd_little_endian (abfd
))
3433 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3435 /* ??? Aborting here seems too drastic. We could default to big or little
3437 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3439 /* Allow the target to customize the info structure. */
3440 disassemble_init_for_target (& disasm_info
);
3442 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3444 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3446 if (relsize
< 0 && dump_dynamic_reloc_info
)
3447 bfd_fatal (bfd_get_filename (abfd
));
3451 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3452 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3455 if (aux
.dynrelcount
< 0)
3456 bfd_fatal (bfd_get_filename (abfd
));
3458 /* Sort the relocs by address. */
3459 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3463 disasm_info
.symtab
= sorted_syms
;
3464 disasm_info
.symtab_size
= sorted_symcount
;
3466 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3468 if (aux
.dynrelbuf
!= NULL
)
3469 free (aux
.dynrelbuf
);
3471 disassemble_free_target (&disasm_info
);
3475 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3476 asection
*sec
, void *file
)
3478 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3479 bfd
*abfd
= (bfd
*) file
;
3484 if (section
->start
!= NULL
)
3486 /* If it is already loaded, do nothing. */
3487 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3489 free (section
->start
);
3492 section
->filename
= bfd_get_filename (abfd
);
3493 section
->reloc_info
= NULL
;
3494 section
->num_relocs
= 0;
3495 section
->address
= bfd_section_vma (sec
);
3496 section
->user_data
= sec
;
3497 section
->size
= bfd_section_size (sec
);
3498 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3499 alloced
= amt
= section
->size
+ 1;
3500 if (alloced
!= amt
|| alloced
== 0)
3502 section
->start
= NULL
;
3503 free_debug_section (debug
);
3504 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3505 sanitize_string (section
->name
),
3506 (unsigned long long) section
->size
);
3509 section
->start
= contents
= malloc (alloced
);
3510 if (section
->start
== NULL
3511 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3513 free_debug_section (debug
);
3514 printf (_("\nCan't get contents for section '%s'.\n"),
3515 sanitize_string (section
->name
));
3518 /* Ensure any string section has a terminating NUL. */
3519 section
->start
[section
->size
] = 0;
3521 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3522 && debug_displays
[debug
].relocate
)
3527 bfd_cache_section_contents (sec
, section
->start
);
3529 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3536 free_debug_section (debug
);
3537 printf (_("\nCan't get contents for section '%s'.\n"),
3538 sanitize_string (section
->name
));
3542 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3545 unsigned long reloc_count
;
3548 relocs
= (arelent
**) xmalloc (reloc_size
);
3550 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3551 if (reloc_count
== 0)
3555 section
->reloc_info
= relocs
;
3556 section
->num_relocs
= reloc_count
;
3565 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3570 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3573 relocs
= (arelent
**) dsec
->reloc_info
;
3575 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3576 if (rp
->address
== offset
)
3583 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3585 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3586 bfd
*abfd
= (bfd
*) file
;
3589 /* If it is already loaded, do nothing. */
3590 if (section
->start
!= NULL
)
3592 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3596 /* Locate the debug section. */
3597 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3599 section
->name
= section
->uncompressed_name
;
3602 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3604 section
->name
= section
->compressed_name
;
3609 return load_specific_debug_section (debug
, sec
, file
);
3613 free_debug_section (enum dwarf_section_display_enum debug
)
3615 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3617 if (section
->start
== NULL
)
3620 /* PR 17512: file: 0f67f69d. */
3621 if (section
->user_data
!= NULL
)
3623 asection
* sec
= (asection
*) section
->user_data
;
3625 /* If we are freeing contents that are also pointed to by the BFD
3626 library's section structure then make sure to update those pointers
3627 too. Otherwise, the next time we try to load data for this section
3628 we can end up using a stale pointer. */
3629 if (section
->start
== sec
->contents
)
3631 sec
->contents
= NULL
;
3632 sec
->flags
&= ~ SEC_IN_MEMORY
;
3633 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3637 free ((char *) section
->start
);
3638 section
->start
= NULL
;
3639 section
->address
= 0;
3644 close_debug_file (void * file
)
3646 bfd
* abfd
= (bfd
*) file
;
3652 open_debug_file (const char * pathname
)
3656 data
= bfd_openr (pathname
, NULL
);
3660 if (! bfd_check_format (data
, bfd_object
))
3666 #if HAVE_LIBDEBUGINFOD
3667 /* Return a hex string represention of the build-id. */
3670 get_build_id (void * data
)
3673 char * build_id_str
;
3674 bfd
* abfd
= (bfd
*) data
;
3675 const struct bfd_build_id
* build_id
;
3677 build_id
= abfd
->build_id
;
3678 if (build_id
== NULL
)
3681 build_id_str
= malloc (build_id
->size
* 2 + 1);
3682 if (build_id_str
== NULL
)
3685 for (i
= 0; i
< build_id
->size
; i
++)
3686 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3687 build_id_str
[build_id
->size
* 2] = '\0';
3689 return (unsigned char *)build_id_str
;
3691 #endif /* HAVE_LIBDEBUGINFOD */
3694 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3695 void *arg ATTRIBUTE_UNUSED
)
3697 const char *name
= bfd_section_name (section
);
3701 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3702 match
= ".debug_info";
3706 for (i
= 0; i
< max
; i
++)
3707 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3708 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3709 && debug_displays
[i
].enabled
!= NULL
3710 && *debug_displays
[i
].enabled
)
3712 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3714 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3715 sec
->name
= sec
->uncompressed_name
;
3717 sec
->name
= sec
->compressed_name
;
3718 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3721 debug_displays
[i
].display (sec
, abfd
);
3723 if (i
!= info
&& i
!= abbrev
)
3724 free_debug_section ((enum dwarf_section_display_enum
) i
);
3730 /* Dump the dwarf debugging information. */
3733 dump_dwarf (bfd
*abfd
)
3735 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3736 if (byte_get
== NULL
)
3738 warn (_("File %s does not contain any dwarf debug information\n"),
3739 bfd_get_filename (abfd
));
3743 switch (bfd_get_arch (abfd
))
3746 /* S12Z has a 24 bit address space. But the only known
3747 producer of dwarf_info encodes addresses into 32 bits. */
3752 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3756 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3757 bfd_get_mach (abfd
));
3759 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3762 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3763 it. Return NULL on failure. */
3766 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3767 bfd_size_type
*entsize_ptr
)
3772 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3773 if (stabsect
== NULL
)
3775 printf (_("No %s section present\n\n"),
3776 sanitize_string (sect_name
));
3780 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3782 non_fatal (_("reading %s section of %s failed: %s"),
3783 sect_name
, bfd_get_filename (abfd
),
3784 bfd_errmsg (bfd_get_error ()));
3790 *size_ptr
= bfd_section_size (stabsect
);
3792 *entsize_ptr
= stabsect
->entsize
;
3797 /* Stabs entries use a 12 byte format:
3798 4 byte string table index
3800 1 byte stab other field
3801 2 byte stab desc field
3803 FIXME: This will have to change for a 64 bit object format. */
3805 #define STRDXOFF (0)
3807 #define OTHEROFF (5)
3810 #define STABSIZE (12)
3812 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3813 using string table section STRSECT_NAME (in `strtab'). */
3816 print_section_stabs (bfd
*abfd
,
3817 const char *stabsect_name
,
3818 unsigned *string_offset_ptr
)
3821 unsigned file_string_table_offset
= 0;
3822 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3823 bfd_byte
*stabp
, *stabs_end
;
3826 stabs_end
= stabp
+ stab_size
;
3828 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3829 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3831 /* Loop through all symbols and print them.
3833 We start the index at -1 because there is a dummy symbol on
3834 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3835 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3839 unsigned char type
, other
;
3840 unsigned short desc
;
3843 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3844 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3845 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3846 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3847 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3849 printf ("\n%-6d ", i
);
3850 /* Either print the stab name, or, if unnamed, print its number
3851 again (makes consistent formatting for tools like awk). */
3852 name
= bfd_get_stab_name (type
);
3854 printf ("%-6s", sanitize_string (name
));
3855 else if (type
== N_UNDF
)
3858 printf ("%-6d", type
);
3859 printf (" %-6d %-6d ", other
, desc
);
3860 bfd_printf_vma (abfd
, value
);
3861 printf (" %-6lu", strx
);
3863 /* Symbols with type == 0 (N_UNDF) specify the length of the
3864 string table associated with this file. We use that info
3865 to know how to relocate the *next* file's string table indices. */
3868 file_string_table_offset
= next_file_string_table_offset
;
3869 next_file_string_table_offset
+= value
;
3873 bfd_size_type amt
= strx
+ file_string_table_offset
;
3875 /* Using the (possibly updated) string table offset, print the
3876 string (if any) associated with this symbol. */
3877 if (amt
< stabstr_size
)
3878 /* PR 17512: file: 079-79389-0.001:0.1.
3879 FIXME: May need to sanitize this string before displaying. */
3880 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3886 *string_offset_ptr
= next_file_string_table_offset
;
3891 const char * section_name
;
3892 const char * string_section_name
;
3893 unsigned string_offset
;
3898 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3901 stab_section_names
* sought
= (stab_section_names
*) names
;
3903 /* Check for section names for which stabsect_name is a prefix, to
3904 handle .stab.N, etc. */
3905 len
= strlen (sought
->section_name
);
3907 /* If the prefix matches, and the files section name ends with a
3908 nul or a digit, then we match. I.e., we want either an exact
3909 match or a section followed by a number. */
3910 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3911 && (section
->name
[len
] == 0
3912 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3915 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3916 &stabstr_size
, NULL
);
3920 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3922 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3928 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3930 stab_section_names s
;
3932 s
.section_name
= stabsect_name
;
3933 s
.string_section_name
= strsect_name
;
3934 s
.string_offset
= 0;
3936 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3942 /* Dump the any sections containing stabs debugging information. */
3945 dump_stabs (bfd
*abfd
)
3947 dump_stabs_section (abfd
, ".stab", ".stabstr");
3948 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3949 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3952 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3954 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3958 dump_bfd_header (bfd
*abfd
)
3962 printf (_("architecture: %s, "),
3963 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3964 bfd_get_mach (abfd
)));
3965 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3967 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
3968 PF (HAS_RELOC
, "HAS_RELOC");
3969 PF (EXEC_P
, "EXEC_P");
3970 PF (HAS_LINENO
, "HAS_LINENO");
3971 PF (HAS_DEBUG
, "HAS_DEBUG");
3972 PF (HAS_SYMS
, "HAS_SYMS");
3973 PF (HAS_LOCALS
, "HAS_LOCALS");
3974 PF (DYNAMIC
, "DYNAMIC");
3975 PF (WP_TEXT
, "WP_TEXT");
3976 PF (D_PAGED
, "D_PAGED");
3977 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3978 printf (_("\nstart address 0x"));
3979 bfd_printf_vma (abfd
, abfd
->start_address
);
3984 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3985 it is passed, or a pointer to newly-allocated storage, in which case
3986 dump_ctf() will free it when it no longer needs it. */
3989 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3992 const char *blanks
= arg
;
3995 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4000 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4002 make_ctfsect (const char *name
, bfd_byte
*data
,
4007 ctfsect
.cts_name
= name
;
4008 ctfsect
.cts_entsize
= 1;
4009 ctfsect
.cts_size
= size
;
4010 ctfsect
.cts_data
= data
;
4015 /* Dump one CTF archive member. */
4018 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4020 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4021 const char *things
[] = {"Header", "Labels", "Data objects",
4022 "Function objects", "Variables", "Types", "Strings",
4027 /* Only print out the name of non-default-named archive members.
4028 The name .ctf appears everywhere, even for things that aren't
4029 really archives, so printing it out is liable to be confusing.
4031 The parent, if there is one, is the default-owned archive member:
4032 avoid importing it into itself. (This does no harm, but looks
4035 if (strcmp (name
, ".ctf") != 0)
4037 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4038 ctf_import (ctf
, parent
);
4041 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4043 ctf_dump_state_t
*s
= NULL
;
4046 printf ("\n %s:\n", *thing
);
4047 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4048 (void *) " ")) != NULL
)
4050 printf ("%s\n", item
);
4054 if (ctf_errno (ctf
))
4056 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4057 ctf_errmsg (ctf_errno (ctf
)));
4064 /* Dump the CTF debugging information. */
4067 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4069 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4070 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4071 bfd_size_type ctfsize
, parentsize
;
4073 ctf_file_t
*parent
= NULL
;
4076 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4077 bfd_fatal (bfd_get_filename (abfd
));
4080 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4082 bfd_fatal (bfd_get_filename (abfd
));
4084 /* Load the CTF file and dump it. */
4086 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4087 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4089 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4090 bfd_fatal (bfd_get_filename (abfd
));
4095 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4096 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4098 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4099 bfd_fatal (bfd_get_filename (abfd
));
4102 lookparent
= parenta
;
4107 /* Assume that the applicable parent archive member is the default one.
4108 (This is what all known implementations are expected to do, if they
4109 put CTFs and their parents in archives together.) */
4110 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4112 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4113 bfd_fatal (bfd_get_filename (abfd
));
4116 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4118 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4119 ctf_file_close (parent
);
4121 ctf_close (parenta
);
4128 dump_bfd_private_header (bfd
*abfd
)
4130 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4131 non_fatal (_("warning: private headers incomplete: %s"),
4132 bfd_errmsg (bfd_get_error ()));
4136 dump_target_specific (bfd
*abfd
)
4138 const struct objdump_private_desc
* const *desc
;
4139 struct objdump_private_option
*opt
;
4142 /* Find the desc. */
4143 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4144 if ((*desc
)->filter (abfd
))
4149 non_fatal (_("option -P/--private not supported by this file"));
4153 /* Clear all options. */
4154 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4155 opt
->selected
= FALSE
;
4157 /* Decode options. */
4158 b
= dump_private_options
;
4161 e
= strchr (b
, ',');
4166 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4167 if (strcmp (opt
->name
, b
) == 0)
4169 opt
->selected
= TRUE
;
4172 if (opt
->name
== NULL
)
4173 non_fatal (_("target specific dump '%s' not supported"), b
);
4184 (*desc
)->dump (abfd
);
4187 /* Display a section in hexadecimal format with associated characters.
4188 Each line prefixed by the zero padded address. */
4191 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4193 bfd_byte
*data
= NULL
;
4194 bfd_size_type datasize
;
4195 bfd_vma addr_offset
;
4196 bfd_vma start_offset
;
4197 bfd_vma stop_offset
;
4198 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4199 /* Bytes per line. */
4200 const int onaline
= 16;
4205 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4208 if (! process_section_p (section
))
4211 if ((datasize
= bfd_section_size (section
)) == 0)
4214 /* Compute the address range to display. */
4215 if (start_address
== (bfd_vma
) -1
4216 || start_address
< section
->vma
)
4219 start_offset
= start_address
- section
->vma
;
4221 if (stop_address
== (bfd_vma
) -1)
4222 stop_offset
= datasize
/ opb
;
4225 if (stop_address
< section
->vma
)
4228 stop_offset
= stop_address
- section
->vma
;
4230 if (stop_offset
> datasize
/ opb
)
4231 stop_offset
= datasize
/ opb
;
4234 if (start_offset
>= stop_offset
)
4237 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4238 if (display_file_offsets
)
4239 printf (_(" (Starting at file offset: 0x%lx)"),
4240 (unsigned long) (section
->filepos
+ start_offset
));
4243 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4245 non_fatal (_("Reading section %s failed because: %s"),
4246 section
->name
, bfd_errmsg (bfd_get_error ()));
4252 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4253 if (strlen (buf
) >= sizeof (buf
))
4257 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4259 count
= strlen (buf
) - count
;
4263 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4264 if (strlen (buf
) >= sizeof (buf
))
4268 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4270 count
= strlen (buf
) - count
;
4274 for (addr_offset
= start_offset
;
4275 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4279 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4280 count
= strlen (buf
);
4281 if ((size_t) count
>= sizeof (buf
))
4285 while (count
< width
)
4290 fputs (buf
+ count
- width
, stdout
);
4293 for (j
= addr_offset
* opb
;
4294 j
< addr_offset
* opb
+ onaline
; j
++)
4296 if (j
< stop_offset
* opb
)
4297 printf ("%02x", (unsigned) (data
[j
]));
4305 for (j
= addr_offset
* opb
;
4306 j
< addr_offset
* opb
+ onaline
; j
++)
4308 if (j
>= stop_offset
* opb
)
4311 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4318 /* Actually display the various requested regions. */
4321 dump_data (bfd
*abfd
)
4323 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4326 /* Should perhaps share code and display with nm? */
4329 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4338 max_count
= dynsymcount
;
4339 printf ("DYNAMIC SYMBOL TABLE:\n");
4344 max_count
= symcount
;
4345 printf ("SYMBOL TABLE:\n");
4349 printf (_("no symbols\n"));
4351 for (count
= 0; count
< max_count
; count
++)
4355 if (*current
== NULL
)
4356 printf (_("no information for symbol number %ld\n"), count
);
4358 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4359 printf (_("could not determine the type of symbol number %ld\n"),
4362 else if (process_section_p ((* current
)->section
)
4363 && (dump_special_syms
4364 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4366 const char *name
= (*current
)->name
;
4368 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4372 /* If we want to demangle the name, we demangle it
4373 here, and temporarily clobber it while calling
4374 bfd_print_symbol. FIXME: This is a gross hack. */
4375 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4377 (*current
)->name
= alloc
;
4378 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4379 bfd_print_symbol_all
);
4382 (*current
)->name
= name
;
4387 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4388 bfd_print_symbol_all
);
4398 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4401 char *last_filename
, *last_functionname
;
4402 unsigned int last_line
;
4403 unsigned int last_discriminator
;
4405 /* Get column headers lined up reasonably. */
4413 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4414 width
= strlen (buf
) - 7;
4416 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4419 last_filename
= NULL
;
4420 last_functionname
= NULL
;
4422 last_discriminator
= 0;
4424 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4427 const char *filename
, *functionname
;
4428 unsigned int linenumber
;
4429 unsigned int discriminator
;
4430 const char *sym_name
;
4431 const char *section_name
;
4432 bfd_vma addend2
= 0;
4434 if (start_address
!= (bfd_vma
) -1
4435 && q
->address
< start_address
)
4437 if (stop_address
!= (bfd_vma
) -1
4438 && q
->address
> stop_address
)
4441 if (with_line_numbers
4443 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4444 &filename
, &functionname
,
4445 &linenumber
, &discriminator
))
4447 if (functionname
!= NULL
4448 && (last_functionname
== NULL
4449 || strcmp (functionname
, last_functionname
) != 0))
4451 printf ("%s():\n", sanitize_string (functionname
));
4452 if (last_functionname
!= NULL
)
4453 free (last_functionname
);
4454 last_functionname
= xstrdup (functionname
);
4458 && (linenumber
!= last_line
4459 || (filename
!= NULL
4460 && last_filename
!= NULL
4461 && filename_cmp (filename
, last_filename
) != 0)
4462 || (discriminator
!= last_discriminator
)))
4464 if (discriminator
> 0)
4465 printf ("%s:%u\n", filename
== NULL
? "???" :
4466 sanitize_string (filename
), linenumber
);
4468 printf ("%s:%u (discriminator %u)\n",
4469 filename
== NULL
? "???" : sanitize_string (filename
),
4470 linenumber
, discriminator
);
4471 last_line
= linenumber
;
4472 last_discriminator
= discriminator
;
4473 if (last_filename
!= NULL
)
4474 free (last_filename
);
4475 if (filename
== NULL
)
4476 last_filename
= NULL
;
4478 last_filename
= xstrdup (filename
);
4482 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4484 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4485 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4490 section_name
= NULL
;
4493 bfd_printf_vma (abfd
, q
->address
);
4494 if (q
->howto
== NULL
)
4495 printf (" *unknown* ");
4496 else if (q
->howto
->name
)
4498 const char *name
= q
->howto
->name
;
4500 /* R_SPARC_OLO10 relocations contain two addends.
4501 But because 'arelent' lacks enough storage to
4502 store them both, the 64-bit ELF Sparc backend
4503 records this as two relocations. One R_SPARC_LO10
4504 and one R_SPARC_13, both pointing to the same
4505 address. This is merely so that we have some
4506 place to store both addend fields.
4508 Undo this transformation, otherwise the output
4509 will be confusing. */
4510 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4511 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4513 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4515 arelent
*q2
= *(p
+ 1);
4518 && q
->address
== q2
->address
4519 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4521 name
= "R_SPARC_OLO10";
4522 addend2
= q2
->addend
;
4526 printf (" %-16s ", name
);
4529 printf (" %-16d ", q
->howto
->type
);
4533 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4537 if (section_name
== NULL
)
4538 section_name
= "*unknown*";
4539 printf ("[%s]", sanitize_string (section_name
));
4544 bfd_signed_vma addend
= q
->addend
;
4552 bfd_printf_vma (abfd
, addend
);
4557 bfd_printf_vma (abfd
, addend2
);
4563 if (last_filename
!= NULL
)
4564 free (last_filename
);
4565 if (last_functionname
!= NULL
)
4566 free (last_functionname
);
4570 dump_relocs_in_section (bfd
*abfd
,
4572 void *dummy ATTRIBUTE_UNUSED
)
4574 arelent
**relpp
= NULL
;
4578 if ( bfd_is_abs_section (section
)
4579 || bfd_is_und_section (section
)
4580 || bfd_is_com_section (section
)
4581 || (! process_section_p (section
))
4582 || ((section
->flags
& SEC_RELOC
) == 0))
4585 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4587 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4590 printf (" (none)\n\n");
4598 relpp
= (arelent
**) xmalloc (relsize
);
4599 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4605 non_fatal (_("failed to read relocs in: %s"),
4606 sanitize_string (bfd_get_filename (abfd
)));
4607 bfd_fatal (_("error message was"));
4609 else if (relcount
== 0)
4610 printf (" (none)\n\n");
4614 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4621 dump_relocs (bfd
*abfd
)
4623 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4627 dump_dynamic_relocs (bfd
*abfd
)
4633 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4635 bfd_fatal (bfd_get_filename (abfd
));
4637 printf ("DYNAMIC RELOCATION RECORDS");
4640 printf (" (none)\n\n");
4643 relpp
= (arelent
**) xmalloc (relsize
);
4644 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4647 bfd_fatal (bfd_get_filename (abfd
));
4648 else if (relcount
== 0)
4649 printf (" (none)\n\n");
4653 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4660 /* Creates a table of paths, to search for source files. */
4663 add_include_path (const char *path
)
4667 include_path_count
++;
4668 include_paths
= (const char **)
4669 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4670 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4671 if (path
[1] == ':' && path
[2] == 0)
4672 path
= concat (path
, ".", (const char *) 0);
4674 include_paths
[include_path_count
- 1] = path
;
4678 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4682 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4684 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4685 section
->vma
+= adjust_section_vma
;
4687 section
->lma
+= adjust_section_vma
;
4691 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4694 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4699 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4700 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4703 /* Dump selected contents of ABFD. */
4706 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4708 const struct elf_backend_data
* bed
;
4710 if (bfd_big_endian (abfd
))
4711 byte_get
= byte_get_big_endian
;
4712 else if (bfd_little_endian (abfd
))
4713 byte_get
= byte_get_little_endian
;
4717 /* Load any separate debug information files.
4718 We do this now and without checking do_follow_links because separate
4719 debug info files may contain symbol tables that we will need when
4720 displaying information about the main file. Any memory allocated by
4721 load_separate_debug_files will be released when we call
4722 free_debug_memory below.
4724 The test on is_mainfile is there because the chain of separate debug
4725 info files is a global variable shared by all invocations of dump_bfd. */
4728 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4730 /* If asked to do so, recursively dump the separate files. */
4731 if (do_follow_links
)
4735 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4736 dump_bfd (i
->handle
, FALSE
);
4740 /* Adjust user-specified start and stop limits for targets that use
4741 signed addresses. */
4742 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4743 && (bed
= get_elf_backend_data (abfd
)) != NULL
4744 && bed
->sign_extend_vma
)
4746 start_address
= sign_extend_address (abfd
, start_address
,
4748 stop_address
= sign_extend_address (abfd
, stop_address
,
4752 /* If we are adjusting section VMA's, change them all now. Changing
4753 the BFD information is a hack. However, we must do it, or
4754 bfd_find_nearest_line will not do the right thing. */
4755 if (adjust_section_vma
!= 0)
4757 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4758 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4761 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4762 printf (_("\n%s: file format %s\n"),
4763 sanitize_string (bfd_get_filename (abfd
)),
4766 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4767 if (dump_file_header
)
4768 dump_bfd_header (abfd
);
4769 if (dump_private_headers
)
4770 dump_bfd_private_header (abfd
);
4771 if (dump_private_options
!= NULL
)
4772 dump_target_specific (abfd
);
4773 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4780 || dump_dwarf_section_info
)
4782 syms
= slurp_symtab (abfd
);
4784 /* If following links, load any symbol tables from the linked files as well. */
4785 if (do_follow_links
&& is_mainfile
)
4789 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4791 asymbol
** extra_syms
;
4792 long old_symcount
= symcount
;
4794 extra_syms
= slurp_symtab (i
->handle
);
4798 if (old_symcount
== 0)
4804 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4805 memcpy (syms
+ old_symcount
,
4807 symcount
* sizeof (asymbol
*));
4811 symcount
+= old_symcount
;
4816 if (dump_section_headers
)
4817 dump_headers (abfd
);
4819 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4820 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4821 dynsyms
= slurp_dynamic_symtab (abfd
);
4825 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4826 dynsymcount
, dynsyms
, &synthsyms
);
4832 dump_symbols (abfd
, FALSE
);
4833 if (dump_dynamic_symtab
)
4834 dump_symbols (abfd
, TRUE
);
4835 if (dump_dwarf_section_info
)
4837 if (dump_ctf_section_info
)
4838 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4839 if (dump_stab_section_info
)
4841 if (dump_reloc_info
&& ! disassemble
)
4843 if (dump_dynamic_reloc_info
&& ! disassemble
)
4844 dump_dynamic_relocs (abfd
);
4845 if (dump_section_contents
)
4848 disassemble_data (abfd
);
4854 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4855 if (dhandle
!= NULL
)
4857 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4859 dump_debugging_tags
? TRUE
: FALSE
))
4861 non_fatal (_("%s: printing debugging information failed"),
4862 bfd_get_filename (abfd
));
4868 /* PR 6483: If there was no STABS debug info in the file, try
4870 else if (! dump_dwarf_section_info
)
4872 dwarf_select_sections_all ();
4900 free_debug_memory ();
4904 display_object_bfd (bfd
*abfd
)
4908 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4910 dump_bfd (abfd
, TRUE
);
4914 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4916 nonfatal (bfd_get_filename (abfd
));
4917 list_matching_formats (matching
);
4922 if (bfd_get_error () != bfd_error_file_not_recognized
)
4924 nonfatal (bfd_get_filename (abfd
));
4928 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4930 dump_bfd (abfd
, TRUE
);
4934 nonfatal (bfd_get_filename (abfd
));
4936 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4938 list_matching_formats (matching
);
4944 display_any_bfd (bfd
*file
, int level
)
4946 /* Decompress sections unless dumping the section contents. */
4947 if (!dump_section_contents
)
4948 file
->flags
|= BFD_DECOMPRESS
;
4950 /* If the file is an archive, process all of its elements. */
4951 if (bfd_check_format (file
, bfd_archive
))
4954 bfd
*last_arfile
= NULL
;
4957 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4958 else if (level
> 100)
4960 /* Prevent corrupted files from spinning us into an
4961 infinite loop. 100 is an arbitrary heuristic. */
4962 fatal (_("Archive nesting is too deep"));
4966 printf (_("In nested archive %s:\n"),
4967 sanitize_string (bfd_get_filename (file
)));
4971 bfd_set_error (bfd_error_no_error
);
4973 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4976 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4977 nonfatal (bfd_get_filename (file
));
4981 display_any_bfd (arfile
, level
+ 1);
4983 if (last_arfile
!= NULL
)
4985 bfd_close (last_arfile
);
4986 /* PR 17512: file: ac585d01. */
4987 if (arfile
== last_arfile
)
4993 last_arfile
= arfile
;
4996 if (last_arfile
!= NULL
)
4997 bfd_close (last_arfile
);
5000 display_object_bfd (file
);
5004 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5008 if (get_file_size (filename
) < 1)
5014 file
= bfd_openr (filename
, target
);
5017 nonfatal (filename
);
5021 display_any_bfd (file
, 0);
5023 /* This is an optimization to improve the speed of objdump, especially when
5024 dumping a file with lots of associated debug informatiom. Calling
5025 bfd_close on such a file can take a non-trivial amount of time as there
5026 are lots of lists to walk and buffers to free. This is only really
5027 necessary however if we are about to load another file and we need the
5028 memory back. Otherwise, if we are about to exit, then we can save (a lot
5029 of) time by only doing a quick close, and allowing the OS to reclaim the
5034 bfd_close_all_done (file
);
5038 main (int argc
, char **argv
)
5041 char *target
= default_target
;
5042 bfd_boolean seenflag
= FALSE
;
5044 #if defined (HAVE_SETLOCALE)
5045 #if defined (HAVE_LC_MESSAGES)
5046 setlocale (LC_MESSAGES
, "");
5048 setlocale (LC_CTYPE
, "");
5051 bindtextdomain (PACKAGE
, LOCALEDIR
);
5052 textdomain (PACKAGE
);
5054 program_name
= *argv
;
5055 xmalloc_set_program_name (program_name
);
5056 bfd_set_error_program_name (program_name
);
5058 START_PROGRESS (program_name
, 0);
5060 expandargv (&argc
, &argv
);
5062 if (bfd_init () != BFD_INIT_MAGIC
)
5063 fatal (_("fatal error: libbfd ABI mismatch"));
5064 set_default_bfd_target ();
5066 while ((c
= getopt_long (argc
, argv
,
5067 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5068 long_options
, (int *) 0))
5074 break; /* We've been given a long option. */
5081 if (disassembler_options
)
5082 /* Ignore potential memory leak for now. */
5083 options
= concat (disassembler_options
, ",",
5084 optarg
, (const char *) NULL
);
5087 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5094 display_file_offsets
= TRUE
;
5097 with_line_numbers
= TRUE
;
5106 enum demangling_styles style
;
5108 style
= cplus_demangle_name_to_style (optarg
);
5109 if (style
== unknown_demangling
)
5110 fatal (_("unknown demangling style `%s'"),
5113 cplus_demangle_set_style (style
);
5116 case OPTION_RECURSE_LIMIT
:
5117 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5119 case OPTION_NO_RECURSE_LIMIT
:
5120 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5123 do_wide
= wide_output
= TRUE
;
5125 case OPTION_ADJUST_VMA
:
5126 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5128 case OPTION_START_ADDRESS
:
5129 start_address
= parse_vma (optarg
, "--start-address");
5130 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5131 fatal (_("error: the start address should be before the end address"));
5133 case OPTION_STOP_ADDRESS
:
5134 stop_address
= parse_vma (optarg
, "--stop-address");
5135 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5136 fatal (_("error: the stop address should be after the start address"));
5140 prefix_length
= strlen (prefix
);
5141 /* Remove an unnecessary trailing '/' */
5142 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5145 case OPTION_PREFIX_STRIP
:
5146 prefix_strip
= atoi (optarg
);
5147 if (prefix_strip
< 0)
5148 fatal (_("error: prefix strip must be non-negative"));
5150 case OPTION_INSN_WIDTH
:
5151 insn_width
= strtoul (optarg
, NULL
, 0);
5152 if (insn_width
<= 0)
5153 fatal (_("error: instruction width must be positive"));
5155 case OPTION_INLINES
:
5156 unwind_inlines
= TRUE
;
5158 case OPTION_VISUALIZE_JUMPS
:
5159 visualize_jumps
= TRUE
;
5160 color_output
= FALSE
;
5161 extended_color_output
= FALSE
;
5164 if (streq (optarg
, "color"))
5165 color_output
= TRUE
;
5166 else if (streq (optarg
, "extended-color"))
5168 color_output
= TRUE
;
5169 extended_color_output
= TRUE
;
5171 else if (streq (optarg
, "off"))
5172 visualize_jumps
= FALSE
;
5174 nonfatal (_("unrecognized argument to --visualize-option"));
5178 if (strcmp (optarg
, "B") == 0)
5179 endian
= BFD_ENDIAN_BIG
;
5180 else if (strcmp (optarg
, "L") == 0)
5181 endian
= BFD_ENDIAN_LITTLE
;
5184 nonfatal (_("unrecognized -E option"));
5189 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5190 endian
= BFD_ENDIAN_BIG
;
5191 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5192 endian
= BFD_ENDIAN_LITTLE
;
5195 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5202 dump_file_header
= TRUE
;
5206 formats_info
= TRUE
;
5210 add_include_path (optarg
);
5213 dump_private_headers
= TRUE
;
5217 dump_private_options
= optarg
;
5221 dump_private_headers
= TRUE
;
5223 dump_reloc_info
= TRUE
;
5224 dump_file_header
= TRUE
;
5225 dump_ar_hdrs
= TRUE
;
5226 dump_section_headers
= TRUE
;
5234 dump_dynamic_symtab
= TRUE
;
5240 disasm_sym
= optarg
;
5243 disassemble_zeroes
= TRUE
;
5247 disassemble_all
= TRUE
;
5252 with_source_code
= TRUE
;
5255 case OPTION_SOURCE_COMMENT
:
5257 with_source_code
= TRUE
;
5260 source_comment
= xstrdup (sanitize_string (optarg
));
5262 source_comment
= xstrdup ("# ");
5270 dump_debugging_tags
= 1;
5275 dump_dwarf_section_info
= TRUE
;
5278 dwarf_select_sections_by_letters (optarg
);
5280 dwarf_select_sections_all ();
5283 dump_dwarf_section_info
= TRUE
;
5286 dwarf_select_sections_by_names (optarg
);
5288 dwarf_select_sections_all ();
5290 case OPTION_DWARF_DEPTH
:
5293 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5296 case OPTION_DWARF_START
:
5299 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5300 suppress_bfd_header
= 1;
5303 case OPTION_DWARF_CHECK
:
5307 dump_ctf_section_info
= TRUE
;
5308 dump_ctf_section_name
= xstrdup (optarg
);
5311 case OPTION_CTF_PARENT
:
5312 dump_ctf_parent_name
= xstrdup (optarg
);
5315 dump_stab_section_info
= TRUE
;
5319 dump_section_contents
= TRUE
;
5323 dump_reloc_info
= TRUE
;
5327 dump_dynamic_reloc_info
= TRUE
;
5331 dump_ar_hdrs
= TRUE
;
5335 dump_section_headers
= TRUE
;
5340 show_version
= TRUE
;
5346 /* No need to set seenflag or to break - usage() does not return. */
5353 print_version ("objdump");
5359 exit_status
= display_info ();
5363 display_file ("a.out", target
, TRUE
);
5365 for (; optind
< argc
;)
5367 display_file (argv
[optind
], target
, optind
== argc
- 1);
5373 free (dump_ctf_section_name
);
5374 free (dump_ctf_parent_name
);
5375 free ((void *) source_comment
);
5377 END_PROGRESS (program_name
);