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 (bfd_vma address
,
2152 uint8_t *color_buffer
)
2154 struct jump_info
*ji
= detected_jumps
;
2155 size_t len
= (max_level
+ 1) * 3;
2157 /* Clear line buffer. */
2158 memset (line_buffer
, ' ', len
);
2159 memset (color_buffer
, 0, len
);
2161 /* Iterate over jumps and add their ASCII art. */
2164 /* Discard jumps that are never needed again. */
2165 if (jump_info_max_address (ji
) < address
)
2167 struct jump_info
*tmp
= ji
;
2170 jump_info_unlink (tmp
, &detected_jumps
);
2171 jump_info_free (tmp
);
2175 /* This jump intersects with the current address. */
2176 if (jump_info_min_address (ji
) <= address
)
2178 /* Hash target address to get an even
2179 distribution between all values. */
2180 bfd_vma hash_address
= jump_info_end_address (ji
);
2181 uint8_t color
= iterative_hash_object (hash_address
, 0);
2182 /* Fetch line offset. */
2183 int offset
= (max_level
- ji
->level
) * 3;
2185 /* Draw start line. */
2186 if (jump_info_is_start_address (ji
, address
))
2188 size_t i
= offset
+ 1;
2190 for (; i
< len
- 1; ++i
)
2191 if (line_buffer
[i
] == ' ')
2193 line_buffer
[i
] = '-';
2194 color_buffer
[i
] = color
;
2197 if (line_buffer
[i
] == ' ')
2199 line_buffer
[i
] = '-';
2200 color_buffer
[i
] = color
;
2202 else if (line_buffer
[i
] == '>')
2204 line_buffer
[i
] = 'X';
2205 color_buffer
[i
] = color
;
2208 if (line_buffer
[offset
] == ' ')
2210 if (address
<= ji
->end
)
2211 line_buffer
[offset
] =
2212 (jump_info_min_address (ji
) == address
) ? '/': '+';
2214 line_buffer
[offset
] =
2215 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2216 color_buffer
[offset
] = color
;
2219 /* Draw jump target. */
2220 else if (jump_info_is_end_address (ji
, address
))
2222 size_t i
= offset
+ 1;
2224 for (; i
< len
- 1; ++i
)
2225 if (line_buffer
[i
] == ' ')
2227 line_buffer
[i
] = '-';
2228 color_buffer
[i
] = color
;
2231 if (line_buffer
[i
] == ' ')
2233 line_buffer
[i
] = '>';
2234 color_buffer
[i
] = color
;
2236 else if (line_buffer
[i
] == '-')
2238 line_buffer
[i
] = 'X';
2239 color_buffer
[i
] = color
;
2242 if (line_buffer
[offset
] == ' ')
2244 if (jump_info_min_address (ji
) < address
)
2245 line_buffer
[offset
] =
2246 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2248 line_buffer
[offset
] = '/';
2249 color_buffer
[offset
] = color
;
2252 /* Draw intermediate line segment. */
2253 else if (line_buffer
[offset
] == ' ')
2255 line_buffer
[offset
] = '|';
2256 color_buffer
[offset
] = color
;
2264 /* Clone of disassemble_bytes to detect jumps inside a function. */
2265 /* FIXME: is this correct? Can we strip it down even further? */
2267 static struct jump_info
*
2268 disassemble_jumps (struct disassemble_info
* inf
,
2269 disassembler_ftype disassemble_fn
,
2270 bfd_vma start_offset
,
2271 bfd_vma stop_offset
,
2274 arelent
** relppend
)
2276 struct objdump_disasm_info
*aux
;
2277 struct jump_info
*jumps
= NULL
;
2279 bfd_vma addr_offset
;
2280 unsigned int opb
= inf
->octets_per_byte
;
2284 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2285 section
= inf
->section
;
2288 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2291 inf
->insn_info_valid
= 0;
2292 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2293 inf
->stream
= &sfile
;
2295 addr_offset
= start_offset
;
2296 while (addr_offset
< stop_offset
)
2298 int previous_octets
;
2300 /* Remember the length of the previous instruction. */
2301 previous_octets
= octets
;
2305 inf
->bytes_per_line
= 0;
2306 inf
->bytes_per_chunk
= 0;
2307 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2308 | (wide_output
? WIDE_OUTPUT
: 0));
2310 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2312 if (inf
->disassembler_needs_relocs
2313 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2314 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2315 && *relppp
< relppend
)
2317 bfd_signed_vma distance_to_rel
;
2319 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2321 /* Check to see if the current reloc is associated with
2322 the instruction that we are about to disassemble. */
2323 if (distance_to_rel
== 0
2324 /* FIXME: This is wrong. We are trying to catch
2325 relocs that are addressed part way through the
2326 current instruction, as might happen with a packed
2327 VLIW instruction. Unfortunately we do not know the
2328 length of the current instruction since we have not
2329 disassembled it yet. Instead we take a guess based
2330 upon the length of the previous instruction. The
2331 proper solution is to have a new target-specific
2332 disassembler function which just returns the length
2333 of an instruction at a given address without trying
2334 to display its disassembly. */
2335 || (distance_to_rel
> 0
2336 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2338 inf
->flags
|= INSN_HAS_RELOC
;
2342 if (! disassemble_all
2343 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2344 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2345 /* Set a stop_vma so that the disassembler will not read
2346 beyond the next symbol. We assume that symbols appear on
2347 the boundaries between instructions. We only do this when
2348 disassembling code of course, and when -D is in effect. */
2349 inf
->stop_vma
= section
->vma
+ stop_offset
;
2351 inf
->stop_offset
= stop_offset
;
2353 /* Extract jump information. */
2354 inf
->insn_info_valid
= 0;
2355 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2356 /* Test if a jump was detected. */
2357 if (inf
->insn_info_valid
2358 && ((inf
->insn_type
== dis_branch
)
2359 || (inf
->insn_type
== dis_condbranch
)
2360 || (inf
->insn_type
== dis_jsr
)
2361 || (inf
->insn_type
== dis_condjsr
))
2362 && (inf
->target
>= section
->vma
+ start_offset
)
2363 && (inf
->target
< section
->vma
+ stop_offset
))
2365 struct jump_info
*ji
=
2366 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2367 jump_info_add_front (ji
, &jumps
);
2372 addr_offset
+= octets
/ opb
;
2375 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2376 inf
->stream
= stdout
;
2378 free (sfile
.buffer
);
2381 jump_info_merge (&jumps
);
2382 /* Process jumps. */
2383 jump_info_sort (&jumps
);
2385 /* Group jumps by level. */
2386 struct jump_info
*last_jump
= jumps
;
2391 /* The last jump is part of the next group. */
2392 struct jump_info
*base
= last_jump
;
2393 /* Increment level. */
2394 base
->level
= ++max_level
;
2396 /* Find jumps that can be combined on the same
2397 level, with the largest jumps tested first.
2398 This has the advantage that large jumps are on
2399 lower levels and do not intersect with small
2400 jumps that get grouped on higher levels. */
2401 struct jump_info
*exchange_item
= last_jump
->next
;
2402 struct jump_info
*it
= exchange_item
;
2404 for (; it
; it
= it
->next
)
2406 /* Test if the jump intersects with any
2407 jump from current group. */
2408 bfd_boolean ok
= TRUE
;
2409 struct jump_info
*it_collision
;
2411 for (it_collision
= base
;
2412 it_collision
!= exchange_item
;
2413 it_collision
= it_collision
->next
)
2415 /* This jump intersects so we leave it out. */
2416 if (jump_info_intersect (it_collision
, it
))
2423 /* Add jump to group. */
2426 /* Move current element to the front. */
2427 if (it
!= exchange_item
)
2429 struct jump_info
*save
= it
->prev
;
2430 jump_info_move_linked (it
, exchange_item
, &jumps
);
2436 last_jump
= exchange_item
;
2437 exchange_item
= exchange_item
->next
;
2439 last_jump
->level
= max_level
;
2443 /* Move to next group. */
2444 last_jump
= exchange_item
;
2450 /* The number of zeroes we want to see before we start skipping them.
2451 The number is arbitrarily chosen. */
2453 #define DEFAULT_SKIP_ZEROES 8
2455 /* The number of zeroes to skip at the end of a section. If the
2456 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2457 SKIP_ZEROES, they will be disassembled. If there are fewer than
2458 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2459 attempt to avoid disassembling zeroes inserted by section
2462 #define DEFAULT_SKIP_ZEROES_AT_END 3
2465 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2470 /* Disassemble some data in memory between given values. */
2473 disassemble_bytes (struct disassemble_info
* inf
,
2474 disassembler_ftype disassemble_fn
,
2477 bfd_vma start_offset
,
2478 bfd_vma stop_offset
,
2481 arelent
** relppend
)
2483 struct objdump_disasm_info
*aux
;
2485 int octets_per_line
;
2486 int skip_addr_chars
;
2487 bfd_vma addr_offset
;
2488 unsigned int opb
= inf
->octets_per_byte
;
2489 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2490 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2494 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2495 section
= inf
->section
;
2498 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2502 octets_per_line
= insn_width
;
2504 octets_per_line
= 4;
2506 octets_per_line
= 16;
2508 /* Figure out how many characters to skip at the start of an
2509 address, to make the disassembly look nicer. We discard leading
2510 zeroes in chunks of 4, ensuring that there is always a leading
2512 skip_addr_chars
= 0;
2513 if (! prefix_addresses
)
2517 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2519 while (buf
[skip_addr_chars
] == '0')
2522 /* Don't discard zeros on overflow. */
2523 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2524 skip_addr_chars
= 0;
2526 if (skip_addr_chars
!= 0)
2527 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2530 inf
->insn_info_valid
= 0;
2532 /* Determine maximum level. */
2533 uint8_t *color_buffer
= NULL
;
2534 char *line_buffer
= NULL
;
2537 /* Some jumps were detected. */
2540 struct jump_info
*ji
;
2542 /* Find maximum jump level. */
2543 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2545 if (ji
->level
> max_level
)
2546 max_level
= ji
->level
;
2549 /* Allocate buffers. */
2550 size_t len
= (max_level
+ 1) * 3 + 1;
2551 line_buffer
= xmalloc (len
);
2552 line_buffer
[len
- 1] = 0;
2553 color_buffer
= xmalloc (len
);
2554 color_buffer
[len
- 1] = 0;
2557 addr_offset
= start_offset
;
2558 while (addr_offset
< stop_offset
)
2561 bfd_boolean need_nl
= FALSE
;
2565 /* Make sure we don't use relocs from previous instructions. */
2568 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2570 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2573 if (! disassemble_zeroes
2574 && (inf
->insn_info_valid
== 0
2575 || inf
->branch_delay_insns
== 0)
2576 && (z
- addr_offset
* opb
>= skip_zeroes
2577 || (z
== stop_offset
* opb
&&
2578 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2580 /* If there are more nonzero octets to follow, we only skip
2581 zeroes in multiples of 4, to try to avoid running over
2582 the start of an instruction which happens to start with
2584 if (z
!= stop_offset
* opb
)
2585 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2587 octets
= z
- addr_offset
* opb
;
2589 /* If we are going to display more data, and we are displaying
2590 file offsets, then tell the user how many zeroes we skip
2591 and the file offset from where we resume dumping. */
2592 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2593 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2595 (unsigned long) (section
->filepos
2596 + (addr_offset
+ (octets
/ opb
))));
2606 if (with_line_numbers
|| with_source_code
)
2607 show_line (aux
->abfd
, section
, addr_offset
);
2609 if (! prefix_addresses
)
2613 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2614 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2618 printf ("%s:\t", buf
+ skip_addr_chars
);
2622 aux
->require_sec
= TRUE
;
2623 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2624 aux
->require_sec
= FALSE
;
2628 /* Visualize jumps. */
2631 jump_info_visualize_address (section
->vma
+ addr_offset
,
2636 size_t line_buffer_size
= strlen (line_buffer
);
2637 char last_color
= 0;
2640 for (i
= 0; i
<= line_buffer_size
; ++i
)
2644 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2646 if (color
!= last_color
)
2649 if (extended_color_output
)
2650 /* Use extended 8bit color, but
2651 do not choose dark colors. */
2652 printf ("\033[38;5;%dm", 124 + (color
% 108));
2654 /* Use simple terminal colors. */
2655 printf ("\033[%dm", 31 + (color
% 7));
2662 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2669 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2670 inf
->stream
= &sfile
;
2671 inf
->bytes_per_line
= 0;
2672 inf
->bytes_per_chunk
= 0;
2673 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2674 | (wide_output
? WIDE_OUTPUT
: 0));
2676 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2678 if (inf
->disassembler_needs_relocs
2679 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2680 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2681 && *relppp
< relppend
)
2683 bfd_signed_vma distance_to_rel
;
2685 int max_reloc_offset
2686 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2688 distance_to_rel
= ((**relppp
)->address
- rel_offset
2691 if (distance_to_rel
> 0
2692 && (max_reloc_offset
< 0
2693 || distance_to_rel
<= max_reloc_offset
))
2695 /* This reloc *might* apply to the current insn,
2696 starting somewhere inside it. Discover the length
2697 of the current insn so that the check below will
2700 insn_size
= insn_width
;
2703 /* We find the length by calling the dissassembler
2704 function with a dummy print handler. This should
2705 work unless the disassembler is not expecting to
2706 be called multiple times for the same address.
2708 This does mean disassembling the instruction
2709 twice, but we only do this when there is a high
2710 probability that there is a reloc that will
2711 affect the instruction. */
2712 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2713 insn_size
= disassemble_fn (section
->vma
2714 + addr_offset
, inf
);
2715 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2719 /* Check to see if the current reloc is associated with
2720 the instruction that we are about to disassemble. */
2721 if (distance_to_rel
== 0
2722 || (distance_to_rel
> 0
2723 && distance_to_rel
< insn_size
/ (int) opb
))
2725 inf
->flags
|= INSN_HAS_RELOC
;
2726 aux
->reloc
= **relppp
;
2730 if (! disassemble_all
2731 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2732 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2733 /* Set a stop_vma so that the disassembler will not read
2734 beyond the next symbol. We assume that symbols appear on
2735 the boundaries between instructions. We only do this when
2736 disassembling code of course, and when -D is in effect. */
2737 inf
->stop_vma
= section
->vma
+ stop_offset
;
2739 inf
->stop_offset
= stop_offset
;
2740 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2743 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2744 inf
->stream
= stdout
;
2745 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2746 octets_per_line
= inf
->bytes_per_line
;
2747 if (octets
< (int) opb
)
2750 printf ("%s\n", sfile
.buffer
);
2753 non_fatal (_("disassemble_fn returned length %d"),
2764 octets
= octets_per_line
;
2765 if (addr_offset
+ octets
/ opb
> stop_offset
)
2766 octets
= (stop_offset
- addr_offset
) * opb
;
2768 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2770 if (ISPRINT (data
[j
]))
2771 buf
[j
- addr_offset
* opb
] = data
[j
];
2773 buf
[j
- addr_offset
* opb
] = '.';
2775 buf
[j
- addr_offset
* opb
] = '\0';
2778 if (prefix_addresses
2780 : show_raw_insn
>= 0)
2784 /* If ! prefix_addresses and ! wide_output, we print
2785 octets_per_line octets per line. */
2787 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2788 pb
= octets_per_line
;
2790 if (inf
->bytes_per_chunk
)
2791 bpc
= inf
->bytes_per_chunk
;
2795 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2797 /* PR 21580: Check for a buffer ending early. */
2798 if (j
+ bpc
<= stop_offset
* opb
)
2802 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2804 for (k
= bpc
- 1; k
>= 0; k
--)
2805 printf ("%02x", (unsigned) data
[j
+ k
]);
2809 for (k
= 0; k
< bpc
; k
++)
2810 printf ("%02x", (unsigned) data
[j
+ k
]);
2816 for (; pb
< octets_per_line
; pb
+= bpc
)
2820 for (k
= 0; k
< bpc
; k
++)
2825 /* Separate raw data from instruction by extra space. */
2835 printf ("%s", sfile
.buffer
);
2837 if (prefix_addresses
2839 : show_raw_insn
>= 0)
2847 j
= addr_offset
* opb
+ pb
;
2849 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2850 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2854 printf ("%s:\t", buf
+ skip_addr_chars
);
2856 pb
+= octets_per_line
;
2859 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2861 /* PR 21619: Check for a buffer ending early. */
2862 if (j
+ bpc
<= stop_offset
* opb
)
2866 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2868 for (k
= bpc
- 1; k
>= 0; k
--)
2869 printf ("%02x", (unsigned) data
[j
+ k
]);
2873 for (k
= 0; k
< bpc
; k
++)
2874 printf ("%02x", (unsigned) data
[j
+ k
]);
2888 while ((*relppp
) < relppend
2889 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2891 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2902 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2905 if (q
->howto
== NULL
)
2906 printf (": *unknown*\t");
2907 else if (q
->howto
->name
)
2908 printf (": %s\t", q
->howto
->name
);
2910 printf (": %d\t", q
->howto
->type
);
2912 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2913 printf ("*unknown*");
2916 const char *sym_name
;
2918 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2919 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2920 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2925 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2926 sym_name
= bfd_section_name (sym_sec
);
2927 if (sym_name
== NULL
|| *sym_name
== '\0')
2928 sym_name
= "*unknown*";
2929 printf ("%s", sanitize_string (sym_name
));
2935 bfd_signed_vma addend
= q
->addend
;
2943 objdump_print_value (addend
, inf
, TRUE
);
2955 addr_offset
+= octets
/ opb
;
2958 free (sfile
.buffer
);
2960 free (color_buffer
);
2964 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2966 const struct elf_backend_data
* bed
;
2967 bfd_vma sign_adjust
= 0;
2968 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2969 struct objdump_disasm_info
* paux
;
2970 unsigned int opb
= pinfo
->octets_per_byte
;
2971 bfd_byte
* data
= NULL
;
2972 bfd_size_type datasize
= 0;
2973 arelent
** rel_pp
= NULL
;
2974 arelent
** rel_ppstart
= NULL
;
2975 arelent
** rel_ppend
;
2976 bfd_vma stop_offset
;
2977 asymbol
* sym
= NULL
;
2981 unsigned long addr_offset
;
2982 bfd_boolean do_print
;
2985 stop_offset_reached
,
2990 /* Sections that do not contain machine
2991 code are not normally disassembled. */
2992 if (! disassemble_all
2993 && only_list
== NULL
2994 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2995 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2998 if (! process_section_p (section
))
3001 datasize
= bfd_section_size (section
);
3005 if (start_address
== (bfd_vma
) -1
3006 || start_address
< section
->vma
)
3009 addr_offset
= start_address
- section
->vma
;
3011 if (stop_address
== (bfd_vma
) -1)
3012 stop_offset
= datasize
/ opb
;
3015 if (stop_address
< section
->vma
)
3018 stop_offset
= stop_address
- section
->vma
;
3019 if (stop_offset
> datasize
/ opb
)
3020 stop_offset
= datasize
/ opb
;
3023 if (addr_offset
>= stop_offset
)
3026 /* Decide which set of relocs to use. Load them if necessary. */
3027 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3028 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3030 rel_pp
= paux
->dynrelbuf
;
3031 rel_count
= paux
->dynrelcount
;
3032 /* Dynamic reloc addresses are absolute, non-dynamic are section
3033 relative. REL_OFFSET specifies the reloc address corresponding
3034 to the start of this section. */
3035 rel_offset
= section
->vma
;
3043 if ((section
->flags
& SEC_RELOC
) != 0
3044 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3048 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3050 bfd_fatal (bfd_get_filename (abfd
));
3054 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3055 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3057 bfd_fatal (bfd_get_filename (abfd
));
3059 /* Sort the relocs by address. */
3060 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3064 rel_ppend
= rel_pp
+ rel_count
;
3066 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3068 non_fatal (_("Reading section %s failed because: %s"),
3069 section
->name
, bfd_errmsg (bfd_get_error ()));
3073 pinfo
->buffer
= data
;
3074 pinfo
->buffer_vma
= section
->vma
;
3075 pinfo
->buffer_length
= datasize
;
3076 pinfo
->section
= section
;
3078 /* Sort the symbols into value and section order. */
3079 compare_section
= section
;
3080 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3082 /* Skip over the relocs belonging to addresses below the
3084 while (rel_pp
< rel_ppend
3085 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3088 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3090 /* Find the nearest symbol forwards from our current position. */
3091 paux
->require_sec
= TRUE
;
3092 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3093 (struct disassemble_info
*) inf
,
3095 paux
->require_sec
= FALSE
;
3097 /* PR 9774: If the target used signed addresses then we must make
3098 sure that we sign extend the value that we calculate for 'addr'
3099 in the loop below. */
3100 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3101 && (bed
= get_elf_backend_data (abfd
)) != NULL
3102 && bed
->sign_extend_vma
)
3103 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3105 /* Disassemble a block of instructions up to the address associated with
3106 the symbol we have just found. Then print the symbol and find the
3107 next symbol on. Repeat until we have disassembled the entire section
3108 or we have reached the end of the address range we are interested in. */
3109 do_print
= paux
->symbol
== NULL
;
3110 loop_until
= stop_offset_reached
;
3112 while (addr_offset
< stop_offset
)
3116 bfd_vma nextstop_offset
;
3119 addr
= section
->vma
+ addr_offset
;
3120 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3122 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3127 (x
< sorted_symcount
3128 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3132 pinfo
->symbols
= sorted_syms
+ place
;
3133 pinfo
->num_symbols
= x
- place
;
3134 pinfo
->symtab_pos
= place
;
3138 pinfo
->symbols
= NULL
;
3139 pinfo
->num_symbols
= 0;
3140 pinfo
->symtab_pos
= -1;
3143 /* If we are only disassembling from a specific symbol,
3144 check to see if we should start or stop displaying. */
3145 if (sym
&& paux
->symbol
)
3149 /* See if we should stop printing. */
3153 if (sym
->flags
& BSF_FUNCTION
)
3157 case stop_offset_reached
:
3158 /* Handled by the while loop. */
3162 /* FIXME: There is an implicit assumption here
3163 that the name of sym is different from
3165 if (! bfd_is_local_label (abfd
, sym
))
3172 const char * name
= bfd_asymbol_name (sym
);
3173 char * alloc
= NULL
;
3175 if (do_demangle
&& name
[0] != '\0')
3177 /* Demangle the name. */
3178 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3183 /* We are not currently printing. Check to see
3184 if the current symbol matches the requested symbol. */
3185 if (streq (name
, paux
->symbol
))
3189 if (sym
->flags
& BSF_FUNCTION
)
3191 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3192 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3194 /* Sym is a function symbol with a size associated
3195 with it. Turn on automatic disassembly for the
3196 next VALUE bytes. */
3197 stop_offset
= addr_offset
3198 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3199 loop_until
= stop_offset_reached
;
3203 /* Otherwise we need to tell the loop heuristic to
3204 loop until the next function symbol is encountered. */
3205 loop_until
= function_sym
;
3210 /* Otherwise loop until the next symbol is encountered. */
3211 loop_until
= next_sym
;
3219 if (! prefix_addresses
&& do_print
)
3221 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3222 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3224 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3227 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3229 else if (sym
== NULL
)
3233 #define is_valid_next_sym(SYM) \
3234 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3235 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3236 && pinfo->symbol_is_valid (SYM, pinfo))
3238 /* Search forward for the next appropriate symbol in
3239 SECTION. Note that all the symbols are sorted
3240 together into one big array, and that some sections
3241 may have overlapping addresses. */
3242 while (place
< sorted_symcount
3243 && ! is_valid_next_sym (sorted_syms
[place
]))
3246 if (place
>= sorted_symcount
)
3249 nextsym
= sorted_syms
[place
];
3252 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3253 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3254 else if (nextsym
== NULL
)
3255 nextstop_offset
= stop_offset
;
3257 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3259 if (nextstop_offset
> stop_offset
3260 || nextstop_offset
<= addr_offset
)
3261 nextstop_offset
= stop_offset
;
3263 /* If a symbol is explicitly marked as being an object
3264 rather than a function, just dump the bytes without
3265 disassembling them. */
3268 || sym
->section
!= section
3269 || bfd_asymbol_value (sym
) > addr
3270 || ((sym
->flags
& BSF_OBJECT
) == 0
3271 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3273 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3275 || (sym
->flags
& BSF_FUNCTION
) != 0)
3282 /* Resolve symbol name. */
3283 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3285 struct disassemble_info di
;
3288 sf
.alloc
= strlen (sym
->name
) + 40;
3289 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3291 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3294 objdump_print_symname (abfd
, &di
, sym
);
3296 /* Fetch jump information. */
3297 detected_jumps
= disassemble_jumps
3298 (pinfo
, paux
->disassemble_fn
,
3299 addr_offset
, nextstop_offset
,
3300 rel_offset
, &rel_pp
, rel_ppend
);
3302 /* Free symbol name. */
3306 /* Add jumps to output. */
3307 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3308 addr_offset
, nextstop_offset
,
3309 rel_offset
, &rel_pp
, rel_ppend
);
3312 while (detected_jumps
)
3314 detected_jumps
= jump_info_free (detected_jumps
);
3318 addr_offset
= nextstop_offset
;
3324 if (rel_ppstart
!= NULL
)
3328 /* Disassemble the contents of an object file. */
3331 disassemble_data (bfd
*abfd
)
3333 struct disassemble_info disasm_info
;
3334 struct objdump_disasm_info aux
;
3338 prev_functionname
= NULL
;
3340 prev_discriminator
= 0;
3342 /* We make a copy of syms to sort. We don't want to sort syms
3343 because that will screw up the relocs. */
3344 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3345 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3346 * sizeof (asymbol
*));
3347 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3348 sorted_symcount
* sizeof (asymbol
*));
3350 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3352 for (i
= 0; i
< synthcount
; ++i
)
3354 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3358 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3360 disasm_info
.application_data
= (void *) &aux
;
3362 aux
.require_sec
= FALSE
;
3363 aux
.dynrelbuf
= NULL
;
3364 aux
.dynrelcount
= 0;
3366 aux
.symbol
= disasm_sym
;
3368 disasm_info
.print_address_func
= objdump_print_address
;
3369 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3371 if (machine
!= NULL
)
3373 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3376 fatal (_("can't use supplied machine %s"), machine
);
3378 abfd
->arch_info
= inf
;
3381 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3383 struct bfd_target
*xvec
;
3385 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3386 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3387 xvec
->byteorder
= endian
;
3391 /* Use libopcodes to locate a suitable disassembler. */
3392 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3393 bfd_big_endian (abfd
),
3394 bfd_get_mach (abfd
), abfd
);
3395 if (!aux
.disassemble_fn
)
3397 non_fatal (_("can't disassemble for architecture %s\n"),
3398 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3403 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3404 disasm_info
.arch
= bfd_get_arch (abfd
);
3405 disasm_info
.mach
= bfd_get_mach (abfd
);
3406 disasm_info
.disassembler_options
= disassembler_options
;
3407 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3408 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3409 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3410 disasm_info
.disassembler_needs_relocs
= FALSE
;
3412 if (bfd_big_endian (abfd
))
3413 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3414 else if (bfd_little_endian (abfd
))
3415 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3417 /* ??? Aborting here seems too drastic. We could default to big or little
3419 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3421 /* Allow the target to customize the info structure. */
3422 disassemble_init_for_target (& disasm_info
);
3424 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3426 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3428 if (relsize
< 0 && dump_dynamic_reloc_info
)
3429 bfd_fatal (bfd_get_filename (abfd
));
3433 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3434 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3437 if (aux
.dynrelcount
< 0)
3438 bfd_fatal (bfd_get_filename (abfd
));
3440 /* Sort the relocs by address. */
3441 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3445 disasm_info
.symtab
= sorted_syms
;
3446 disasm_info
.symtab_size
= sorted_symcount
;
3448 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3450 if (aux
.dynrelbuf
!= NULL
)
3451 free (aux
.dynrelbuf
);
3453 disassemble_free_target (&disasm_info
);
3457 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3458 asection
*sec
, void *file
)
3460 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3461 bfd
*abfd
= (bfd
*) file
;
3466 if (section
->start
!= NULL
)
3468 /* If it is already loaded, do nothing. */
3469 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3471 free (section
->start
);
3474 section
->filename
= bfd_get_filename (abfd
);
3475 section
->reloc_info
= NULL
;
3476 section
->num_relocs
= 0;
3477 section
->address
= bfd_section_vma (sec
);
3478 section
->user_data
= sec
;
3479 section
->size
= bfd_section_size (sec
);
3480 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3481 alloced
= amt
= section
->size
+ 1;
3482 if (alloced
!= amt
|| alloced
== 0)
3484 section
->start
= NULL
;
3485 free_debug_section (debug
);
3486 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3487 sanitize_string (section
->name
),
3488 (unsigned long long) section
->size
);
3491 section
->start
= contents
= malloc (alloced
);
3492 if (section
->start
== NULL
3493 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3495 free_debug_section (debug
);
3496 printf (_("\nCan't get contents for section '%s'.\n"),
3497 sanitize_string (section
->name
));
3500 /* Ensure any string section has a terminating NUL. */
3501 section
->start
[section
->size
] = 0;
3503 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3504 && debug_displays
[debug
].relocate
)
3509 bfd_cache_section_contents (sec
, section
->start
);
3511 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3518 free_debug_section (debug
);
3519 printf (_("\nCan't get contents for section '%s'.\n"),
3520 sanitize_string (section
->name
));
3524 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3527 unsigned long reloc_count
;
3530 relocs
= (arelent
**) xmalloc (reloc_size
);
3532 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3533 if (reloc_count
== 0)
3537 section
->reloc_info
= relocs
;
3538 section
->num_relocs
= reloc_count
;
3547 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3552 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3555 relocs
= (arelent
**) dsec
->reloc_info
;
3557 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3558 if (rp
->address
== offset
)
3565 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3567 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3568 bfd
*abfd
= (bfd
*) file
;
3571 /* If it is already loaded, do nothing. */
3572 if (section
->start
!= NULL
)
3574 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3578 /* Locate the debug section. */
3579 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3581 section
->name
= section
->uncompressed_name
;
3584 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3586 section
->name
= section
->compressed_name
;
3591 return load_specific_debug_section (debug
, sec
, file
);
3595 free_debug_section (enum dwarf_section_display_enum debug
)
3597 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3599 if (section
->start
== NULL
)
3602 /* PR 17512: file: 0f67f69d. */
3603 if (section
->user_data
!= NULL
)
3605 asection
* sec
= (asection
*) section
->user_data
;
3607 /* If we are freeing contents that are also pointed to by the BFD
3608 library's section structure then make sure to update those pointers
3609 too. Otherwise, the next time we try to load data for this section
3610 we can end up using a stale pointer. */
3611 if (section
->start
== sec
->contents
)
3613 sec
->contents
= NULL
;
3614 sec
->flags
&= ~ SEC_IN_MEMORY
;
3615 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3619 free ((char *) section
->start
);
3620 section
->start
= NULL
;
3621 section
->address
= 0;
3626 close_debug_file (void * file
)
3628 bfd
* abfd
= (bfd
*) file
;
3634 open_debug_file (const char * pathname
)
3638 data
= bfd_openr (pathname
, NULL
);
3642 if (! bfd_check_format (data
, bfd_object
))
3648 #if HAVE_LIBDEBUGINFOD
3649 /* Return a hex string represention of the build-id. */
3652 get_build_id (void * data
)
3655 char * build_id_str
;
3656 bfd
* abfd
= (bfd
*) data
;
3657 const struct bfd_build_id
* build_id
;
3659 build_id
= abfd
->build_id
;
3660 if (build_id
== NULL
)
3663 build_id_str
= malloc (build_id
->size
* 2 + 1);
3664 if (build_id_str
== NULL
)
3667 for (i
= 0; i
< build_id
->size
; i
++)
3668 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3669 build_id_str
[build_id
->size
* 2] = '\0';
3671 return (unsigned char *)build_id_str
;
3673 #endif /* HAVE_LIBDEBUGINFOD */
3676 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3677 void *arg ATTRIBUTE_UNUSED
)
3679 const char *name
= bfd_section_name (section
);
3683 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3684 match
= ".debug_info";
3688 for (i
= 0; i
< max
; i
++)
3689 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3690 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3691 && debug_displays
[i
].enabled
!= NULL
3692 && *debug_displays
[i
].enabled
)
3694 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3696 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3697 sec
->name
= sec
->uncompressed_name
;
3699 sec
->name
= sec
->compressed_name
;
3700 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3703 debug_displays
[i
].display (sec
, abfd
);
3705 if (i
!= info
&& i
!= abbrev
)
3706 free_debug_section ((enum dwarf_section_display_enum
) i
);
3712 /* Dump the dwarf debugging information. */
3715 dump_dwarf (bfd
*abfd
)
3717 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3718 if (byte_get
== NULL
)
3720 warn (_("File %s does not contain any dwarf debug information\n"),
3721 bfd_get_filename (abfd
));
3725 switch (bfd_get_arch (abfd
))
3728 /* S12Z has a 24 bit address space. But the only known
3729 producer of dwarf_info encodes addresses into 32 bits. */
3734 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3738 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3739 bfd_get_mach (abfd
));
3741 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3744 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3745 it. Return NULL on failure. */
3748 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3749 bfd_size_type
*entsize_ptr
)
3754 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3755 if (stabsect
== NULL
)
3757 printf (_("No %s section present\n\n"),
3758 sanitize_string (sect_name
));
3762 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3764 non_fatal (_("reading %s section of %s failed: %s"),
3765 sect_name
, bfd_get_filename (abfd
),
3766 bfd_errmsg (bfd_get_error ()));
3772 *size_ptr
= bfd_section_size (stabsect
);
3774 *entsize_ptr
= stabsect
->entsize
;
3779 /* Stabs entries use a 12 byte format:
3780 4 byte string table index
3782 1 byte stab other field
3783 2 byte stab desc field
3785 FIXME: This will have to change for a 64 bit object format. */
3787 #define STRDXOFF (0)
3789 #define OTHEROFF (5)
3792 #define STABSIZE (12)
3794 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3795 using string table section STRSECT_NAME (in `strtab'). */
3798 print_section_stabs (bfd
*abfd
,
3799 const char *stabsect_name
,
3800 unsigned *string_offset_ptr
)
3803 unsigned file_string_table_offset
= 0;
3804 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3805 bfd_byte
*stabp
, *stabs_end
;
3808 stabs_end
= stabp
+ stab_size
;
3810 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3811 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3813 /* Loop through all symbols and print them.
3815 We start the index at -1 because there is a dummy symbol on
3816 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3817 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3821 unsigned char type
, other
;
3822 unsigned short desc
;
3825 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3826 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3827 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3828 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3829 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3831 printf ("\n%-6d ", i
);
3832 /* Either print the stab name, or, if unnamed, print its number
3833 again (makes consistent formatting for tools like awk). */
3834 name
= bfd_get_stab_name (type
);
3836 printf ("%-6s", sanitize_string (name
));
3837 else if (type
== N_UNDF
)
3840 printf ("%-6d", type
);
3841 printf (" %-6d %-6d ", other
, desc
);
3842 bfd_printf_vma (abfd
, value
);
3843 printf (" %-6lu", strx
);
3845 /* Symbols with type == 0 (N_UNDF) specify the length of the
3846 string table associated with this file. We use that info
3847 to know how to relocate the *next* file's string table indices. */
3850 file_string_table_offset
= next_file_string_table_offset
;
3851 next_file_string_table_offset
+= value
;
3855 bfd_size_type amt
= strx
+ file_string_table_offset
;
3857 /* Using the (possibly updated) string table offset, print the
3858 string (if any) associated with this symbol. */
3859 if (amt
< stabstr_size
)
3860 /* PR 17512: file: 079-79389-0.001:0.1.
3861 FIXME: May need to sanitize this string before displaying. */
3862 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3868 *string_offset_ptr
= next_file_string_table_offset
;
3873 const char * section_name
;
3874 const char * string_section_name
;
3875 unsigned string_offset
;
3880 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3883 stab_section_names
* sought
= (stab_section_names
*) names
;
3885 /* Check for section names for which stabsect_name is a prefix, to
3886 handle .stab.N, etc. */
3887 len
= strlen (sought
->section_name
);
3889 /* If the prefix matches, and the files section name ends with a
3890 nul or a digit, then we match. I.e., we want either an exact
3891 match or a section followed by a number. */
3892 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3893 && (section
->name
[len
] == 0
3894 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3897 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3898 &stabstr_size
, NULL
);
3902 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3904 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3910 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3912 stab_section_names s
;
3914 s
.section_name
= stabsect_name
;
3915 s
.string_section_name
= strsect_name
;
3916 s
.string_offset
= 0;
3918 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3924 /* Dump the any sections containing stabs debugging information. */
3927 dump_stabs (bfd
*abfd
)
3929 dump_stabs_section (abfd
, ".stab", ".stabstr");
3930 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3931 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3934 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3936 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3940 dump_bfd_header (bfd
*abfd
)
3944 printf (_("architecture: %s, "),
3945 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3946 bfd_get_mach (abfd
)));
3947 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3949 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
3950 PF (HAS_RELOC
, "HAS_RELOC");
3951 PF (EXEC_P
, "EXEC_P");
3952 PF (HAS_LINENO
, "HAS_LINENO");
3953 PF (HAS_DEBUG
, "HAS_DEBUG");
3954 PF (HAS_SYMS
, "HAS_SYMS");
3955 PF (HAS_LOCALS
, "HAS_LOCALS");
3956 PF (DYNAMIC
, "DYNAMIC");
3957 PF (WP_TEXT
, "WP_TEXT");
3958 PF (D_PAGED
, "D_PAGED");
3959 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3960 printf (_("\nstart address 0x"));
3961 bfd_printf_vma (abfd
, abfd
->start_address
);
3966 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3967 it is passed, or a pointer to newly-allocated storage, in which case
3968 dump_ctf() will free it when it no longer needs it. */
3971 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3974 const char *blanks
= arg
;
3977 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3982 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3984 make_ctfsect (const char *name
, bfd_byte
*data
,
3989 ctfsect
.cts_name
= name
;
3990 ctfsect
.cts_entsize
= 1;
3991 ctfsect
.cts_size
= size
;
3992 ctfsect
.cts_data
= data
;
3997 /* Dump one CTF archive member. */
4000 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4002 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4003 const char *things
[] = {"Header", "Labels", "Data objects",
4004 "Function objects", "Variables", "Types", "Strings",
4009 /* Only print out the name of non-default-named archive members.
4010 The name .ctf appears everywhere, even for things that aren't
4011 really archives, so printing it out is liable to be confusing.
4013 The parent, if there is one, is the default-owned archive member:
4014 avoid importing it into itself. (This does no harm, but looks
4017 if (strcmp (name
, ".ctf") != 0)
4019 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4020 ctf_import (ctf
, parent
);
4023 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4025 ctf_dump_state_t
*s
= NULL
;
4028 printf ("\n %s:\n", *thing
);
4029 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4030 (void *) " ")) != NULL
)
4032 printf ("%s\n", item
);
4036 if (ctf_errno (ctf
))
4038 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4039 ctf_errmsg (ctf_errno (ctf
)));
4046 /* Dump the CTF debugging information. */
4049 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4051 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4052 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4053 bfd_size_type ctfsize
, parentsize
;
4055 ctf_file_t
*parent
= NULL
;
4058 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4059 bfd_fatal (bfd_get_filename (abfd
));
4062 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4064 bfd_fatal (bfd_get_filename (abfd
));
4066 /* Load the CTF file and dump it. */
4068 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4069 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4071 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4072 bfd_fatal (bfd_get_filename (abfd
));
4077 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4078 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4080 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4081 bfd_fatal (bfd_get_filename (abfd
));
4084 lookparent
= parenta
;
4089 /* Assume that the applicable parent archive member is the default one.
4090 (This is what all known implementations are expected to do, if they
4091 put CTFs and their parents in archives together.) */
4092 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4094 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4095 bfd_fatal (bfd_get_filename (abfd
));
4098 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4100 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4101 ctf_file_close (parent
);
4103 ctf_close (parenta
);
4110 dump_bfd_private_header (bfd
*abfd
)
4112 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4113 non_fatal (_("warning: private headers incomplete: %s"),
4114 bfd_errmsg (bfd_get_error ()));
4118 dump_target_specific (bfd
*abfd
)
4120 const struct objdump_private_desc
* const *desc
;
4121 struct objdump_private_option
*opt
;
4124 /* Find the desc. */
4125 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4126 if ((*desc
)->filter (abfd
))
4131 non_fatal (_("option -P/--private not supported by this file"));
4135 /* Clear all options. */
4136 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4137 opt
->selected
= FALSE
;
4139 /* Decode options. */
4140 b
= dump_private_options
;
4143 e
= strchr (b
, ',');
4148 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4149 if (strcmp (opt
->name
, b
) == 0)
4151 opt
->selected
= TRUE
;
4154 if (opt
->name
== NULL
)
4155 non_fatal (_("target specific dump '%s' not supported"), b
);
4166 (*desc
)->dump (abfd
);
4169 /* Display a section in hexadecimal format with associated characters.
4170 Each line prefixed by the zero padded address. */
4173 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4175 bfd_byte
*data
= NULL
;
4176 bfd_size_type datasize
;
4177 bfd_vma addr_offset
;
4178 bfd_vma start_offset
;
4179 bfd_vma stop_offset
;
4180 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4181 /* Bytes per line. */
4182 const int onaline
= 16;
4187 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4190 if (! process_section_p (section
))
4193 if ((datasize
= bfd_section_size (section
)) == 0)
4196 /* Compute the address range to display. */
4197 if (start_address
== (bfd_vma
) -1
4198 || start_address
< section
->vma
)
4201 start_offset
= start_address
- section
->vma
;
4203 if (stop_address
== (bfd_vma
) -1)
4204 stop_offset
= datasize
/ opb
;
4207 if (stop_address
< section
->vma
)
4210 stop_offset
= stop_address
- section
->vma
;
4212 if (stop_offset
> datasize
/ opb
)
4213 stop_offset
= datasize
/ opb
;
4216 if (start_offset
>= stop_offset
)
4219 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4220 if (display_file_offsets
)
4221 printf (_(" (Starting at file offset: 0x%lx)"),
4222 (unsigned long) (section
->filepos
+ start_offset
));
4225 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4227 non_fatal (_("Reading section %s failed because: %s"),
4228 section
->name
, bfd_errmsg (bfd_get_error ()));
4234 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4235 if (strlen (buf
) >= sizeof (buf
))
4239 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4241 count
= strlen (buf
) - count
;
4245 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4246 if (strlen (buf
) >= sizeof (buf
))
4250 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4252 count
= strlen (buf
) - count
;
4256 for (addr_offset
= start_offset
;
4257 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4261 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4262 count
= strlen (buf
);
4263 if ((size_t) count
>= sizeof (buf
))
4267 while (count
< width
)
4272 fputs (buf
+ count
- width
, stdout
);
4275 for (j
= addr_offset
* opb
;
4276 j
< addr_offset
* opb
+ onaline
; j
++)
4278 if (j
< stop_offset
* opb
)
4279 printf ("%02x", (unsigned) (data
[j
]));
4287 for (j
= addr_offset
* opb
;
4288 j
< addr_offset
* opb
+ onaline
; j
++)
4290 if (j
>= stop_offset
* opb
)
4293 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4300 /* Actually display the various requested regions. */
4303 dump_data (bfd
*abfd
)
4305 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4308 /* Should perhaps share code and display with nm? */
4311 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4320 max_count
= dynsymcount
;
4321 printf ("DYNAMIC SYMBOL TABLE:\n");
4326 max_count
= symcount
;
4327 printf ("SYMBOL TABLE:\n");
4331 printf (_("no symbols\n"));
4333 for (count
= 0; count
< max_count
; count
++)
4337 if (*current
== NULL
)
4338 printf (_("no information for symbol number %ld\n"), count
);
4340 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4341 printf (_("could not determine the type of symbol number %ld\n"),
4344 else if (process_section_p ((* current
)->section
)
4345 && (dump_special_syms
4346 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4348 const char *name
= (*current
)->name
;
4350 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4354 /* If we want to demangle the name, we demangle it
4355 here, and temporarily clobber it while calling
4356 bfd_print_symbol. FIXME: This is a gross hack. */
4357 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4359 (*current
)->name
= alloc
;
4360 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4361 bfd_print_symbol_all
);
4364 (*current
)->name
= name
;
4369 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4370 bfd_print_symbol_all
);
4380 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4383 char *last_filename
, *last_functionname
;
4384 unsigned int last_line
;
4385 unsigned int last_discriminator
;
4387 /* Get column headers lined up reasonably. */
4395 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4396 width
= strlen (buf
) - 7;
4398 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4401 last_filename
= NULL
;
4402 last_functionname
= NULL
;
4404 last_discriminator
= 0;
4406 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4409 const char *filename
, *functionname
;
4410 unsigned int linenumber
;
4411 unsigned int discriminator
;
4412 const char *sym_name
;
4413 const char *section_name
;
4414 bfd_vma addend2
= 0;
4416 if (start_address
!= (bfd_vma
) -1
4417 && q
->address
< start_address
)
4419 if (stop_address
!= (bfd_vma
) -1
4420 && q
->address
> stop_address
)
4423 if (with_line_numbers
4425 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4426 &filename
, &functionname
,
4427 &linenumber
, &discriminator
))
4429 if (functionname
!= NULL
4430 && (last_functionname
== NULL
4431 || strcmp (functionname
, last_functionname
) != 0))
4433 printf ("%s():\n", sanitize_string (functionname
));
4434 if (last_functionname
!= NULL
)
4435 free (last_functionname
);
4436 last_functionname
= xstrdup (functionname
);
4440 && (linenumber
!= last_line
4441 || (filename
!= NULL
4442 && last_filename
!= NULL
4443 && filename_cmp (filename
, last_filename
) != 0)
4444 || (discriminator
!= last_discriminator
)))
4446 if (discriminator
> 0)
4447 printf ("%s:%u\n", filename
== NULL
? "???" :
4448 sanitize_string (filename
), linenumber
);
4450 printf ("%s:%u (discriminator %u)\n",
4451 filename
== NULL
? "???" : sanitize_string (filename
),
4452 linenumber
, discriminator
);
4453 last_line
= linenumber
;
4454 last_discriminator
= discriminator
;
4455 if (last_filename
!= NULL
)
4456 free (last_filename
);
4457 if (filename
== NULL
)
4458 last_filename
= NULL
;
4460 last_filename
= xstrdup (filename
);
4464 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4466 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4467 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4472 section_name
= NULL
;
4475 bfd_printf_vma (abfd
, q
->address
);
4476 if (q
->howto
== NULL
)
4477 printf (" *unknown* ");
4478 else if (q
->howto
->name
)
4480 const char *name
= q
->howto
->name
;
4482 /* R_SPARC_OLO10 relocations contain two addends.
4483 But because 'arelent' lacks enough storage to
4484 store them both, the 64-bit ELF Sparc backend
4485 records this as two relocations. One R_SPARC_LO10
4486 and one R_SPARC_13, both pointing to the same
4487 address. This is merely so that we have some
4488 place to store both addend fields.
4490 Undo this transformation, otherwise the output
4491 will be confusing. */
4492 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4493 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4495 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4497 arelent
*q2
= *(p
+ 1);
4500 && q
->address
== q2
->address
4501 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4503 name
= "R_SPARC_OLO10";
4504 addend2
= q2
->addend
;
4508 printf (" %-16s ", name
);
4511 printf (" %-16d ", q
->howto
->type
);
4515 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4519 if (section_name
== NULL
)
4520 section_name
= "*unknown*";
4521 printf ("[%s]", sanitize_string (section_name
));
4526 bfd_signed_vma addend
= q
->addend
;
4534 bfd_printf_vma (abfd
, addend
);
4539 bfd_printf_vma (abfd
, addend2
);
4545 if (last_filename
!= NULL
)
4546 free (last_filename
);
4547 if (last_functionname
!= NULL
)
4548 free (last_functionname
);
4552 dump_relocs_in_section (bfd
*abfd
,
4554 void *dummy ATTRIBUTE_UNUSED
)
4556 arelent
**relpp
= NULL
;
4560 if ( bfd_is_abs_section (section
)
4561 || bfd_is_und_section (section
)
4562 || bfd_is_com_section (section
)
4563 || (! process_section_p (section
))
4564 || ((section
->flags
& SEC_RELOC
) == 0))
4567 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4569 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4572 printf (" (none)\n\n");
4580 relpp
= (arelent
**) xmalloc (relsize
);
4581 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4587 non_fatal (_("failed to read relocs in: %s"),
4588 sanitize_string (bfd_get_filename (abfd
)));
4589 bfd_fatal (_("error message was"));
4591 else if (relcount
== 0)
4592 printf (" (none)\n\n");
4596 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4603 dump_relocs (bfd
*abfd
)
4605 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4609 dump_dynamic_relocs (bfd
*abfd
)
4615 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4617 bfd_fatal (bfd_get_filename (abfd
));
4619 printf ("DYNAMIC RELOCATION RECORDS");
4622 printf (" (none)\n\n");
4625 relpp
= (arelent
**) xmalloc (relsize
);
4626 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4629 bfd_fatal (bfd_get_filename (abfd
));
4630 else if (relcount
== 0)
4631 printf (" (none)\n\n");
4635 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4642 /* Creates a table of paths, to search for source files. */
4645 add_include_path (const char *path
)
4649 include_path_count
++;
4650 include_paths
= (const char **)
4651 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4652 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4653 if (path
[1] == ':' && path
[2] == 0)
4654 path
= concat (path
, ".", (const char *) 0);
4656 include_paths
[include_path_count
- 1] = path
;
4660 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4664 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4666 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4667 section
->vma
+= adjust_section_vma
;
4669 section
->lma
+= adjust_section_vma
;
4673 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4676 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4681 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4682 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4685 /* Dump selected contents of ABFD. */
4688 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4690 const struct elf_backend_data
* bed
;
4692 if (bfd_big_endian (abfd
))
4693 byte_get
= byte_get_big_endian
;
4694 else if (bfd_little_endian (abfd
))
4695 byte_get
= byte_get_little_endian
;
4699 /* Load any separate debug information files.
4700 We do this now and without checking do_follow_links because separate
4701 debug info files may contain symbol tables that we will need when
4702 displaying information about the main file. Any memory allocated by
4703 load_separate_debug_files will be released when we call
4704 free_debug_memory below.
4706 The test on is_mainfile is there because the chain of separate debug
4707 info files is a global variable shared by all invocations of dump_bfd. */
4710 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4712 /* If asked to do so, recursively dump the separate files. */
4713 if (do_follow_links
)
4717 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4718 dump_bfd (i
->handle
, FALSE
);
4722 /* Adjust user-specified start and stop limits for targets that use
4723 signed addresses. */
4724 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4725 && (bed
= get_elf_backend_data (abfd
)) != NULL
4726 && bed
->sign_extend_vma
)
4728 start_address
= sign_extend_address (abfd
, start_address
,
4730 stop_address
= sign_extend_address (abfd
, stop_address
,
4734 /* If we are adjusting section VMA's, change them all now. Changing
4735 the BFD information is a hack. However, we must do it, or
4736 bfd_find_nearest_line will not do the right thing. */
4737 if (adjust_section_vma
!= 0)
4739 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4740 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4743 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4744 printf (_("\n%s: file format %s\n"),
4745 sanitize_string (bfd_get_filename (abfd
)),
4748 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4749 if (dump_file_header
)
4750 dump_bfd_header (abfd
);
4751 if (dump_private_headers
)
4752 dump_bfd_private_header (abfd
);
4753 if (dump_private_options
!= NULL
)
4754 dump_target_specific (abfd
);
4755 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4762 || dump_dwarf_section_info
)
4764 syms
= slurp_symtab (abfd
);
4766 /* If following links, load any symbol tables from the linked files as well. */
4767 if (do_follow_links
&& is_mainfile
)
4771 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4773 asymbol
** extra_syms
;
4774 long old_symcount
= symcount
;
4776 extra_syms
= slurp_symtab (i
->handle
);
4780 if (old_symcount
== 0)
4786 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4787 memcpy (syms
+ old_symcount
,
4789 symcount
* sizeof (asymbol
*));
4793 symcount
+= old_symcount
;
4798 if (dump_section_headers
)
4799 dump_headers (abfd
);
4801 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4802 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4803 dynsyms
= slurp_dynamic_symtab (abfd
);
4807 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4808 dynsymcount
, dynsyms
, &synthsyms
);
4814 dump_symbols (abfd
, FALSE
);
4815 if (dump_dynamic_symtab
)
4816 dump_symbols (abfd
, TRUE
);
4817 if (dump_dwarf_section_info
)
4819 if (dump_ctf_section_info
)
4820 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4821 if (dump_stab_section_info
)
4823 if (dump_reloc_info
&& ! disassemble
)
4825 if (dump_dynamic_reloc_info
&& ! disassemble
)
4826 dump_dynamic_relocs (abfd
);
4827 if (dump_section_contents
)
4830 disassemble_data (abfd
);
4836 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4837 if (dhandle
!= NULL
)
4839 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4841 dump_debugging_tags
? TRUE
: FALSE
))
4843 non_fatal (_("%s: printing debugging information failed"),
4844 bfd_get_filename (abfd
));
4850 /* PR 6483: If there was no STABS debug info in the file, try
4852 else if (! dump_dwarf_section_info
)
4854 dwarf_select_sections_all ();
4882 free_debug_memory ();
4886 display_object_bfd (bfd
*abfd
)
4890 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4892 dump_bfd (abfd
, TRUE
);
4896 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4898 nonfatal (bfd_get_filename (abfd
));
4899 list_matching_formats (matching
);
4904 if (bfd_get_error () != bfd_error_file_not_recognized
)
4906 nonfatal (bfd_get_filename (abfd
));
4910 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4912 dump_bfd (abfd
, TRUE
);
4916 nonfatal (bfd_get_filename (abfd
));
4918 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4920 list_matching_formats (matching
);
4926 display_any_bfd (bfd
*file
, int level
)
4928 /* Decompress sections unless dumping the section contents. */
4929 if (!dump_section_contents
)
4930 file
->flags
|= BFD_DECOMPRESS
;
4932 /* If the file is an archive, process all of its elements. */
4933 if (bfd_check_format (file
, bfd_archive
))
4936 bfd
*last_arfile
= NULL
;
4939 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4940 else if (level
> 100)
4942 /* Prevent corrupted files from spinning us into an
4943 infinite loop. 100 is an arbitrary heuristic. */
4944 fatal (_("Archive nesting is too deep"));
4948 printf (_("In nested archive %s:\n"),
4949 sanitize_string (bfd_get_filename (file
)));
4953 bfd_set_error (bfd_error_no_error
);
4955 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4958 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4959 nonfatal (bfd_get_filename (file
));
4963 display_any_bfd (arfile
, level
+ 1);
4965 if (last_arfile
!= NULL
)
4967 bfd_close (last_arfile
);
4968 /* PR 17512: file: ac585d01. */
4969 if (arfile
== last_arfile
)
4975 last_arfile
= arfile
;
4978 if (last_arfile
!= NULL
)
4979 bfd_close (last_arfile
);
4982 display_object_bfd (file
);
4986 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4990 if (get_file_size (filename
) < 1)
4996 file
= bfd_openr (filename
, target
);
4999 nonfatal (filename
);
5003 display_any_bfd (file
, 0);
5005 /* This is an optimization to improve the speed of objdump, especially when
5006 dumping a file with lots of associated debug informatiom. Calling
5007 bfd_close on such a file can take a non-trivial amount of time as there
5008 are lots of lists to walk and buffers to free. This is only really
5009 necessary however if we are about to load another file and we need the
5010 memory back. Otherwise, if we are about to exit, then we can save (a lot
5011 of) time by only doing a quick close, and allowing the OS to reclaim the
5016 bfd_close_all_done (file
);
5020 main (int argc
, char **argv
)
5023 char *target
= default_target
;
5024 bfd_boolean seenflag
= FALSE
;
5026 #if defined (HAVE_SETLOCALE)
5027 #if defined (HAVE_LC_MESSAGES)
5028 setlocale (LC_MESSAGES
, "");
5030 setlocale (LC_CTYPE
, "");
5033 bindtextdomain (PACKAGE
, LOCALEDIR
);
5034 textdomain (PACKAGE
);
5036 program_name
= *argv
;
5037 xmalloc_set_program_name (program_name
);
5038 bfd_set_error_program_name (program_name
);
5040 START_PROGRESS (program_name
, 0);
5042 expandargv (&argc
, &argv
);
5044 if (bfd_init () != BFD_INIT_MAGIC
)
5045 fatal (_("fatal error: libbfd ABI mismatch"));
5046 set_default_bfd_target ();
5048 while ((c
= getopt_long (argc
, argv
,
5049 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5050 long_options
, (int *) 0))
5056 break; /* We've been given a long option. */
5063 if (disassembler_options
)
5064 /* Ignore potential memory leak for now. */
5065 options
= concat (disassembler_options
, ",",
5066 optarg
, (const char *) NULL
);
5069 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5076 display_file_offsets
= TRUE
;
5079 with_line_numbers
= TRUE
;
5088 enum demangling_styles style
;
5090 style
= cplus_demangle_name_to_style (optarg
);
5091 if (style
== unknown_demangling
)
5092 fatal (_("unknown demangling style `%s'"),
5095 cplus_demangle_set_style (style
);
5098 case OPTION_RECURSE_LIMIT
:
5099 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5101 case OPTION_NO_RECURSE_LIMIT
:
5102 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5105 do_wide
= wide_output
= TRUE
;
5107 case OPTION_ADJUST_VMA
:
5108 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5110 case OPTION_START_ADDRESS
:
5111 start_address
= parse_vma (optarg
, "--start-address");
5112 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5113 fatal (_("error: the start address should be before the end address"));
5115 case OPTION_STOP_ADDRESS
:
5116 stop_address
= parse_vma (optarg
, "--stop-address");
5117 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5118 fatal (_("error: the stop address should be after the start address"));
5122 prefix_length
= strlen (prefix
);
5123 /* Remove an unnecessary trailing '/' */
5124 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5127 case OPTION_PREFIX_STRIP
:
5128 prefix_strip
= atoi (optarg
);
5129 if (prefix_strip
< 0)
5130 fatal (_("error: prefix strip must be non-negative"));
5132 case OPTION_INSN_WIDTH
:
5133 insn_width
= strtoul (optarg
, NULL
, 0);
5134 if (insn_width
<= 0)
5135 fatal (_("error: instruction width must be positive"));
5137 case OPTION_INLINES
:
5138 unwind_inlines
= TRUE
;
5140 case OPTION_VISUALIZE_JUMPS
:
5141 visualize_jumps
= TRUE
;
5142 color_output
= FALSE
;
5143 extended_color_output
= FALSE
;
5146 if (streq (optarg
, "color"))
5147 color_output
= TRUE
;
5148 else if (streq (optarg
, "extended-color"))
5150 color_output
= TRUE
;
5151 extended_color_output
= TRUE
;
5153 else if (streq (optarg
, "off"))
5154 visualize_jumps
= FALSE
;
5156 nonfatal (_("unrecognized argument to --visualize-option"));
5160 if (strcmp (optarg
, "B") == 0)
5161 endian
= BFD_ENDIAN_BIG
;
5162 else if (strcmp (optarg
, "L") == 0)
5163 endian
= BFD_ENDIAN_LITTLE
;
5166 nonfatal (_("unrecognized -E option"));
5171 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5172 endian
= BFD_ENDIAN_BIG
;
5173 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5174 endian
= BFD_ENDIAN_LITTLE
;
5177 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5184 dump_file_header
= TRUE
;
5188 formats_info
= TRUE
;
5192 add_include_path (optarg
);
5195 dump_private_headers
= TRUE
;
5199 dump_private_options
= optarg
;
5203 dump_private_headers
= TRUE
;
5205 dump_reloc_info
= TRUE
;
5206 dump_file_header
= TRUE
;
5207 dump_ar_hdrs
= TRUE
;
5208 dump_section_headers
= TRUE
;
5216 dump_dynamic_symtab
= TRUE
;
5222 disasm_sym
= optarg
;
5225 disassemble_zeroes
= TRUE
;
5229 disassemble_all
= TRUE
;
5234 with_source_code
= TRUE
;
5237 case OPTION_SOURCE_COMMENT
:
5239 with_source_code
= TRUE
;
5242 source_comment
= xstrdup (sanitize_string (optarg
));
5244 source_comment
= xstrdup ("# ");
5252 dump_debugging_tags
= 1;
5257 dump_dwarf_section_info
= TRUE
;
5260 dwarf_select_sections_by_letters (optarg
);
5262 dwarf_select_sections_all ();
5265 dump_dwarf_section_info
= TRUE
;
5268 dwarf_select_sections_by_names (optarg
);
5270 dwarf_select_sections_all ();
5272 case OPTION_DWARF_DEPTH
:
5275 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5278 case OPTION_DWARF_START
:
5281 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5282 suppress_bfd_header
= 1;
5285 case OPTION_DWARF_CHECK
:
5289 dump_ctf_section_info
= TRUE
;
5290 dump_ctf_section_name
= xstrdup (optarg
);
5293 case OPTION_CTF_PARENT
:
5294 dump_ctf_parent_name
= xstrdup (optarg
);
5297 dump_stab_section_info
= TRUE
;
5301 dump_section_contents
= TRUE
;
5305 dump_reloc_info
= TRUE
;
5309 dump_dynamic_reloc_info
= TRUE
;
5313 dump_ar_hdrs
= TRUE
;
5317 dump_section_headers
= TRUE
;
5322 show_version
= TRUE
;
5328 /* No need to set seenflag or to break - usage() does not return. */
5335 print_version ("objdump");
5341 exit_status
= display_info ();
5345 display_file ("a.out", target
, TRUE
);
5347 for (; optind
< argc
;)
5349 display_file (argv
[optind
], target
, optind
== argc
- 1);
5355 free (dump_ctf_section_name
);
5356 free (dump_ctf_parent_name
);
5357 free ((void *) source_comment
);
5359 END_PROGRESS (program_name
);