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 /* Note - we cannot just compare section pointers because they could
1069 be different, but the same... Ie the symbol that we are trying to
1070 find could have come from a separate debug info file. Under such
1071 circumstances the symbol will be associated with a section in the
1072 debug info file, whilst the section we want is in a normal file.
1073 So the section pointers will be different, but the section names
1074 will be the same. */
1075 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1076 bfd_section_name (sec
)) != 0)
1080 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1083 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1084 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1085 require the symbol to be in the section. Returns NULL if there is no
1086 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1087 of the symbol in sorted_syms. */
1090 find_symbol_for_address (bfd_vma vma
,
1091 struct disassemble_info
*inf
,
1094 /* @@ Would it speed things up to cache the last two symbols returned,
1095 and maybe their address ranges? For many processors, only one memory
1096 operand can be present at a time, so the 2-entry cache wouldn't be
1097 constantly churned by code doing heavy memory accesses. */
1099 /* Indices in `sorted_syms'. */
1101 long max_count
= sorted_symcount
;
1103 struct objdump_disasm_info
*aux
;
1107 bfd_boolean want_section
;
1110 if (sorted_symcount
< 1)
1113 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1116 opb
= inf
->octets_per_byte
;
1118 /* Perform a binary search looking for the closest symbol to the
1119 required value. We are searching the range (min, max_count]. */
1120 while (min
+ 1 < max_count
)
1124 thisplace
= (max_count
+ min
) / 2;
1125 sym
= sorted_syms
[thisplace
];
1127 if (bfd_asymbol_value (sym
) > vma
)
1128 max_count
= thisplace
;
1129 else if (bfd_asymbol_value (sym
) < vma
)
1138 /* The symbol we want is now in min, the low end of the range we
1139 were searching. If there are several symbols with the same
1140 value, we want the first one. */
1142 while (thisplace
> 0
1143 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1144 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1147 /* Prefer a symbol in the current section if we have multple symbols
1148 with the same value, as can occur with overlays or zero size
1151 while (min
< max_count
1152 && (bfd_asymbol_value (sorted_syms
[min
])
1153 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1155 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1162 return sorted_syms
[thisplace
];
1167 /* If the file is relocatable, and the symbol could be from this
1168 section, prefer a symbol from this section over symbols from
1169 others, even if the other symbol's value might be closer.
1171 Note that this may be wrong for some symbol references if the
1172 sections have overlapping memory ranges, but in that case there's
1173 no way to tell what's desired without looking at the relocation
1176 Also give the target a chance to reject symbols. */
1177 want_section
= (aux
->require_sec
1178 || ((abfd
->flags
& HAS_RELOC
) != 0
1179 && vma
>= bfd_section_vma (sec
)
1180 && vma
< (bfd_section_vma (sec
)
1181 + bfd_section_size (sec
) / opb
)));
1183 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1186 long newplace
= sorted_symcount
;
1188 for (i
= min
- 1; i
>= 0; i
--)
1190 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1192 if (newplace
== sorted_symcount
)
1195 if (bfd_asymbol_value (sorted_syms
[i
])
1196 != bfd_asymbol_value (sorted_syms
[newplace
]))
1199 /* Remember this symbol and keep searching until we reach
1200 an earlier address. */
1205 if (newplace
!= sorted_symcount
)
1206 thisplace
= newplace
;
1209 /* We didn't find a good symbol with a smaller value.
1210 Look for one with a larger value. */
1211 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1213 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1221 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1222 /* There is no suitable symbol. */
1226 /* If we have not found an exact match for the specified address
1227 and we have dynamic relocations available, then we can produce
1228 a better result by matching a relocation to the address and
1229 using the symbol associated with that relocation. */
1230 rel_count
= aux
->dynrelcount
;
1232 && sorted_syms
[thisplace
]->value
!= vma
1234 && aux
->dynrelbuf
!= NULL
1235 && aux
->dynrelbuf
[0]->address
<= vma
1236 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1237 /* If we have matched a synthetic symbol, then stick with that. */
1238 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1241 arelent
** rel_high
;
1243 rel_low
= aux
->dynrelbuf
;
1244 rel_high
= rel_low
+ rel_count
- 1;
1245 while (rel_low
<= rel_high
)
1247 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1248 arelent
* rel
= *rel_mid
;
1250 if (rel
->address
== vma
)
1252 /* Absolute relocations do not provide a more helpful
1253 symbolic address. Find a non-absolute relocation
1254 with the same address. */
1255 arelent
**rel_vma
= rel_mid
;
1257 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1261 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1265 if (rel
->sym_ptr_ptr
!= NULL
1266 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1269 * place
= thisplace
;
1270 return * rel
->sym_ptr_ptr
;
1276 if (vma
< rel
->address
)
1278 else if (vma
>= rel_mid
[1]->address
)
1279 rel_low
= rel_mid
+ 1;
1288 return sorted_syms
[thisplace
];
1291 /* Print an address and the offset to the nearest symbol. */
1294 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1295 bfd_vma vma
, struct disassemble_info
*inf
,
1296 bfd_boolean skip_zeroes
)
1298 objdump_print_value (vma
, inf
, skip_zeroes
);
1304 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1305 sanitize_string (bfd_section_name (sec
)));
1306 secaddr
= bfd_section_vma (sec
);
1309 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1310 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1312 else if (vma
> secaddr
)
1314 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1315 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1317 (*inf
->fprintf_func
) (inf
->stream
, ">");
1321 (*inf
->fprintf_func
) (inf
->stream
, " <");
1323 objdump_print_symname (abfd
, inf
, sym
);
1325 if (bfd_asymbol_value (sym
) == vma
)
1327 /* Undefined symbols in an executables and dynamic objects do not have
1328 a value associated with them, so it does not make sense to display
1329 an offset relative to them. Normally we would not be provided with
1330 this kind of symbol, but the target backend might choose to do so,
1331 and the code in find_symbol_for_address might return an as yet
1332 unresolved symbol associated with a dynamic reloc. */
1333 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1334 && bfd_is_und_section (sym
->section
))
1336 else if (bfd_asymbol_value (sym
) > vma
)
1338 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1339 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1341 else if (vma
> bfd_asymbol_value (sym
))
1343 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1344 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1347 (*inf
->fprintf_func
) (inf
->stream
, ">");
1350 if (display_file_offsets
)
1351 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1352 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1355 /* Print an address (VMA), symbolically if possible.
1356 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1359 objdump_print_addr (bfd_vma vma
,
1360 struct disassemble_info
*inf
,
1361 bfd_boolean skip_zeroes
)
1363 struct objdump_disasm_info
*aux
;
1364 asymbol
*sym
= NULL
;
1365 bfd_boolean skip_find
= FALSE
;
1367 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1369 if (sorted_symcount
< 1)
1371 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1372 objdump_print_value (vma
, inf
, skip_zeroes
);
1374 if (display_file_offsets
)
1375 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1376 (long int) (inf
->section
->filepos
1377 + (vma
- inf
->section
->vma
)));
1381 if (aux
->reloc
!= NULL
1382 && aux
->reloc
->sym_ptr_ptr
!= NULL
1383 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1385 sym
= * aux
->reloc
->sym_ptr_ptr
;
1387 /* Adjust the vma to the reloc. */
1388 vma
+= bfd_asymbol_value (sym
);
1390 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1395 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1397 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1401 /* Print VMA to INFO. This function is passed to the disassembler
1405 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1407 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1410 /* Determine if the given address has a symbol associated with it. */
1413 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1417 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1419 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1422 /* Hold the last function name and the last line number we displayed
1423 in a disassembly. */
1425 static char *prev_functionname
;
1426 static unsigned int prev_line
;
1427 static unsigned int prev_discriminator
;
1429 /* We keep a list of all files that we have seen when doing a
1430 disassembly with source, so that we know how much of the file to
1431 display. This can be important for inlined functions. */
1433 struct print_file_list
1435 struct print_file_list
*next
;
1436 const char *filename
;
1437 const char *modname
;
1440 const char **linemap
;
1443 unsigned max_printed
;
1447 static struct print_file_list
*print_files
;
1449 /* The number of preceding context lines to show when we start
1450 displaying a file for the first time. */
1452 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1454 /* Read a complete file into memory. */
1457 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1460 int ps
= getpagesize ();
1464 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1468 if (fstat (fd
, fst
) < 0)
1473 *size
= fst
->st_size
;
1475 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1476 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1477 if (map
!= (char *) -1L)
1483 map
= (const char *) malloc (*size
);
1484 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1486 free ((void *) map
);
1493 #define line_map_decrease 5
1495 /* Precompute array of lines for a mapped file. */
1497 static const char **
1498 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1500 const char *p
, *lstart
, *end
;
1501 int chars_per_line
= 45; /* First iteration will use 40. */
1502 unsigned int lineno
;
1503 const char **linemap
= NULL
;
1504 unsigned long line_map_size
= 0;
1510 for (p
= map
; p
< end
; p
++)
1514 if (p
+ 1 < end
&& p
[1] == '\r')
1517 else if (*p
== '\r')
1519 if (p
+ 1 < end
&& p
[1] == '\n')
1525 /* End of line found. */
1527 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1529 unsigned long newsize
;
1531 chars_per_line
-= line_map_decrease
;
1532 if (chars_per_line
<= 1)
1534 line_map_size
= size
/ chars_per_line
+ 1;
1535 if (line_map_size
< lineno
+ 1)
1536 line_map_size
= lineno
+ 1;
1537 newsize
= line_map_size
* sizeof (char *);
1538 linemap
= (const char **) xrealloc (linemap
, newsize
);
1541 linemap
[lineno
++] = lstart
;
1549 /* Tries to open MODNAME, and if successful adds a node to print_files
1550 linked list and returns that node. Returns NULL on failure. */
1552 static struct print_file_list
*
1553 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1555 struct print_file_list
*p
;
1557 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1559 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1566 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1569 p
->filename
= origname
;
1570 p
->modname
= modname
;
1571 p
->next
= print_files
;
1577 /* If the source file, as described in the symtab, is not found
1578 try to locate it in one of the paths specified with -I
1579 If found, add location to print_files linked list. */
1581 static struct print_file_list
*
1582 update_source_path (const char *filename
, bfd
*abfd
)
1584 struct print_file_list
*p
;
1589 p
= try_print_file_open (filename
, filename
, &fst
);
1592 if (include_path_count
== 0)
1595 /* Get the name of the file. */
1596 fname
= lbasename (filename
);
1598 /* If file exists under a new path, we need to add it to the list
1599 so that show_line knows about it. */
1600 for (i
= 0; i
< include_path_count
; i
++)
1602 char *modname
= concat (include_paths
[i
], "/", fname
,
1605 p
= try_print_file_open (filename
, modname
, &fst
);
1615 long mtime
= bfd_get_mtime (abfd
);
1617 if (fst
.st_mtime
> mtime
)
1618 warn (_("source file %s is more recent than object file\n"),
1625 /* Print a source file line. */
1628 print_line (struct print_file_list
*p
, unsigned int linenum
)
1634 if (linenum
>= p
->maxline
)
1636 l
= p
->linemap
[linenum
];
1637 if (source_comment
!= NULL
&& strlen (l
) > 0)
1638 printf ("%s", source_comment
);
1639 len
= strcspn (l
, "\n\r");
1640 /* Test fwrite return value to quiet glibc warning. */
1641 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1645 /* Print a range of source code lines. */
1648 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1652 while (start
<= end
)
1654 print_line (p
, start
);
1659 /* Show the line number, or the source line, in a disassembly
1663 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1665 const char *filename
;
1666 const char *functionname
;
1667 unsigned int linenumber
;
1668 unsigned int discriminator
;
1672 if (! with_line_numbers
&& ! with_source_code
)
1675 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1676 &filename
, &functionname
,
1677 &linenumber
, &discriminator
))
1680 if (filename
!= NULL
&& *filename
== '\0')
1682 if (functionname
!= NULL
&& *functionname
== '\0')
1683 functionname
= NULL
;
1686 && IS_ABSOLUTE_PATH (filename
)
1690 const char *fname
= filename
;
1692 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1695 memcpy (path
, prefix
, prefix_length
);
1696 path_up
= path
+ prefix_length
;
1698 /* Build relocated filename, stripping off leading directories
1699 from the initial filename if requested. */
1700 if (prefix_strip
> 0)
1705 /* Skip selected directory levels. */
1706 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1707 if (IS_DIR_SEPARATOR(*s
))
1714 /* Update complete filename. */
1715 strncpy (path_up
, fname
, PATH_MAX
);
1716 path_up
[PATH_MAX
] = '\0';
1724 if (with_line_numbers
)
1726 if (functionname
!= NULL
1727 && (prev_functionname
== NULL
1728 || strcmp (functionname
, prev_functionname
) != 0))
1730 printf ("%s():\n", sanitize_string (functionname
));
1734 && (linenumber
!= prev_line
1735 || discriminator
!= prev_discriminator
))
1737 if (discriminator
> 0)
1738 printf ("%s:%u (discriminator %u)\n",
1739 filename
== NULL
? "???" : sanitize_string (filename
),
1740 linenumber
, discriminator
);
1742 printf ("%s:%u\n", filename
== NULL
1743 ? "???" : sanitize_string (filename
),
1748 const char *filename2
;
1749 const char *functionname2
;
1752 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1755 printf ("inlined by %s:%u",
1756 sanitize_string (filename2
), line2
);
1757 printf (" (%s)\n", sanitize_string (functionname2
));
1762 if (with_source_code
1766 struct print_file_list
**pp
, *p
;
1769 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1770 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1777 filename
= xstrdup (filename
);
1778 p
= update_source_path (filename
, abfd
);
1781 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1783 if (file_start_context
&& p
->first
)
1787 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1788 if (l
>= linenumber
)
1790 if (p
->max_printed
>= l
)
1792 if (p
->max_printed
< linenumber
)
1793 l
= p
->max_printed
+ 1;
1798 dump_lines (p
, l
, linenumber
);
1799 if (p
->max_printed
< linenumber
)
1800 p
->max_printed
= linenumber
;
1801 p
->last_line
= linenumber
;
1806 if (functionname
!= NULL
1807 && (prev_functionname
== NULL
1808 || strcmp (functionname
, prev_functionname
) != 0))
1810 if (prev_functionname
!= NULL
)
1811 free (prev_functionname
);
1812 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1813 strcpy (prev_functionname
, functionname
);
1816 if (linenumber
> 0 && linenumber
!= prev_line
)
1817 prev_line
= linenumber
;
1819 if (discriminator
!= prev_discriminator
)
1820 prev_discriminator
= discriminator
;
1826 /* Pseudo FILE object for strings. */
1834 /* sprintf to a "stream". */
1836 static int ATTRIBUTE_PRINTF_2
1837 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1844 size_t space
= f
->alloc
- f
->pos
;
1846 va_start (args
, format
);
1847 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1853 f
->alloc
= (f
->alloc
+ n
) * 2;
1854 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1861 /* Code for generating (colored) diagrams of control flow start and end
1864 /* Structure used to store the properties of a jump. */
1868 /* The next jump, or NULL if this is the last object. */
1869 struct jump_info
*next
;
1870 /* The previous jump, or NULL if this is the first object. */
1871 struct jump_info
*prev
;
1872 /* The start addresses of the jump. */
1875 /* The list of start addresses. */
1877 /* The number of elements. */
1879 /* The maximum number of elements that fit into the array. */
1882 /* The end address of the jump. */
1884 /* The drawing level of the jump. */
1888 /* Construct a jump object for a jump from start
1889 to end with the corresponding level. */
1891 static struct jump_info
*
1892 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1894 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1896 result
->next
= NULL
;
1897 result
->prev
= NULL
;
1898 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1899 result
->start
.addresses
[0] = start
;
1900 result
->start
.count
= 1;
1901 result
->start
.max_count
= 2;
1903 result
->level
= level
;
1908 /* Free a jump object and return the next object
1909 or NULL if this was the last one. */
1911 static struct jump_info
*
1912 jump_info_free (struct jump_info
*ji
)
1914 struct jump_info
*result
= NULL
;
1919 if (ji
->start
.addresses
)
1920 free (ji
->start
.addresses
);
1927 /* Get the smallest value of all start and end addresses. */
1930 jump_info_min_address (const struct jump_info
*ji
)
1932 bfd_vma min_address
= ji
->end
;
1935 for (i
= ji
->start
.count
; i
-- > 0;)
1936 if (ji
->start
.addresses
[i
] < min_address
)
1937 min_address
= ji
->start
.addresses
[i
];
1941 /* Get the largest value of all start and end addresses. */
1944 jump_info_max_address (const struct jump_info
*ji
)
1946 bfd_vma max_address
= ji
->end
;
1949 for (i
= ji
->start
.count
; i
-- > 0;)
1950 if (ji
->start
.addresses
[i
] > max_address
)
1951 max_address
= ji
->start
.addresses
[i
];
1955 /* Get the target address of a jump. */
1958 jump_info_end_address (const struct jump_info
*ji
)
1963 /* Test if an address is one of the start addresses of a jump. */
1966 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
1968 bfd_boolean result
= FALSE
;
1971 for (i
= ji
->start
.count
; i
-- > 0;)
1972 if (address
== ji
->start
.addresses
[i
])
1981 /* Test if an address is the target address of a jump. */
1984 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
1986 return (address
== ji
->end
);
1989 /* Get the difference between the smallest and largest address of a jump. */
1992 jump_info_size (const struct jump_info
*ji
)
1994 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
1997 /* Unlink a jump object from a list. */
2000 jump_info_unlink (struct jump_info
*node
,
2001 struct jump_info
**base
)
2004 node
->next
->prev
= node
->prev
;
2006 node
->prev
->next
= node
->next
;
2013 /* Insert unlinked jump info node into a list. */
2016 jump_info_insert (struct jump_info
*node
,
2017 struct jump_info
*target
,
2018 struct jump_info
**base
)
2020 node
->next
= target
;
2021 node
->prev
= target
->prev
;
2022 target
->prev
= node
;
2024 node
->prev
->next
= node
;
2029 /* Add unlinked node to the front of a list. */
2032 jump_info_add_front (struct jump_info
*node
,
2033 struct jump_info
**base
)
2037 node
->next
->prev
= node
;
2042 /* Move linked node to target position. */
2045 jump_info_move_linked (struct jump_info
*node
,
2046 struct jump_info
*target
,
2047 struct jump_info
**base
)
2050 jump_info_unlink (node
, base
);
2051 /* Insert node at target position. */
2052 jump_info_insert (node
, target
, base
);
2055 /* Test if two jumps intersect. */
2058 jump_info_intersect (const struct jump_info
*a
,
2059 const struct jump_info
*b
)
2061 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2062 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2065 /* Merge two compatible jump info objects. */
2068 jump_info_merge (struct jump_info
**base
)
2070 struct jump_info
*a
;
2072 for (a
= *base
; a
; a
= a
->next
)
2074 struct jump_info
*b
;
2076 for (b
= a
->next
; b
; b
= b
->next
)
2078 /* Merge both jumps into one. */
2079 if (a
->end
== b
->end
)
2081 /* Reallocate addresses. */
2082 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2085 if (needed_size
> a
->start
.max_count
)
2087 a
->start
.max_count
+= b
->start
.max_count
;
2088 a
->start
.addresses
=
2089 xrealloc (a
->start
.addresses
,
2090 a
->start
.max_count
* sizeof(bfd_vma
*));
2093 /* Append start addresses. */
2094 for (i
= 0; i
< b
->start
.count
; ++i
)
2095 a
->start
.addresses
[a
->start
.count
++] =
2096 b
->start
.addresses
[i
];
2098 /* Remove and delete jump. */
2099 struct jump_info
*tmp
= b
->prev
;
2100 jump_info_unlink (b
, base
);
2108 /* Sort jumps by their size and starting point using a stable
2109 minsort. This could be improved if sorting performance is
2110 an issue, for example by using mergesort. */
2113 jump_info_sort (struct jump_info
**base
)
2115 struct jump_info
*current_element
= *base
;
2117 while (current_element
)
2119 struct jump_info
*best_match
= current_element
;
2120 struct jump_info
*runner
= current_element
->next
;
2121 bfd_vma best_size
= jump_info_size (best_match
);
2125 bfd_vma runner_size
= jump_info_size (runner
);
2127 if ((runner_size
< best_size
)
2128 || ((runner_size
== best_size
)
2129 && (jump_info_min_address (runner
)
2130 < jump_info_min_address (best_match
))))
2132 best_match
= runner
;
2133 best_size
= runner_size
;
2136 runner
= runner
->next
;
2139 if (best_match
== current_element
)
2140 current_element
= current_element
->next
;
2142 jump_info_move_linked (best_match
, current_element
, base
);
2146 /* Visualize all jumps at a given address. */
2149 jump_info_visualize_address (const struct jump_info
*jumps
,
2153 uint8_t *color_buffer
)
2155 size_t len
= (max_level
+ 1) * 3;
2156 const struct jump_info
*ji
;
2158 /* Clear line buffer. */
2159 memset(line_buffer
, ' ', len
);
2160 memset(color_buffer
, 0, len
);
2162 /* Iterate over jumps and add their ASCII art. */
2163 for (ji
= jumps
; ji
; ji
= ji
->next
)
2165 if ((jump_info_min_address (ji
) <= address
)
2166 && (jump_info_max_address (ji
) >= address
))
2168 /* Hash target address to get an even
2169 distribution between all values. */
2170 bfd_vma hash_address
= jump_info_end_address (ji
);
2171 uint8_t color
= iterative_hash_object (hash_address
, 0);
2172 /* Fetch line offset. */
2173 int offset
= (max_level
- ji
->level
) * 3;
2175 /* Draw start line. */
2176 if (jump_info_is_start_address (ji
, address
))
2178 size_t i
= offset
+ 1;
2180 for (; i
< len
- 1; ++i
)
2181 if (line_buffer
[i
] == ' ')
2183 line_buffer
[i
] = '-';
2184 color_buffer
[i
] = color
;
2187 if (line_buffer
[i
] == ' ')
2189 line_buffer
[i
] = '-';
2190 color_buffer
[i
] = color
;
2192 else if (line_buffer
[i
] == '>')
2194 line_buffer
[i
] = 'X';
2195 color_buffer
[i
] = color
;
2198 if (line_buffer
[offset
] == ' ')
2200 if (address
<= ji
->end
)
2201 line_buffer
[offset
] =
2202 (jump_info_min_address (ji
) == address
) ? '/': '+';
2204 line_buffer
[offset
] =
2205 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2206 color_buffer
[offset
] = color
;
2209 /* Draw jump target. */
2210 else if (jump_info_is_end_address (ji
, address
))
2212 size_t i
= offset
+ 1;
2214 for (; i
< len
- 1; ++i
)
2215 if (line_buffer
[i
] == ' ')
2217 line_buffer
[i
] = '-';
2218 color_buffer
[i
] = color
;
2221 if (line_buffer
[i
] == ' ')
2223 line_buffer
[i
] = '>';
2224 color_buffer
[i
] = color
;
2226 else if (line_buffer
[i
] == '-')
2228 line_buffer
[i
] = 'X';
2229 color_buffer
[i
] = color
;
2232 if (line_buffer
[offset
] == ' ')
2234 if (jump_info_min_address (ji
) < address
)
2235 line_buffer
[offset
] =
2236 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2238 line_buffer
[offset
] = '/';
2239 color_buffer
[offset
] = color
;
2242 /* Draw intermediate line segment. */
2243 else if (line_buffer
[offset
] == ' ')
2245 line_buffer
[offset
] = '|';
2246 color_buffer
[offset
] = color
;
2252 /* Clone of disassemble_bytes to detect jumps inside a function. */
2253 /* FIXME: is this correct? Can we strip it down even further? */
2255 static struct jump_info
*
2256 disassemble_jumps (struct disassemble_info
* inf
,
2257 disassembler_ftype disassemble_fn
,
2258 bfd_vma start_offset
,
2259 bfd_vma stop_offset
,
2262 arelent
** relppend
)
2264 struct objdump_disasm_info
*aux
;
2265 struct jump_info
*jumps
= NULL
;
2267 bfd_vma addr_offset
;
2268 unsigned int opb
= inf
->octets_per_byte
;
2272 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2273 section
= inf
->section
;
2276 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2279 inf
->insn_info_valid
= 0;
2280 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2281 inf
->stream
= &sfile
;
2283 addr_offset
= start_offset
;
2284 while (addr_offset
< stop_offset
)
2286 int previous_octets
;
2288 /* Remember the length of the previous instruction. */
2289 previous_octets
= octets
;
2293 inf
->bytes_per_line
= 0;
2294 inf
->bytes_per_chunk
= 0;
2295 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2296 | (wide_output
? WIDE_OUTPUT
: 0));
2298 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2300 if (inf
->disassembler_needs_relocs
2301 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2302 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2303 && *relppp
< relppend
)
2305 bfd_signed_vma distance_to_rel
;
2307 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2309 /* Check to see if the current reloc is associated with
2310 the instruction that we are about to disassemble. */
2311 if (distance_to_rel
== 0
2312 /* FIXME: This is wrong. We are trying to catch
2313 relocs that are addressed part way through the
2314 current instruction, as might happen with a packed
2315 VLIW instruction. Unfortunately we do not know the
2316 length of the current instruction since we have not
2317 disassembled it yet. Instead we take a guess based
2318 upon the length of the previous instruction. The
2319 proper solution is to have a new target-specific
2320 disassembler function which just returns the length
2321 of an instruction at a given address without trying
2322 to display its disassembly. */
2323 || (distance_to_rel
> 0
2324 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2326 inf
->flags
|= INSN_HAS_RELOC
;
2330 if (! disassemble_all
2331 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2332 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2333 /* Set a stop_vma so that the disassembler will not read
2334 beyond the next symbol. We assume that symbols appear on
2335 the boundaries between instructions. We only do this when
2336 disassembling code of course, and when -D is in effect. */
2337 inf
->stop_vma
= section
->vma
+ stop_offset
;
2339 inf
->stop_offset
= stop_offset
;
2341 /* Extract jump information. */
2342 inf
->insn_info_valid
= 0;
2343 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2344 /* Test if a jump was detected. */
2345 if (inf
->insn_info_valid
2346 && ((inf
->insn_type
== dis_branch
)
2347 || (inf
->insn_type
== dis_condbranch
)
2348 || (inf
->insn_type
== dis_jsr
)
2349 || (inf
->insn_type
== dis_condjsr
))
2350 && (inf
->target
>= section
->vma
+ start_offset
)
2351 && (inf
->target
< section
->vma
+ stop_offset
))
2353 struct jump_info
*ji
=
2354 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2355 jump_info_add_front (ji
, &jumps
);
2360 addr_offset
+= octets
/ opb
;
2363 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2364 inf
->stream
= stdout
;
2366 free (sfile
.buffer
);
2369 jump_info_merge (&jumps
);
2370 /* Process jumps. */
2371 jump_info_sort (&jumps
);
2373 /* Group jumps by level. */
2374 struct jump_info
*last_jump
= jumps
;
2379 /* The last jump is part of the next group. */
2380 struct jump_info
*base
= last_jump
;
2381 /* Increment level. */
2382 base
->level
= ++max_level
;
2384 /* Find jumps that can be combined on the same
2385 level, with the largest jumps tested first.
2386 This has the advantage that large jumps are on
2387 lower levels and do not intersect with small
2388 jumps that get grouped on higher levels. */
2389 struct jump_info
*exchange_item
= last_jump
->next
;
2390 struct jump_info
*it
= exchange_item
;
2392 for (; it
; it
= it
->next
)
2394 /* Test if the jump intersects with any
2395 jump from current group. */
2396 bfd_boolean ok
= TRUE
;
2397 struct jump_info
*it_collision
;
2399 for (it_collision
= base
;
2400 it_collision
!= exchange_item
;
2401 it_collision
= it_collision
->next
)
2403 /* This jump intersects so we leave it out. */
2404 if (jump_info_intersect (it_collision
, it
))
2411 /* Add jump to group. */
2414 /* Move current element to the front. */
2415 if (it
!= exchange_item
)
2417 struct jump_info
*save
= it
->prev
;
2418 jump_info_move_linked (it
, exchange_item
, &jumps
);
2424 last_jump
= exchange_item
;
2425 exchange_item
= exchange_item
->next
;
2427 last_jump
->level
= max_level
;
2431 /* Move to next group. */
2432 last_jump
= exchange_item
;
2438 /* The number of zeroes we want to see before we start skipping them.
2439 The number is arbitrarily chosen. */
2441 #define DEFAULT_SKIP_ZEROES 8
2443 /* The number of zeroes to skip at the end of a section. If the
2444 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2445 SKIP_ZEROES, they will be disassembled. If there are fewer than
2446 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2447 attempt to avoid disassembling zeroes inserted by section
2450 #define DEFAULT_SKIP_ZEROES_AT_END 3
2453 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2458 /* Disassemble some data in memory between given values. */
2461 disassemble_bytes (struct disassemble_info
* inf
,
2462 disassembler_ftype disassemble_fn
,
2465 bfd_vma start_offset
,
2466 bfd_vma stop_offset
,
2469 arelent
** relppend
)
2471 struct objdump_disasm_info
*aux
;
2473 int octets_per_line
;
2474 int skip_addr_chars
;
2475 bfd_vma addr_offset
;
2476 unsigned int opb
= inf
->octets_per_byte
;
2477 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2478 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2482 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2483 section
= inf
->section
;
2486 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2490 octets_per_line
= insn_width
;
2492 octets_per_line
= 4;
2494 octets_per_line
= 16;
2496 /* Figure out how many characters to skip at the start of an
2497 address, to make the disassembly look nicer. We discard leading
2498 zeroes in chunks of 4, ensuring that there is always a leading
2500 skip_addr_chars
= 0;
2501 if (! prefix_addresses
)
2505 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2507 while (buf
[skip_addr_chars
] == '0')
2510 /* Don't discard zeros on overflow. */
2511 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2512 skip_addr_chars
= 0;
2514 if (skip_addr_chars
!= 0)
2515 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2518 inf
->insn_info_valid
= 0;
2520 /* Determine maximum level. */
2522 struct jump_info
*base
= detected_jumps
? detected_jumps
: NULL
;
2523 struct jump_info
*ji
;
2525 for (ji
= base
; ji
; ji
= ji
->next
)
2527 if (ji
->level
> max_level
)
2529 max_level
= ji
->level
;
2533 /* Allocate line buffer if there are any jumps. */
2534 size_t len
= (max_level
+ 1) * 3 + 1;
2535 char *line_buffer
= (max_level
>= 0) ? xmalloc(len
): NULL
;
2536 uint8_t *color_buffer
= (max_level
>= 0) ? xmalloc(len
): NULL
;
2540 line_buffer
[len
- 1] = 0;
2541 color_buffer
[len
- 1] = 0;
2544 addr_offset
= start_offset
;
2545 while (addr_offset
< stop_offset
)
2548 bfd_boolean need_nl
= FALSE
;
2552 /* Make sure we don't use relocs from previous instructions. */
2555 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2557 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2560 if (! disassemble_zeroes
2561 && (inf
->insn_info_valid
== 0
2562 || inf
->branch_delay_insns
== 0)
2563 && (z
- addr_offset
* opb
>= skip_zeroes
2564 || (z
== stop_offset
* opb
&&
2565 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2567 /* If there are more nonzero octets to follow, we only skip
2568 zeroes in multiples of 4, to try to avoid running over
2569 the start of an instruction which happens to start with
2571 if (z
!= stop_offset
* opb
)
2572 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2574 octets
= z
- addr_offset
* opb
;
2576 /* If we are going to display more data, and we are displaying
2577 file offsets, then tell the user how many zeroes we skip
2578 and the file offset from where we resume dumping. */
2579 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2580 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2582 (unsigned long) (section
->filepos
2583 + (addr_offset
+ (octets
/ opb
))));
2593 if (with_line_numbers
|| with_source_code
)
2594 show_line (aux
->abfd
, section
, addr_offset
);
2596 if (! prefix_addresses
)
2600 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2601 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2605 printf ("%s:\t", buf
+ skip_addr_chars
);
2609 aux
->require_sec
= TRUE
;
2610 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2611 aux
->require_sec
= FALSE
;
2615 /* Visualize jumps. */
2618 jump_info_visualize_address (base
,
2619 section
->vma
+ addr_offset
,
2624 size_t line_buffer_size
= strlen (line_buffer
);
2625 char last_color
= 0;
2627 for (size_t i
= 0; i
<= line_buffer_size
; ++i
)
2631 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2633 if (color
!= last_color
)
2636 if (extended_color_output
)
2637 /* Use extended 8bit color, but
2638 do not choose dark colors. */
2639 printf ("\033[38;5;%dm", 124 + (color
% 108));
2641 /* Use simple terminal colors. */
2642 printf ("\033[%dm", 31 + (color
% 7));
2649 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2656 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2657 inf
->stream
= &sfile
;
2658 inf
->bytes_per_line
= 0;
2659 inf
->bytes_per_chunk
= 0;
2660 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2661 | (wide_output
? WIDE_OUTPUT
: 0));
2663 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2665 if (inf
->disassembler_needs_relocs
2666 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2667 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2668 && *relppp
< relppend
)
2670 bfd_signed_vma distance_to_rel
;
2672 int max_reloc_offset
2673 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2675 distance_to_rel
= ((**relppp
)->address
- rel_offset
2678 if (distance_to_rel
> 0
2679 && (max_reloc_offset
< 0
2680 || distance_to_rel
<= max_reloc_offset
))
2682 /* This reloc *might* apply to the current insn,
2683 starting somewhere inside it. Discover the length
2684 of the current insn so that the check below will
2687 insn_size
= insn_width
;
2690 /* We find the length by calling the dissassembler
2691 function with a dummy print handler. This should
2692 work unless the disassembler is not expecting to
2693 be called multiple times for the same address.
2695 This does mean disassembling the instruction
2696 twice, but we only do this when there is a high
2697 probability that there is a reloc that will
2698 affect the instruction. */
2699 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2700 insn_size
= disassemble_fn (section
->vma
2701 + addr_offset
, inf
);
2702 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2706 /* Check to see if the current reloc is associated with
2707 the instruction that we are about to disassemble. */
2708 if (distance_to_rel
== 0
2709 || (distance_to_rel
> 0
2710 && distance_to_rel
< insn_size
/ (int) opb
))
2712 inf
->flags
|= INSN_HAS_RELOC
;
2713 aux
->reloc
= **relppp
;
2717 if (! disassemble_all
2718 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2719 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2720 /* Set a stop_vma so that the disassembler will not read
2721 beyond the next symbol. We assume that symbols appear on
2722 the boundaries between instructions. We only do this when
2723 disassembling code of course, and when -D is in effect. */
2724 inf
->stop_vma
= section
->vma
+ stop_offset
;
2726 inf
->stop_offset
= stop_offset
;
2727 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2730 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2731 inf
->stream
= stdout
;
2732 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2733 octets_per_line
= inf
->bytes_per_line
;
2734 if (octets
< (int) opb
)
2737 printf ("%s\n", sfile
.buffer
);
2740 non_fatal (_("disassemble_fn returned length %d"),
2751 octets
= octets_per_line
;
2752 if (addr_offset
+ octets
/ opb
> stop_offset
)
2753 octets
= (stop_offset
- addr_offset
) * opb
;
2755 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2757 if (ISPRINT (data
[j
]))
2758 buf
[j
- addr_offset
* opb
] = data
[j
];
2760 buf
[j
- addr_offset
* opb
] = '.';
2762 buf
[j
- addr_offset
* opb
] = '\0';
2765 if (prefix_addresses
2767 : show_raw_insn
>= 0)
2771 /* If ! prefix_addresses and ! wide_output, we print
2772 octets_per_line octets per line. */
2774 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2775 pb
= octets_per_line
;
2777 if (inf
->bytes_per_chunk
)
2778 bpc
= inf
->bytes_per_chunk
;
2782 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2784 /* PR 21580: Check for a buffer ending early. */
2785 if (j
+ bpc
<= stop_offset
* opb
)
2789 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2791 for (k
= bpc
- 1; k
>= 0; k
--)
2792 printf ("%02x", (unsigned) data
[j
+ k
]);
2796 for (k
= 0; k
< bpc
; k
++)
2797 printf ("%02x", (unsigned) data
[j
+ k
]);
2803 for (; pb
< octets_per_line
; pb
+= bpc
)
2807 for (k
= 0; k
< bpc
; k
++)
2812 /* Separate raw data from instruction by extra space. */
2822 printf ("%s", sfile
.buffer
);
2824 if (prefix_addresses
2826 : show_raw_insn
>= 0)
2834 j
= addr_offset
* opb
+ pb
;
2836 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2837 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2841 printf ("%s:\t", buf
+ skip_addr_chars
);
2843 pb
+= octets_per_line
;
2846 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2848 /* PR 21619: Check for a buffer ending early. */
2849 if (j
+ bpc
<= stop_offset
* opb
)
2853 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2855 for (k
= bpc
- 1; k
>= 0; k
--)
2856 printf ("%02x", (unsigned) data
[j
+ k
]);
2860 for (k
= 0; k
< bpc
; k
++)
2861 printf ("%02x", (unsigned) data
[j
+ k
]);
2875 while ((*relppp
) < relppend
2876 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2878 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2889 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2892 if (q
->howto
== NULL
)
2893 printf (": *unknown*\t");
2894 else if (q
->howto
->name
)
2895 printf (": %s\t", q
->howto
->name
);
2897 printf (": %d\t", q
->howto
->type
);
2899 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2900 printf ("*unknown*");
2903 const char *sym_name
;
2905 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2906 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2907 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2912 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2913 sym_name
= bfd_section_name (sym_sec
);
2914 if (sym_name
== NULL
|| *sym_name
== '\0')
2915 sym_name
= "*unknown*";
2916 printf ("%s", sanitize_string (sym_name
));
2922 bfd_signed_vma addend
= q
->addend
;
2930 objdump_print_value (addend
, inf
, TRUE
);
2942 addr_offset
+= octets
/ opb
;
2945 free (sfile
.buffer
);
2947 free (color_buffer
);
2951 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2953 const struct elf_backend_data
* bed
;
2954 bfd_vma sign_adjust
= 0;
2955 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2956 struct objdump_disasm_info
* paux
;
2957 unsigned int opb
= pinfo
->octets_per_byte
;
2958 bfd_byte
* data
= NULL
;
2959 bfd_size_type datasize
= 0;
2960 arelent
** rel_pp
= NULL
;
2961 arelent
** rel_ppstart
= NULL
;
2962 arelent
** rel_ppend
;
2963 bfd_vma stop_offset
;
2964 asymbol
* sym
= NULL
;
2968 unsigned long addr_offset
;
2969 bfd_boolean do_print
;
2972 stop_offset_reached
,
2977 /* Sections that do not contain machine
2978 code are not normally disassembled. */
2979 if (! disassemble_all
2980 && only_list
== NULL
2981 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2982 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2985 if (! process_section_p (section
))
2988 datasize
= bfd_section_size (section
);
2992 if (start_address
== (bfd_vma
) -1
2993 || start_address
< section
->vma
)
2996 addr_offset
= start_address
- section
->vma
;
2998 if (stop_address
== (bfd_vma
) -1)
2999 stop_offset
= datasize
/ opb
;
3002 if (stop_address
< section
->vma
)
3005 stop_offset
= stop_address
- section
->vma
;
3006 if (stop_offset
> datasize
/ opb
)
3007 stop_offset
= datasize
/ opb
;
3010 if (addr_offset
>= stop_offset
)
3013 /* Decide which set of relocs to use. Load them if necessary. */
3014 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3015 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3017 rel_pp
= paux
->dynrelbuf
;
3018 rel_count
= paux
->dynrelcount
;
3019 /* Dynamic reloc addresses are absolute, non-dynamic are section
3020 relative. REL_OFFSET specifies the reloc address corresponding
3021 to the start of this section. */
3022 rel_offset
= section
->vma
;
3030 if ((section
->flags
& SEC_RELOC
) != 0
3031 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3035 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3037 bfd_fatal (bfd_get_filename (abfd
));
3041 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3042 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3044 bfd_fatal (bfd_get_filename (abfd
));
3046 /* Sort the relocs by address. */
3047 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3051 rel_ppend
= rel_pp
+ rel_count
;
3053 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3055 non_fatal (_("Reading section %s failed because: %s"),
3056 section
->name
, bfd_errmsg (bfd_get_error ()));
3060 pinfo
->buffer
= data
;
3061 pinfo
->buffer_vma
= section
->vma
;
3062 pinfo
->buffer_length
= datasize
;
3063 pinfo
->section
= section
;
3065 /* Sort the symbols into value and section order. */
3066 compare_section
= section
;
3067 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3069 /* Skip over the relocs belonging to addresses below the
3071 while (rel_pp
< rel_ppend
3072 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3075 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3077 /* Find the nearest symbol forwards from our current position. */
3078 paux
->require_sec
= TRUE
;
3079 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3080 (struct disassemble_info
*) inf
,
3082 paux
->require_sec
= FALSE
;
3084 /* PR 9774: If the target used signed addresses then we must make
3085 sure that we sign extend the value that we calculate for 'addr'
3086 in the loop below. */
3087 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3088 && (bed
= get_elf_backend_data (abfd
)) != NULL
3089 && bed
->sign_extend_vma
)
3090 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3092 /* Disassemble a block of instructions up to the address associated with
3093 the symbol we have just found. Then print the symbol and find the
3094 next symbol on. Repeat until we have disassembled the entire section
3095 or we have reached the end of the address range we are interested in. */
3096 do_print
= paux
->symbol
== NULL
;
3097 loop_until
= stop_offset_reached
;
3099 while (addr_offset
< stop_offset
)
3103 bfd_vma nextstop_offset
;
3106 addr
= section
->vma
+ addr_offset
;
3107 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3109 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3114 (x
< sorted_symcount
3115 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3119 pinfo
->symbols
= sorted_syms
+ place
;
3120 pinfo
->num_symbols
= x
- place
;
3121 pinfo
->symtab_pos
= place
;
3125 pinfo
->symbols
= NULL
;
3126 pinfo
->num_symbols
= 0;
3127 pinfo
->symtab_pos
= -1;
3130 /* If we are only disassembling from a specific symbol,
3131 check to see if we should start or stop displaying. */
3132 if (sym
&& paux
->symbol
)
3136 /* See if we should stop printing. */
3140 if (sym
->flags
& BSF_FUNCTION
)
3144 case stop_offset_reached
:
3145 /* Handled by the while loop. */
3149 /* FIXME: There is an implicit assumption here
3150 that the name of sym is different from
3152 if (! bfd_is_local_label (abfd
, sym
))
3159 const char * name
= bfd_asymbol_name (sym
);
3160 char * alloc
= NULL
;
3162 if (do_demangle
&& name
[0] != '\0')
3164 /* Demangle the name. */
3165 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3170 /* We are not currently printing. Check to see
3171 if the current symbol matches the requested symbol. */
3172 if (streq (name
, paux
->symbol
))
3176 if (sym
->flags
& BSF_FUNCTION
)
3178 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3179 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3181 /* Sym is a function symbol with a size associated
3182 with it. Turn on automatic disassembly for the
3183 next VALUE bytes. */
3184 stop_offset
= addr_offset
3185 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3186 loop_until
= stop_offset_reached
;
3190 /* Otherwise we need to tell the loop heuristic to
3191 loop until the next function symbol is encountered. */
3192 loop_until
= function_sym
;
3197 /* Otherwise loop until the next symbol is encountered. */
3198 loop_until
= next_sym
;
3206 if (! prefix_addresses
&& do_print
)
3208 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3209 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3211 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3214 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3216 else if (sym
== NULL
)
3220 #define is_valid_next_sym(SYM) \
3221 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3222 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3223 && pinfo->symbol_is_valid (SYM, pinfo))
3225 /* Search forward for the next appropriate symbol in
3226 SECTION. Note that all the symbols are sorted
3227 together into one big array, and that some sections
3228 may have overlapping addresses. */
3229 while (place
< sorted_symcount
3230 && ! is_valid_next_sym (sorted_syms
[place
]))
3233 if (place
>= sorted_symcount
)
3236 nextsym
= sorted_syms
[place
];
3239 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3240 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3241 else if (nextsym
== NULL
)
3242 nextstop_offset
= stop_offset
;
3244 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3246 if (nextstop_offset
> stop_offset
3247 || nextstop_offset
<= addr_offset
)
3248 nextstop_offset
= stop_offset
;
3250 /* If a symbol is explicitly marked as being an object
3251 rather than a function, just dump the bytes without
3252 disassembling them. */
3255 || sym
->section
!= section
3256 || bfd_asymbol_value (sym
) > addr
3257 || ((sym
->flags
& BSF_OBJECT
) == 0
3258 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3260 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3262 || (sym
->flags
& BSF_FUNCTION
) != 0)
3269 /* Resolve symbol name. */
3270 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3272 struct disassemble_info di
;
3275 sf
.alloc
= strlen (sym
->name
) + 40;
3276 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3278 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3281 objdump_print_symname (abfd
, &di
, sym
);
3283 /* Fetch jump information. */
3284 detected_jumps
= disassemble_jumps
3285 (pinfo
, paux
->disassemble_fn
,
3286 addr_offset
, nextstop_offset
,
3287 rel_offset
, &rel_pp
, rel_ppend
);
3289 /* Free symbol name. */
3293 /* Add jumps to output. */
3294 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3295 addr_offset
, nextstop_offset
,
3296 rel_offset
, &rel_pp
, rel_ppend
);
3299 while (detected_jumps
)
3301 detected_jumps
= jump_info_free (detected_jumps
);
3305 addr_offset
= nextstop_offset
;
3311 if (rel_ppstart
!= NULL
)
3315 /* Disassemble the contents of an object file. */
3318 disassemble_data (bfd
*abfd
)
3320 struct disassemble_info disasm_info
;
3321 struct objdump_disasm_info aux
;
3325 prev_functionname
= NULL
;
3327 prev_discriminator
= 0;
3329 /* We make a copy of syms to sort. We don't want to sort syms
3330 because that will screw up the relocs. */
3331 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3332 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3333 * sizeof (asymbol
*));
3334 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3335 sorted_symcount
* sizeof (asymbol
*));
3337 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3339 for (i
= 0; i
< synthcount
; ++i
)
3341 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3345 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3347 disasm_info
.application_data
= (void *) &aux
;
3349 aux
.require_sec
= FALSE
;
3350 aux
.dynrelbuf
= NULL
;
3351 aux
.dynrelcount
= 0;
3353 aux
.symbol
= disasm_sym
;
3355 disasm_info
.print_address_func
= objdump_print_address
;
3356 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3358 if (machine
!= NULL
)
3360 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3363 fatal (_("can't use supplied machine %s"), machine
);
3365 abfd
->arch_info
= inf
;
3368 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3370 struct bfd_target
*xvec
;
3372 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3373 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3374 xvec
->byteorder
= endian
;
3378 /* Use libopcodes to locate a suitable disassembler. */
3379 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3380 bfd_big_endian (abfd
),
3381 bfd_get_mach (abfd
), abfd
);
3382 if (!aux
.disassemble_fn
)
3384 non_fatal (_("can't disassemble for architecture %s\n"),
3385 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3390 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3391 disasm_info
.arch
= bfd_get_arch (abfd
);
3392 disasm_info
.mach
= bfd_get_mach (abfd
);
3393 disasm_info
.disassembler_options
= disassembler_options
;
3394 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3395 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3396 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3397 disasm_info
.disassembler_needs_relocs
= FALSE
;
3399 if (bfd_big_endian (abfd
))
3400 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3401 else if (bfd_little_endian (abfd
))
3402 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3404 /* ??? Aborting here seems too drastic. We could default to big or little
3406 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3408 /* Allow the target to customize the info structure. */
3409 disassemble_init_for_target (& disasm_info
);
3411 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3413 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3415 if (relsize
< 0 && dump_dynamic_reloc_info
)
3416 bfd_fatal (bfd_get_filename (abfd
));
3420 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3421 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3424 if (aux
.dynrelcount
< 0)
3425 bfd_fatal (bfd_get_filename (abfd
));
3427 /* Sort the relocs by address. */
3428 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3432 disasm_info
.symtab
= sorted_syms
;
3433 disasm_info
.symtab_size
= sorted_symcount
;
3435 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3437 if (aux
.dynrelbuf
!= NULL
)
3438 free (aux
.dynrelbuf
);
3440 disassemble_free_target (&disasm_info
);
3444 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3445 asection
*sec
, void *file
)
3447 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3448 bfd
*abfd
= (bfd
*) file
;
3453 if (section
->start
!= NULL
)
3455 /* If it is already loaded, do nothing. */
3456 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3458 free (section
->start
);
3461 section
->filename
= bfd_get_filename (abfd
);
3462 section
->reloc_info
= NULL
;
3463 section
->num_relocs
= 0;
3464 section
->address
= bfd_section_vma (sec
);
3465 section
->user_data
= sec
;
3466 section
->size
= bfd_section_size (sec
);
3467 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3468 alloced
= amt
= section
->size
+ 1;
3469 if (alloced
!= amt
|| alloced
== 0)
3471 section
->start
= NULL
;
3472 free_debug_section (debug
);
3473 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3474 sanitize_string (section
->name
),
3475 (unsigned long long) section
->size
);
3478 section
->start
= contents
= malloc (alloced
);
3479 if (section
->start
== NULL
3480 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3482 free_debug_section (debug
);
3483 printf (_("\nCan't get contents for section '%s'.\n"),
3484 sanitize_string (section
->name
));
3487 /* Ensure any string section has a terminating NUL. */
3488 section
->start
[section
->size
] = 0;
3490 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3491 && debug_displays
[debug
].relocate
)
3496 bfd_cache_section_contents (sec
, section
->start
);
3498 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3505 free_debug_section (debug
);
3506 printf (_("\nCan't get contents for section '%s'.\n"),
3507 sanitize_string (section
->name
));
3511 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3514 unsigned long reloc_count
;
3517 relocs
= (arelent
**) xmalloc (reloc_size
);
3519 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3520 if (reloc_count
== 0)
3524 section
->reloc_info
= relocs
;
3525 section
->num_relocs
= reloc_count
;
3534 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3539 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3542 relocs
= (arelent
**) dsec
->reloc_info
;
3544 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3545 if (rp
->address
== offset
)
3552 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3554 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3555 bfd
*abfd
= (bfd
*) file
;
3558 /* If it is already loaded, do nothing. */
3559 if (section
->start
!= NULL
)
3561 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3565 /* Locate the debug section. */
3566 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3568 section
->name
= section
->uncompressed_name
;
3571 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3573 section
->name
= section
->compressed_name
;
3578 return load_specific_debug_section (debug
, sec
, file
);
3582 free_debug_section (enum dwarf_section_display_enum debug
)
3584 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3586 if (section
->start
== NULL
)
3589 /* PR 17512: file: 0f67f69d. */
3590 if (section
->user_data
!= NULL
)
3592 asection
* sec
= (asection
*) section
->user_data
;
3594 /* If we are freeing contents that are also pointed to by the BFD
3595 library's section structure then make sure to update those pointers
3596 too. Otherwise, the next time we try to load data for this section
3597 we can end up using a stale pointer. */
3598 if (section
->start
== sec
->contents
)
3600 sec
->contents
= NULL
;
3601 sec
->flags
&= ~ SEC_IN_MEMORY
;
3602 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3606 free ((char *) section
->start
);
3607 section
->start
= NULL
;
3608 section
->address
= 0;
3613 close_debug_file (void * file
)
3615 bfd
* abfd
= (bfd
*) file
;
3621 open_debug_file (const char * pathname
)
3625 data
= bfd_openr (pathname
, NULL
);
3629 if (! bfd_check_format (data
, bfd_object
))
3635 #if HAVE_LIBDEBUGINFOD
3636 /* Return a hex string represention of the build-id. */
3639 get_build_id (void * data
)
3642 char * build_id_str
;
3643 bfd
* abfd
= (bfd
*) data
;
3644 const struct bfd_build_id
* build_id
;
3646 build_id
= abfd
->build_id
;
3647 if (build_id
== NULL
)
3650 build_id_str
= malloc (build_id
->size
* 2 + 1);
3651 if (build_id_str
== NULL
)
3654 for (i
= 0; i
< build_id
->size
; i
++)
3655 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3656 build_id_str
[build_id
->size
* 2] = '\0';
3658 return (unsigned char *)build_id_str
;
3660 #endif /* HAVE_LIBDEBUGINFOD */
3663 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3664 void *arg ATTRIBUTE_UNUSED
)
3666 const char *name
= bfd_section_name (section
);
3670 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3671 match
= ".debug_info";
3675 for (i
= 0; i
< max
; i
++)
3676 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3677 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3678 && debug_displays
[i
].enabled
!= NULL
3679 && *debug_displays
[i
].enabled
)
3681 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3683 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3684 sec
->name
= sec
->uncompressed_name
;
3686 sec
->name
= sec
->compressed_name
;
3687 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3690 debug_displays
[i
].display (sec
, abfd
);
3692 if (i
!= info
&& i
!= abbrev
)
3693 free_debug_section ((enum dwarf_section_display_enum
) i
);
3699 /* Dump the dwarf debugging information. */
3702 dump_dwarf (bfd
*abfd
)
3704 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3705 if (byte_get
== NULL
)
3707 warn (_("File %s does not contain any dwarf debug information\n"),
3708 bfd_get_filename (abfd
));
3712 switch (bfd_get_arch (abfd
))
3715 /* S12Z has a 24 bit address space. But the only known
3716 producer of dwarf_info encodes addresses into 32 bits. */
3721 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3725 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3726 bfd_get_mach (abfd
));
3728 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3731 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3732 it. Return NULL on failure. */
3735 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3736 bfd_size_type
*entsize_ptr
)
3741 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3742 if (stabsect
== NULL
)
3744 printf (_("No %s section present\n\n"),
3745 sanitize_string (sect_name
));
3749 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3751 non_fatal (_("reading %s section of %s failed: %s"),
3752 sect_name
, bfd_get_filename (abfd
),
3753 bfd_errmsg (bfd_get_error ()));
3759 *size_ptr
= bfd_section_size (stabsect
);
3761 *entsize_ptr
= stabsect
->entsize
;
3766 /* Stabs entries use a 12 byte format:
3767 4 byte string table index
3769 1 byte stab other field
3770 2 byte stab desc field
3772 FIXME: This will have to change for a 64 bit object format. */
3774 #define STRDXOFF (0)
3776 #define OTHEROFF (5)
3779 #define STABSIZE (12)
3781 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3782 using string table section STRSECT_NAME (in `strtab'). */
3785 print_section_stabs (bfd
*abfd
,
3786 const char *stabsect_name
,
3787 unsigned *string_offset_ptr
)
3790 unsigned file_string_table_offset
= 0;
3791 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3792 bfd_byte
*stabp
, *stabs_end
;
3795 stabs_end
= stabp
+ stab_size
;
3797 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3798 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3800 /* Loop through all symbols and print them.
3802 We start the index at -1 because there is a dummy symbol on
3803 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3804 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3808 unsigned char type
, other
;
3809 unsigned short desc
;
3812 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3813 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3814 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3815 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3816 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3818 printf ("\n%-6d ", i
);
3819 /* Either print the stab name, or, if unnamed, print its number
3820 again (makes consistent formatting for tools like awk). */
3821 name
= bfd_get_stab_name (type
);
3823 printf ("%-6s", sanitize_string (name
));
3824 else if (type
== N_UNDF
)
3827 printf ("%-6d", type
);
3828 printf (" %-6d %-6d ", other
, desc
);
3829 bfd_printf_vma (abfd
, value
);
3830 printf (" %-6lu", strx
);
3832 /* Symbols with type == 0 (N_UNDF) specify the length of the
3833 string table associated with this file. We use that info
3834 to know how to relocate the *next* file's string table indices. */
3837 file_string_table_offset
= next_file_string_table_offset
;
3838 next_file_string_table_offset
+= value
;
3842 bfd_size_type amt
= strx
+ file_string_table_offset
;
3844 /* Using the (possibly updated) string table offset, print the
3845 string (if any) associated with this symbol. */
3846 if (amt
< stabstr_size
)
3847 /* PR 17512: file: 079-79389-0.001:0.1.
3848 FIXME: May need to sanitize this string before displaying. */
3849 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3855 *string_offset_ptr
= next_file_string_table_offset
;
3860 const char * section_name
;
3861 const char * string_section_name
;
3862 unsigned string_offset
;
3867 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3870 stab_section_names
* sought
= (stab_section_names
*) names
;
3872 /* Check for section names for which stabsect_name is a prefix, to
3873 handle .stab.N, etc. */
3874 len
= strlen (sought
->section_name
);
3876 /* If the prefix matches, and the files section name ends with a
3877 nul or a digit, then we match. I.e., we want either an exact
3878 match or a section followed by a number. */
3879 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3880 && (section
->name
[len
] == 0
3881 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3884 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3885 &stabstr_size
, NULL
);
3889 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3891 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3897 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3899 stab_section_names s
;
3901 s
.section_name
= stabsect_name
;
3902 s
.string_section_name
= strsect_name
;
3903 s
.string_offset
= 0;
3905 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3911 /* Dump the any sections containing stabs debugging information. */
3914 dump_stabs (bfd
*abfd
)
3916 dump_stabs_section (abfd
, ".stab", ".stabstr");
3917 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3918 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3921 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3923 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3927 dump_bfd_header (bfd
*abfd
)
3931 printf (_("architecture: %s, "),
3932 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3933 bfd_get_mach (abfd
)));
3934 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3936 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3937 PF (HAS_RELOC
, "HAS_RELOC");
3938 PF (EXEC_P
, "EXEC_P");
3939 PF (HAS_LINENO
, "HAS_LINENO");
3940 PF (HAS_DEBUG
, "HAS_DEBUG");
3941 PF (HAS_SYMS
, "HAS_SYMS");
3942 PF (HAS_LOCALS
, "HAS_LOCALS");
3943 PF (DYNAMIC
, "DYNAMIC");
3944 PF (WP_TEXT
, "WP_TEXT");
3945 PF (D_PAGED
, "D_PAGED");
3946 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3947 printf (_("\nstart address 0x"));
3948 bfd_printf_vma (abfd
, abfd
->start_address
);
3953 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3954 it is passed, or a pointer to newly-allocated storage, in which case
3955 dump_ctf() will free it when it no longer needs it. */
3958 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3961 const char *blanks
= arg
;
3964 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3969 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3971 make_ctfsect (const char *name
, bfd_byte
*data
,
3976 ctfsect
.cts_name
= name
;
3977 ctfsect
.cts_entsize
= 1;
3978 ctfsect
.cts_size
= size
;
3979 ctfsect
.cts_data
= data
;
3984 /* Dump one CTF archive member. */
3987 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3989 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3990 const char *things
[] = {"Header", "Labels", "Data objects",
3991 "Function objects", "Variables", "Types", "Strings",
3996 /* Only print out the name of non-default-named archive members.
3997 The name .ctf appears everywhere, even for things that aren't
3998 really archives, so printing it out is liable to be confusing.
4000 The parent, if there is one, is the default-owned archive member:
4001 avoid importing it into itself. (This does no harm, but looks
4004 if (strcmp (name
, ".ctf") != 0)
4006 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4007 ctf_import (ctf
, parent
);
4010 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4012 ctf_dump_state_t
*s
= NULL
;
4015 printf ("\n %s:\n", *thing
);
4016 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4017 (void *) " ")) != NULL
)
4019 printf ("%s\n", item
);
4023 if (ctf_errno (ctf
))
4025 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4026 ctf_errmsg (ctf_errno (ctf
)));
4033 /* Dump the CTF debugging information. */
4036 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4038 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4039 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4040 bfd_size_type ctfsize
, parentsize
;
4042 ctf_file_t
*parent
= NULL
;
4045 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4046 bfd_fatal (bfd_get_filename (abfd
));
4049 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4051 bfd_fatal (bfd_get_filename (abfd
));
4053 /* Load the CTF file and dump it. */
4055 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4056 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4058 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4059 bfd_fatal (bfd_get_filename (abfd
));
4064 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4065 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4067 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4068 bfd_fatal (bfd_get_filename (abfd
));
4071 lookparent
= parenta
;
4076 /* Assume that the applicable parent archive member is the default one.
4077 (This is what all known implementations are expected to do, if they
4078 put CTFs and their parents in archives together.) */
4079 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4081 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4082 bfd_fatal (bfd_get_filename (abfd
));
4085 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4087 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4088 ctf_file_close (parent
);
4090 ctf_close (parenta
);
4097 dump_bfd_private_header (bfd
*abfd
)
4099 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4100 non_fatal (_("warning: private headers incomplete: %s"),
4101 bfd_errmsg (bfd_get_error ()));
4105 dump_target_specific (bfd
*abfd
)
4107 const struct objdump_private_desc
* const *desc
;
4108 struct objdump_private_option
*opt
;
4111 /* Find the desc. */
4112 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4113 if ((*desc
)->filter (abfd
))
4118 non_fatal (_("option -P/--private not supported by this file"));
4122 /* Clear all options. */
4123 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4124 opt
->selected
= FALSE
;
4126 /* Decode options. */
4127 b
= dump_private_options
;
4130 e
= strchr (b
, ',');
4135 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4136 if (strcmp (opt
->name
, b
) == 0)
4138 opt
->selected
= TRUE
;
4141 if (opt
->name
== NULL
)
4142 non_fatal (_("target specific dump '%s' not supported"), b
);
4153 (*desc
)->dump (abfd
);
4156 /* Display a section in hexadecimal format with associated characters.
4157 Each line prefixed by the zero padded address. */
4160 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4162 bfd_byte
*data
= NULL
;
4163 bfd_size_type datasize
;
4164 bfd_vma addr_offset
;
4165 bfd_vma start_offset
;
4166 bfd_vma stop_offset
;
4167 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4168 /* Bytes per line. */
4169 const int onaline
= 16;
4174 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4177 if (! process_section_p (section
))
4180 if ((datasize
= bfd_section_size (section
)) == 0)
4183 /* Compute the address range to display. */
4184 if (start_address
== (bfd_vma
) -1
4185 || start_address
< section
->vma
)
4188 start_offset
= start_address
- section
->vma
;
4190 if (stop_address
== (bfd_vma
) -1)
4191 stop_offset
= datasize
/ opb
;
4194 if (stop_address
< section
->vma
)
4197 stop_offset
= stop_address
- section
->vma
;
4199 if (stop_offset
> datasize
/ opb
)
4200 stop_offset
= datasize
/ opb
;
4203 if (start_offset
>= stop_offset
)
4206 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4207 if (display_file_offsets
)
4208 printf (_(" (Starting at file offset: 0x%lx)"),
4209 (unsigned long) (section
->filepos
+ start_offset
));
4212 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4214 non_fatal (_("Reading section %s failed because: %s"),
4215 section
->name
, bfd_errmsg (bfd_get_error ()));
4221 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4222 if (strlen (buf
) >= sizeof (buf
))
4226 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4228 count
= strlen (buf
) - count
;
4232 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4233 if (strlen (buf
) >= sizeof (buf
))
4237 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4239 count
= strlen (buf
) - count
;
4243 for (addr_offset
= start_offset
;
4244 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4248 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4249 count
= strlen (buf
);
4250 if ((size_t) count
>= sizeof (buf
))
4254 while (count
< width
)
4259 fputs (buf
+ count
- width
, stdout
);
4262 for (j
= addr_offset
* opb
;
4263 j
< addr_offset
* opb
+ onaline
; j
++)
4265 if (j
< stop_offset
* opb
)
4266 printf ("%02x", (unsigned) (data
[j
]));
4274 for (j
= addr_offset
* opb
;
4275 j
< addr_offset
* opb
+ onaline
; j
++)
4277 if (j
>= stop_offset
* opb
)
4280 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4287 /* Actually display the various requested regions. */
4290 dump_data (bfd
*abfd
)
4292 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4295 /* Should perhaps share code and display with nm? */
4298 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4307 max_count
= dynsymcount
;
4308 printf ("DYNAMIC SYMBOL TABLE:\n");
4313 max_count
= symcount
;
4314 printf ("SYMBOL TABLE:\n");
4318 printf (_("no symbols\n"));
4320 for (count
= 0; count
< max_count
; count
++)
4324 if (*current
== NULL
)
4325 printf (_("no information for symbol number %ld\n"), count
);
4327 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4328 printf (_("could not determine the type of symbol number %ld\n"),
4331 else if (process_section_p ((* current
)->section
)
4332 && (dump_special_syms
4333 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4335 const char *name
= (*current
)->name
;
4337 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4341 /* If we want to demangle the name, we demangle it
4342 here, and temporarily clobber it while calling
4343 bfd_print_symbol. FIXME: This is a gross hack. */
4344 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4346 (*current
)->name
= alloc
;
4347 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4348 bfd_print_symbol_all
);
4351 (*current
)->name
= name
;
4356 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4357 bfd_print_symbol_all
);
4367 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4370 char *last_filename
, *last_functionname
;
4371 unsigned int last_line
;
4372 unsigned int last_discriminator
;
4374 /* Get column headers lined up reasonably. */
4382 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4383 width
= strlen (buf
) - 7;
4385 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4388 last_filename
= NULL
;
4389 last_functionname
= NULL
;
4391 last_discriminator
= 0;
4393 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4396 const char *filename
, *functionname
;
4397 unsigned int linenumber
;
4398 unsigned int discriminator
;
4399 const char *sym_name
;
4400 const char *section_name
;
4401 bfd_vma addend2
= 0;
4403 if (start_address
!= (bfd_vma
) -1
4404 && q
->address
< start_address
)
4406 if (stop_address
!= (bfd_vma
) -1
4407 && q
->address
> stop_address
)
4410 if (with_line_numbers
4412 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4413 &filename
, &functionname
,
4414 &linenumber
, &discriminator
))
4416 if (functionname
!= NULL
4417 && (last_functionname
== NULL
4418 || strcmp (functionname
, last_functionname
) != 0))
4420 printf ("%s():\n", sanitize_string (functionname
));
4421 if (last_functionname
!= NULL
)
4422 free (last_functionname
);
4423 last_functionname
= xstrdup (functionname
);
4427 && (linenumber
!= last_line
4428 || (filename
!= NULL
4429 && last_filename
!= NULL
4430 && filename_cmp (filename
, last_filename
) != 0)
4431 || (discriminator
!= last_discriminator
)))
4433 if (discriminator
> 0)
4434 printf ("%s:%u\n", filename
== NULL
? "???" :
4435 sanitize_string (filename
), linenumber
);
4437 printf ("%s:%u (discriminator %u)\n",
4438 filename
== NULL
? "???" : sanitize_string (filename
),
4439 linenumber
, discriminator
);
4440 last_line
= linenumber
;
4441 last_discriminator
= discriminator
;
4442 if (last_filename
!= NULL
)
4443 free (last_filename
);
4444 if (filename
== NULL
)
4445 last_filename
= NULL
;
4447 last_filename
= xstrdup (filename
);
4451 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4453 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4454 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4459 section_name
= NULL
;
4462 bfd_printf_vma (abfd
, q
->address
);
4463 if (q
->howto
== NULL
)
4464 printf (" *unknown* ");
4465 else if (q
->howto
->name
)
4467 const char *name
= q
->howto
->name
;
4469 /* R_SPARC_OLO10 relocations contain two addends.
4470 But because 'arelent' lacks enough storage to
4471 store them both, the 64-bit ELF Sparc backend
4472 records this as two relocations. One R_SPARC_LO10
4473 and one R_SPARC_13, both pointing to the same
4474 address. This is merely so that we have some
4475 place to store both addend fields.
4477 Undo this transformation, otherwise the output
4478 will be confusing. */
4479 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4480 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
4482 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4484 arelent
*q2
= *(p
+ 1);
4487 && q
->address
== q2
->address
4488 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4490 name
= "R_SPARC_OLO10";
4491 addend2
= q2
->addend
;
4495 printf (" %-16s ", name
);
4498 printf (" %-16d ", q
->howto
->type
);
4502 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4506 if (section_name
== NULL
)
4507 section_name
= "*unknown*";
4508 printf ("[%s]", sanitize_string (section_name
));
4513 bfd_signed_vma addend
= q
->addend
;
4521 bfd_printf_vma (abfd
, addend
);
4526 bfd_printf_vma (abfd
, addend2
);
4532 if (last_filename
!= NULL
)
4533 free (last_filename
);
4534 if (last_functionname
!= NULL
)
4535 free (last_functionname
);
4539 dump_relocs_in_section (bfd
*abfd
,
4541 void *dummy ATTRIBUTE_UNUSED
)
4543 arelent
**relpp
= NULL
;
4547 if ( bfd_is_abs_section (section
)
4548 || bfd_is_und_section (section
)
4549 || bfd_is_com_section (section
)
4550 || (! process_section_p (section
))
4551 || ((section
->flags
& SEC_RELOC
) == 0))
4554 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4556 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4559 printf (" (none)\n\n");
4567 relpp
= (arelent
**) xmalloc (relsize
);
4568 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4574 non_fatal (_("failed to read relocs in: %s"),
4575 sanitize_string (bfd_get_filename (abfd
)));
4576 bfd_fatal (_("error message was"));
4578 else if (relcount
== 0)
4579 printf (" (none)\n\n");
4583 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4590 dump_relocs (bfd
*abfd
)
4592 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4596 dump_dynamic_relocs (bfd
*abfd
)
4602 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4604 bfd_fatal (bfd_get_filename (abfd
));
4606 printf ("DYNAMIC RELOCATION RECORDS");
4609 printf (" (none)\n\n");
4612 relpp
= (arelent
**) xmalloc (relsize
);
4613 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4616 bfd_fatal (bfd_get_filename (abfd
));
4617 else if (relcount
== 0)
4618 printf (" (none)\n\n");
4622 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4629 /* Creates a table of paths, to search for source files. */
4632 add_include_path (const char *path
)
4636 include_path_count
++;
4637 include_paths
= (const char **)
4638 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4639 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4640 if (path
[1] == ':' && path
[2] == 0)
4641 path
= concat (path
, ".", (const char *) 0);
4643 include_paths
[include_path_count
- 1] = path
;
4647 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4651 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4653 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4654 section
->vma
+= adjust_section_vma
;
4656 section
->lma
+= adjust_section_vma
;
4660 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4663 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4668 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4669 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4672 /* Dump selected contents of ABFD. */
4675 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4677 const struct elf_backend_data
* bed
;
4679 if (bfd_big_endian (abfd
))
4680 byte_get
= byte_get_big_endian
;
4681 else if (bfd_little_endian (abfd
))
4682 byte_get
= byte_get_little_endian
;
4686 /* Load any separate debug information files.
4687 We do this now and without checking do_follow_links because separate
4688 debug info files may contain symbol tables that we will need when
4689 displaying information about the main file. Any memory allocated by
4690 load_separate_debug_files will be released when we call
4691 free_debug_memory below.
4693 The test on is_mainfile is there because the chain of separate debug
4694 info files is a global variable shared by all invocations of dump_bfd. */
4697 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4699 /* If asked to do so, recursively dump the separate files. */
4700 if (do_follow_links
)
4704 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4705 dump_bfd (i
->handle
, FALSE
);
4709 /* Adjust user-specified start and stop limits for targets that use
4710 signed addresses. */
4711 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4712 && (bed
= get_elf_backend_data (abfd
)) != NULL
4713 && bed
->sign_extend_vma
)
4715 start_address
= sign_extend_address (abfd
, start_address
,
4717 stop_address
= sign_extend_address (abfd
, stop_address
,
4721 /* If we are adjusting section VMA's, change them all now. Changing
4722 the BFD information is a hack. However, we must do it, or
4723 bfd_find_nearest_line will not do the right thing. */
4724 if (adjust_section_vma
!= 0)
4726 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4727 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4730 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4731 printf (_("\n%s: file format %s\n"),
4732 sanitize_string (bfd_get_filename (abfd
)),
4735 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4736 if (dump_file_header
)
4737 dump_bfd_header (abfd
);
4738 if (dump_private_headers
)
4739 dump_bfd_private_header (abfd
);
4740 if (dump_private_options
!= NULL
)
4741 dump_target_specific (abfd
);
4742 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4749 || dump_dwarf_section_info
)
4751 syms
= slurp_symtab (abfd
);
4753 /* If following links, load any symbol tables from the linked files as well. */
4754 if (do_follow_links
&& is_mainfile
)
4758 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4760 asymbol
** extra_syms
;
4761 long old_symcount
= symcount
;
4763 extra_syms
= slurp_symtab (i
->handle
);
4767 if (old_symcount
== 0)
4773 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4774 memcpy (syms
+ old_symcount
,
4776 symcount
* sizeof (asymbol
*));
4780 symcount
+= old_symcount
;
4785 if (dump_section_headers
)
4786 dump_headers (abfd
);
4788 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4789 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4790 dynsyms
= slurp_dynamic_symtab (abfd
);
4794 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4795 dynsymcount
, dynsyms
, &synthsyms
);
4801 dump_symbols (abfd
, FALSE
);
4802 if (dump_dynamic_symtab
)
4803 dump_symbols (abfd
, TRUE
);
4804 if (dump_dwarf_section_info
)
4806 if (dump_ctf_section_info
)
4807 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4808 if (dump_stab_section_info
)
4810 if (dump_reloc_info
&& ! disassemble
)
4812 if (dump_dynamic_reloc_info
&& ! disassemble
)
4813 dump_dynamic_relocs (abfd
);
4814 if (dump_section_contents
)
4817 disassemble_data (abfd
);
4823 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4824 if (dhandle
!= NULL
)
4826 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4828 dump_debugging_tags
? TRUE
: FALSE
))
4830 non_fatal (_("%s: printing debugging information failed"),
4831 bfd_get_filename (abfd
));
4837 /* PR 6483: If there was no STABS debug info in the file, try
4839 else if (! dump_dwarf_section_info
)
4841 dwarf_select_sections_all ();
4869 free_debug_memory ();
4873 display_object_bfd (bfd
*abfd
)
4877 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4879 dump_bfd (abfd
, TRUE
);
4883 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4885 nonfatal (bfd_get_filename (abfd
));
4886 list_matching_formats (matching
);
4891 if (bfd_get_error () != bfd_error_file_not_recognized
)
4893 nonfatal (bfd_get_filename (abfd
));
4897 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4899 dump_bfd (abfd
, TRUE
);
4903 nonfatal (bfd_get_filename (abfd
));
4905 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4907 list_matching_formats (matching
);
4913 display_any_bfd (bfd
*file
, int level
)
4915 /* Decompress sections unless dumping the section contents. */
4916 if (!dump_section_contents
)
4917 file
->flags
|= BFD_DECOMPRESS
;
4919 /* If the file is an archive, process all of its elements. */
4920 if (bfd_check_format (file
, bfd_archive
))
4923 bfd
*last_arfile
= NULL
;
4926 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4927 else if (level
> 100)
4929 /* Prevent corrupted files from spinning us into an
4930 infinite loop. 100 is an arbitrary heuristic. */
4931 fatal (_("Archive nesting is too deep"));
4935 printf (_("In nested archive %s:\n"),
4936 sanitize_string (bfd_get_filename (file
)));
4940 bfd_set_error (bfd_error_no_error
);
4942 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4945 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4946 nonfatal (bfd_get_filename (file
));
4950 display_any_bfd (arfile
, level
+ 1);
4952 if (last_arfile
!= NULL
)
4954 bfd_close (last_arfile
);
4955 /* PR 17512: file: ac585d01. */
4956 if (arfile
== last_arfile
)
4962 last_arfile
= arfile
;
4965 if (last_arfile
!= NULL
)
4966 bfd_close (last_arfile
);
4969 display_object_bfd (file
);
4973 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4977 if (get_file_size (filename
) < 1)
4983 file
= bfd_openr (filename
, target
);
4986 nonfatal (filename
);
4990 display_any_bfd (file
, 0);
4992 /* This is an optimization to improve the speed of objdump, especially when
4993 dumping a file with lots of associated debug informatiom. Calling
4994 bfd_close on such a file can take a non-trivial amount of time as there
4995 are lots of lists to walk and buffers to free. This is only really
4996 necessary however if we are about to load another file and we need the
4997 memory back. Otherwise, if we are about to exit, then we can save (a lot
4998 of) time by only doing a quick close, and allowing the OS to reclaim the
5003 bfd_close_all_done (file
);
5007 main (int argc
, char **argv
)
5010 char *target
= default_target
;
5011 bfd_boolean seenflag
= FALSE
;
5013 #if defined (HAVE_SETLOCALE)
5014 #if defined (HAVE_LC_MESSAGES)
5015 setlocale (LC_MESSAGES
, "");
5017 setlocale (LC_CTYPE
, "");
5020 bindtextdomain (PACKAGE
, LOCALEDIR
);
5021 textdomain (PACKAGE
);
5023 program_name
= *argv
;
5024 xmalloc_set_program_name (program_name
);
5025 bfd_set_error_program_name (program_name
);
5027 START_PROGRESS (program_name
, 0);
5029 expandargv (&argc
, &argv
);
5031 if (bfd_init () != BFD_INIT_MAGIC
)
5032 fatal (_("fatal error: libbfd ABI mismatch"));
5033 set_default_bfd_target ();
5035 while ((c
= getopt_long (argc
, argv
,
5036 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5037 long_options
, (int *) 0))
5043 break; /* We've been given a long option. */
5050 if (disassembler_options
)
5051 /* Ignore potential memory leak for now. */
5052 options
= concat (disassembler_options
, ",",
5053 optarg
, (const char *) NULL
);
5056 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5063 display_file_offsets
= TRUE
;
5066 with_line_numbers
= TRUE
;
5075 enum demangling_styles style
;
5077 style
= cplus_demangle_name_to_style (optarg
);
5078 if (style
== unknown_demangling
)
5079 fatal (_("unknown demangling style `%s'"),
5082 cplus_demangle_set_style (style
);
5085 case OPTION_RECURSE_LIMIT
:
5086 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5088 case OPTION_NO_RECURSE_LIMIT
:
5089 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5092 do_wide
= wide_output
= TRUE
;
5094 case OPTION_ADJUST_VMA
:
5095 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5097 case OPTION_START_ADDRESS
:
5098 start_address
= parse_vma (optarg
, "--start-address");
5099 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5100 fatal (_("error: the start address should be before the end address"));
5102 case OPTION_STOP_ADDRESS
:
5103 stop_address
= parse_vma (optarg
, "--stop-address");
5104 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5105 fatal (_("error: the stop address should be after the start address"));
5109 prefix_length
= strlen (prefix
);
5110 /* Remove an unnecessary trailing '/' */
5111 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5114 case OPTION_PREFIX_STRIP
:
5115 prefix_strip
= atoi (optarg
);
5116 if (prefix_strip
< 0)
5117 fatal (_("error: prefix strip must be non-negative"));
5119 case OPTION_INSN_WIDTH
:
5120 insn_width
= strtoul (optarg
, NULL
, 0);
5121 if (insn_width
<= 0)
5122 fatal (_("error: instruction width must be positive"));
5124 case OPTION_INLINES
:
5125 unwind_inlines
= TRUE
;
5127 case OPTION_VISUALIZE_JUMPS
:
5128 visualize_jumps
= TRUE
;
5129 color_output
= FALSE
;
5130 extended_color_output
= FALSE
;
5133 if (streq (optarg
, "color"))
5134 color_output
= TRUE
;
5135 else if (streq (optarg
, "extended-color"))
5137 color_output
= TRUE
;
5138 extended_color_output
= TRUE
;
5140 else if (streq (optarg
, "off"))
5141 visualize_jumps
= FALSE
;
5143 nonfatal (_("unrecognized argument to --visualize-option"));
5147 if (strcmp (optarg
, "B") == 0)
5148 endian
= BFD_ENDIAN_BIG
;
5149 else if (strcmp (optarg
, "L") == 0)
5150 endian
= BFD_ENDIAN_LITTLE
;
5153 nonfatal (_("unrecognized -E option"));
5158 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5159 endian
= BFD_ENDIAN_BIG
;
5160 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5161 endian
= BFD_ENDIAN_LITTLE
;
5164 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5171 dump_file_header
= TRUE
;
5175 formats_info
= TRUE
;
5179 add_include_path (optarg
);
5182 dump_private_headers
= TRUE
;
5186 dump_private_options
= optarg
;
5190 dump_private_headers
= TRUE
;
5192 dump_reloc_info
= TRUE
;
5193 dump_file_header
= TRUE
;
5194 dump_ar_hdrs
= TRUE
;
5195 dump_section_headers
= TRUE
;
5203 dump_dynamic_symtab
= TRUE
;
5209 disasm_sym
= optarg
;
5212 disassemble_zeroes
= TRUE
;
5216 disassemble_all
= TRUE
;
5221 with_source_code
= TRUE
;
5224 case OPTION_SOURCE_COMMENT
:
5226 with_source_code
= TRUE
;
5229 source_comment
= xstrdup (sanitize_string (optarg
));
5231 source_comment
= xstrdup ("# ");
5239 dump_debugging_tags
= 1;
5244 dump_dwarf_section_info
= TRUE
;
5247 dwarf_select_sections_by_letters (optarg
);
5249 dwarf_select_sections_all ();
5252 dump_dwarf_section_info
= TRUE
;
5255 dwarf_select_sections_by_names (optarg
);
5257 dwarf_select_sections_all ();
5259 case OPTION_DWARF_DEPTH
:
5262 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5265 case OPTION_DWARF_START
:
5268 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5269 suppress_bfd_header
= 1;
5272 case OPTION_DWARF_CHECK
:
5276 dump_ctf_section_info
= TRUE
;
5277 dump_ctf_section_name
= xstrdup (optarg
);
5280 case OPTION_CTF_PARENT
:
5281 dump_ctf_parent_name
= xstrdup (optarg
);
5284 dump_stab_section_info
= TRUE
;
5288 dump_section_contents
= TRUE
;
5292 dump_reloc_info
= TRUE
;
5296 dump_dynamic_reloc_info
= TRUE
;
5300 dump_ar_hdrs
= TRUE
;
5304 dump_section_headers
= TRUE
;
5309 show_version
= TRUE
;
5315 /* No need to set seenflag or to break - usage() does not return. */
5322 print_version ("objdump");
5328 exit_status
= display_info ();
5332 display_file ("a.out", target
, TRUE
);
5334 for (; optind
< argc
;)
5336 display_file (argv
[optind
], target
, optind
== argc
- 1);
5342 free (dump_ctf_section_name
);
5343 free (dump_ctf_parent_name
);
5344 free ((void *) source_comment
);
5346 END_PROGRESS (program_name
);