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
, TRUE
,
1037 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1040 name
= sanitize_string (name
);
1044 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1045 if (version_string
&& *version_string
!= '\0')
1046 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1051 printf ("%s", name
);
1052 if (version_string
&& *version_string
!= '\0')
1053 printf (hidden
? "@%s" : "@@%s", version_string
);
1060 static inline bfd_boolean
1061 sym_ok (bfd_boolean want_section
,
1062 bfd
* abfd ATTRIBUTE_UNUSED
,
1065 struct disassemble_info
* inf
)
1069 /* NB: An object file can have different sections with the same
1070 section name. Compare compare section pointers if they have
1072 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1073 && sorted_syms
[place
]->section
!= sec
)
1076 /* Note - we cannot just compare section pointers because they could
1077 be different, but the same... Ie the symbol that we are trying to
1078 find could have come from a separate debug info file. Under such
1079 circumstances the symbol will be associated with a section in the
1080 debug info file, whilst the section we want is in a normal file.
1081 So the section pointers will be different, but the section names
1082 will be the same. */
1083 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1084 bfd_section_name (sec
)) != 0)
1088 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1091 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1092 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1093 require the symbol to be in the section. Returns NULL if there is no
1094 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1095 of the symbol in sorted_syms. */
1098 find_symbol_for_address (bfd_vma vma
,
1099 struct disassemble_info
*inf
,
1102 /* @@ Would it speed things up to cache the last two symbols returned,
1103 and maybe their address ranges? For many processors, only one memory
1104 operand can be present at a time, so the 2-entry cache wouldn't be
1105 constantly churned by code doing heavy memory accesses. */
1107 /* Indices in `sorted_syms'. */
1109 long max_count
= sorted_symcount
;
1111 struct objdump_disasm_info
*aux
;
1115 bfd_boolean want_section
;
1118 if (sorted_symcount
< 1)
1121 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1124 opb
= inf
->octets_per_byte
;
1126 /* Perform a binary search looking for the closest symbol to the
1127 required value. We are searching the range (min, max_count]. */
1128 while (min
+ 1 < max_count
)
1132 thisplace
= (max_count
+ min
) / 2;
1133 sym
= sorted_syms
[thisplace
];
1135 if (bfd_asymbol_value (sym
) > vma
)
1136 max_count
= thisplace
;
1137 else if (bfd_asymbol_value (sym
) < vma
)
1146 /* The symbol we want is now in min, the low end of the range we
1147 were searching. If there are several symbols with the same
1148 value, we want the first one. */
1150 while (thisplace
> 0
1151 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1152 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1155 /* Prefer a symbol in the current section if we have multple symbols
1156 with the same value, as can occur with overlays or zero size
1159 while (min
< max_count
1160 && (bfd_asymbol_value (sorted_syms
[min
])
1161 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1163 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1170 return sorted_syms
[thisplace
];
1175 /* If the file is relocatable, and the symbol could be from this
1176 section, prefer a symbol from this section over symbols from
1177 others, even if the other symbol's value might be closer.
1179 Note that this may be wrong for some symbol references if the
1180 sections have overlapping memory ranges, but in that case there's
1181 no way to tell what's desired without looking at the relocation
1184 Also give the target a chance to reject symbols. */
1185 want_section
= (aux
->require_sec
1186 || ((abfd
->flags
& HAS_RELOC
) != 0
1187 && vma
>= bfd_section_vma (sec
)
1188 && vma
< (bfd_section_vma (sec
)
1189 + bfd_section_size (sec
) / opb
)));
1191 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1194 long newplace
= sorted_symcount
;
1196 for (i
= min
- 1; i
>= 0; i
--)
1198 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1200 if (newplace
== sorted_symcount
)
1203 if (bfd_asymbol_value (sorted_syms
[i
])
1204 != bfd_asymbol_value (sorted_syms
[newplace
]))
1207 /* Remember this symbol and keep searching until we reach
1208 an earlier address. */
1213 if (newplace
!= sorted_symcount
)
1214 thisplace
= newplace
;
1217 /* We didn't find a good symbol with a smaller value.
1218 Look for one with a larger value. */
1219 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1221 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1229 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1230 /* There is no suitable symbol. */
1234 /* If we have not found an exact match for the specified address
1235 and we have dynamic relocations available, then we can produce
1236 a better result by matching a relocation to the address and
1237 using the symbol associated with that relocation. */
1238 rel_count
= aux
->dynrelcount
;
1240 && sorted_syms
[thisplace
]->value
!= vma
1242 && aux
->dynrelbuf
!= NULL
1243 && aux
->dynrelbuf
[0]->address
<= vma
1244 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1245 /* If we have matched a synthetic symbol, then stick with that. */
1246 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1249 arelent
** rel_high
;
1251 rel_low
= aux
->dynrelbuf
;
1252 rel_high
= rel_low
+ rel_count
- 1;
1253 while (rel_low
<= rel_high
)
1255 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1256 arelent
* rel
= *rel_mid
;
1258 if (rel
->address
== vma
)
1260 /* Absolute relocations do not provide a more helpful
1261 symbolic address. Find a non-absolute relocation
1262 with the same address. */
1263 arelent
**rel_vma
= rel_mid
;
1265 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1269 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1273 if (rel
->sym_ptr_ptr
!= NULL
1274 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1277 * place
= thisplace
;
1278 return * rel
->sym_ptr_ptr
;
1284 if (vma
< rel
->address
)
1286 else if (vma
>= rel_mid
[1]->address
)
1287 rel_low
= rel_mid
+ 1;
1296 return sorted_syms
[thisplace
];
1299 /* Print an address and the offset to the nearest symbol. */
1302 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1303 bfd_vma vma
, struct disassemble_info
*inf
,
1304 bfd_boolean skip_zeroes
)
1306 objdump_print_value (vma
, inf
, skip_zeroes
);
1312 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1313 sanitize_string (bfd_section_name (sec
)));
1314 secaddr
= bfd_section_vma (sec
);
1317 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1318 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1320 else if (vma
> secaddr
)
1322 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1323 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1325 (*inf
->fprintf_func
) (inf
->stream
, ">");
1329 (*inf
->fprintf_func
) (inf
->stream
, " <");
1331 objdump_print_symname (abfd
, inf
, sym
);
1333 if (bfd_asymbol_value (sym
) == vma
)
1335 /* Undefined symbols in an executables and dynamic objects do not have
1336 a value associated with them, so it does not make sense to display
1337 an offset relative to them. Normally we would not be provided with
1338 this kind of symbol, but the target backend might choose to do so,
1339 and the code in find_symbol_for_address might return an as yet
1340 unresolved symbol associated with a dynamic reloc. */
1341 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1342 && bfd_is_und_section (sym
->section
))
1344 else if (bfd_asymbol_value (sym
) > vma
)
1346 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1347 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1349 else if (vma
> bfd_asymbol_value (sym
))
1351 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1352 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1355 (*inf
->fprintf_func
) (inf
->stream
, ">");
1358 if (display_file_offsets
)
1359 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1360 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1363 /* Print an address (VMA), symbolically if possible.
1364 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1367 objdump_print_addr (bfd_vma vma
,
1368 struct disassemble_info
*inf
,
1369 bfd_boolean skip_zeroes
)
1371 struct objdump_disasm_info
*aux
;
1372 asymbol
*sym
= NULL
;
1373 bfd_boolean skip_find
= FALSE
;
1375 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1377 if (sorted_symcount
< 1)
1379 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1380 objdump_print_value (vma
, inf
, skip_zeroes
);
1382 if (display_file_offsets
)
1383 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1384 (long int) (inf
->section
->filepos
1385 + (vma
- inf
->section
->vma
)));
1389 if (aux
->reloc
!= NULL
1390 && aux
->reloc
->sym_ptr_ptr
!= NULL
1391 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1393 sym
= * aux
->reloc
->sym_ptr_ptr
;
1395 /* Adjust the vma to the reloc. */
1396 vma
+= bfd_asymbol_value (sym
);
1398 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1403 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1405 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1409 /* Print VMA to INFO. This function is passed to the disassembler
1413 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1415 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1418 /* Determine if the given address has a symbol associated with it. */
1421 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1425 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1427 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1430 /* Hold the last function name and the last line number we displayed
1431 in a disassembly. */
1433 static char *prev_functionname
;
1434 static unsigned int prev_line
;
1435 static unsigned int prev_discriminator
;
1437 /* We keep a list of all files that we have seen when doing a
1438 disassembly with source, so that we know how much of the file to
1439 display. This can be important for inlined functions. */
1441 struct print_file_list
1443 struct print_file_list
*next
;
1444 const char *filename
;
1445 const char *modname
;
1448 const char **linemap
;
1451 unsigned max_printed
;
1455 static struct print_file_list
*print_files
;
1457 /* The number of preceding context lines to show when we start
1458 displaying a file for the first time. */
1460 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1462 /* Read a complete file into memory. */
1465 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1468 int ps
= getpagesize ();
1472 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1476 if (fstat (fd
, fst
) < 0)
1481 *size
= fst
->st_size
;
1483 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1484 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1485 if (map
!= (char *) -1L)
1491 map
= (const char *) malloc (*size
);
1492 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1494 free ((void *) map
);
1501 #define line_map_decrease 5
1503 /* Precompute array of lines for a mapped file. */
1505 static const char **
1506 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1508 const char *p
, *lstart
, *end
;
1509 int chars_per_line
= 45; /* First iteration will use 40. */
1510 unsigned int lineno
;
1511 const char **linemap
= NULL
;
1512 unsigned long line_map_size
= 0;
1518 for (p
= map
; p
< end
; p
++)
1522 if (p
+ 1 < end
&& p
[1] == '\r')
1525 else if (*p
== '\r')
1527 if (p
+ 1 < end
&& p
[1] == '\n')
1533 /* End of line found. */
1535 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1537 unsigned long newsize
;
1539 chars_per_line
-= line_map_decrease
;
1540 if (chars_per_line
<= 1)
1542 line_map_size
= size
/ chars_per_line
+ 1;
1543 if (line_map_size
< lineno
+ 1)
1544 line_map_size
= lineno
+ 1;
1545 newsize
= line_map_size
* sizeof (char *);
1546 linemap
= (const char **) xrealloc (linemap
, newsize
);
1549 linemap
[lineno
++] = lstart
;
1557 /* Tries to open MODNAME, and if successful adds a node to print_files
1558 linked list and returns that node. Returns NULL on failure. */
1560 static struct print_file_list
*
1561 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1563 struct print_file_list
*p
;
1565 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1567 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1574 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1577 p
->filename
= origname
;
1578 p
->modname
= modname
;
1579 p
->next
= print_files
;
1585 /* If the source file, as described in the symtab, is not found
1586 try to locate it in one of the paths specified with -I
1587 If found, add location to print_files linked list. */
1589 static struct print_file_list
*
1590 update_source_path (const char *filename
, bfd
*abfd
)
1592 struct print_file_list
*p
;
1597 p
= try_print_file_open (filename
, filename
, &fst
);
1600 if (include_path_count
== 0)
1603 /* Get the name of the file. */
1604 fname
= lbasename (filename
);
1606 /* If file exists under a new path, we need to add it to the list
1607 so that show_line knows about it. */
1608 for (i
= 0; i
< include_path_count
; i
++)
1610 char *modname
= concat (include_paths
[i
], "/", fname
,
1613 p
= try_print_file_open (filename
, modname
, &fst
);
1623 long mtime
= bfd_get_mtime (abfd
);
1625 if (fst
.st_mtime
> mtime
)
1626 warn (_("source file %s is more recent than object file\n"),
1633 /* Print a source file line. */
1636 print_line (struct print_file_list
*p
, unsigned int linenum
)
1642 if (linenum
>= p
->maxline
)
1644 l
= p
->linemap
[linenum
];
1645 if (source_comment
!= NULL
&& strlen (l
) > 0)
1646 printf ("%s", source_comment
);
1647 len
= strcspn (l
, "\n\r");
1648 /* Test fwrite return value to quiet glibc warning. */
1649 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1653 /* Print a range of source code lines. */
1656 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1660 while (start
<= end
)
1662 print_line (p
, start
);
1667 /* Show the line number, or the source line, in a disassembly
1671 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1673 const char *filename
;
1674 const char *functionname
;
1675 unsigned int linenumber
;
1676 unsigned int discriminator
;
1680 if (! with_line_numbers
&& ! with_source_code
)
1683 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1684 &filename
, &functionname
,
1685 &linenumber
, &discriminator
))
1688 if (filename
!= NULL
&& *filename
== '\0')
1690 if (functionname
!= NULL
&& *functionname
== '\0')
1691 functionname
= NULL
;
1694 && IS_ABSOLUTE_PATH (filename
)
1698 const char *fname
= filename
;
1700 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1703 memcpy (path
, prefix
, prefix_length
);
1704 path_up
= path
+ prefix_length
;
1706 /* Build relocated filename, stripping off leading directories
1707 from the initial filename if requested. */
1708 if (prefix_strip
> 0)
1713 /* Skip selected directory levels. */
1714 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1715 if (IS_DIR_SEPARATOR (*s
))
1722 /* Update complete filename. */
1723 strncpy (path_up
, fname
, PATH_MAX
);
1724 path_up
[PATH_MAX
] = '\0';
1732 if (with_line_numbers
)
1734 if (functionname
!= NULL
1735 && (prev_functionname
== NULL
1736 || strcmp (functionname
, prev_functionname
) != 0))
1738 char *demangle_alloc
= NULL
;
1739 if (do_demangle
&& functionname
[0] != '\0')
1741 /* Demangle the name. */
1742 demangle_alloc
= bfd_demangle (abfd
, functionname
,
1746 /* Demangling adds trailing parens, so don't print those. */
1747 if (demangle_alloc
!= NULL
)
1748 printf ("%s:\n", sanitize_string (demangle_alloc
));
1750 printf ("%s():\n", sanitize_string (functionname
));
1753 free (demangle_alloc
);
1756 && (linenumber
!= prev_line
1757 || discriminator
!= prev_discriminator
))
1759 if (discriminator
> 0)
1760 printf ("%s:%u (discriminator %u)\n",
1761 filename
== NULL
? "???" : sanitize_string (filename
),
1762 linenumber
, discriminator
);
1764 printf ("%s:%u\n", filename
== NULL
1765 ? "???" : sanitize_string (filename
),
1770 const char *filename2
;
1771 const char *functionname2
;
1774 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1777 printf ("inlined by %s:%u",
1778 sanitize_string (filename2
), line2
);
1779 printf (" (%s)\n", sanitize_string (functionname2
));
1784 if (with_source_code
1788 struct print_file_list
**pp
, *p
;
1791 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1792 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1799 filename
= xstrdup (filename
);
1800 p
= update_source_path (filename
, abfd
);
1803 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1805 if (file_start_context
&& p
->first
)
1809 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1810 if (l
>= linenumber
)
1812 if (p
->max_printed
>= l
)
1814 if (p
->max_printed
< linenumber
)
1815 l
= p
->max_printed
+ 1;
1820 dump_lines (p
, l
, linenumber
);
1821 if (p
->max_printed
< linenumber
)
1822 p
->max_printed
= linenumber
;
1823 p
->last_line
= linenumber
;
1828 if (functionname
!= NULL
1829 && (prev_functionname
== NULL
1830 || strcmp (functionname
, prev_functionname
) != 0))
1832 if (prev_functionname
!= NULL
)
1833 free (prev_functionname
);
1834 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1835 strcpy (prev_functionname
, functionname
);
1838 if (linenumber
> 0 && linenumber
!= prev_line
)
1839 prev_line
= linenumber
;
1841 if (discriminator
!= prev_discriminator
)
1842 prev_discriminator
= discriminator
;
1848 /* Pseudo FILE object for strings. */
1856 /* sprintf to a "stream". */
1858 static int ATTRIBUTE_PRINTF_2
1859 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1866 size_t space
= f
->alloc
- f
->pos
;
1868 va_start (args
, format
);
1869 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1875 f
->alloc
= (f
->alloc
+ n
) * 2;
1876 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1883 /* Code for generating (colored) diagrams of control flow start and end
1886 /* Structure used to store the properties of a jump. */
1890 /* The next jump, or NULL if this is the last object. */
1891 struct jump_info
*next
;
1892 /* The previous jump, or NULL if this is the first object. */
1893 struct jump_info
*prev
;
1894 /* The start addresses of the jump. */
1897 /* The list of start addresses. */
1899 /* The number of elements. */
1901 /* The maximum number of elements that fit into the array. */
1904 /* The end address of the jump. */
1906 /* The drawing level of the jump. */
1910 /* Construct a jump object for a jump from start
1911 to end with the corresponding level. */
1913 static struct jump_info
*
1914 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1916 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1918 result
->next
= NULL
;
1919 result
->prev
= NULL
;
1920 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1921 result
->start
.addresses
[0] = start
;
1922 result
->start
.count
= 1;
1923 result
->start
.max_count
= 2;
1925 result
->level
= level
;
1930 /* Free a jump object and return the next object
1931 or NULL if this was the last one. */
1933 static struct jump_info
*
1934 jump_info_free (struct jump_info
*ji
)
1936 struct jump_info
*result
= NULL
;
1941 if (ji
->start
.addresses
)
1942 free (ji
->start
.addresses
);
1949 /* Get the smallest value of all start and end addresses. */
1952 jump_info_min_address (const struct jump_info
*ji
)
1954 bfd_vma min_address
= ji
->end
;
1957 for (i
= ji
->start
.count
; i
-- > 0;)
1958 if (ji
->start
.addresses
[i
] < min_address
)
1959 min_address
= ji
->start
.addresses
[i
];
1963 /* Get the largest value of all start and end addresses. */
1966 jump_info_max_address (const struct jump_info
*ji
)
1968 bfd_vma max_address
= ji
->end
;
1971 for (i
= ji
->start
.count
; i
-- > 0;)
1972 if (ji
->start
.addresses
[i
] > max_address
)
1973 max_address
= ji
->start
.addresses
[i
];
1977 /* Get the target address of a jump. */
1980 jump_info_end_address (const struct jump_info
*ji
)
1985 /* Test if an address is one of the start addresses of a jump. */
1988 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
1990 bfd_boolean result
= FALSE
;
1993 for (i
= ji
->start
.count
; i
-- > 0;)
1994 if (address
== ji
->start
.addresses
[i
])
2003 /* Test if an address is the target address of a jump. */
2006 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2008 return (address
== ji
->end
);
2011 /* Get the difference between the smallest and largest address of a jump. */
2014 jump_info_size (const struct jump_info
*ji
)
2016 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2019 /* Unlink a jump object from a list. */
2022 jump_info_unlink (struct jump_info
*node
,
2023 struct jump_info
**base
)
2026 node
->next
->prev
= node
->prev
;
2028 node
->prev
->next
= node
->next
;
2035 /* Insert unlinked jump info node into a list. */
2038 jump_info_insert (struct jump_info
*node
,
2039 struct jump_info
*target
,
2040 struct jump_info
**base
)
2042 node
->next
= target
;
2043 node
->prev
= target
->prev
;
2044 target
->prev
= node
;
2046 node
->prev
->next
= node
;
2051 /* Add unlinked node to the front of a list. */
2054 jump_info_add_front (struct jump_info
*node
,
2055 struct jump_info
**base
)
2059 node
->next
->prev
= node
;
2064 /* Move linked node to target position. */
2067 jump_info_move_linked (struct jump_info
*node
,
2068 struct jump_info
*target
,
2069 struct jump_info
**base
)
2072 jump_info_unlink (node
, base
);
2073 /* Insert node at target position. */
2074 jump_info_insert (node
, target
, base
);
2077 /* Test if two jumps intersect. */
2080 jump_info_intersect (const struct jump_info
*a
,
2081 const struct jump_info
*b
)
2083 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2084 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2087 /* Merge two compatible jump info objects. */
2090 jump_info_merge (struct jump_info
**base
)
2092 struct jump_info
*a
;
2094 for (a
= *base
; a
; a
= a
->next
)
2096 struct jump_info
*b
;
2098 for (b
= a
->next
; b
; b
= b
->next
)
2100 /* Merge both jumps into one. */
2101 if (a
->end
== b
->end
)
2103 /* Reallocate addresses. */
2104 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2107 if (needed_size
> a
->start
.max_count
)
2109 a
->start
.max_count
+= b
->start
.max_count
;
2110 a
->start
.addresses
=
2111 xrealloc (a
->start
.addresses
,
2112 a
->start
.max_count
* sizeof (bfd_vma
*));
2115 /* Append start addresses. */
2116 for (i
= 0; i
< b
->start
.count
; ++i
)
2117 a
->start
.addresses
[a
->start
.count
++] =
2118 b
->start
.addresses
[i
];
2120 /* Remove and delete jump. */
2121 struct jump_info
*tmp
= b
->prev
;
2122 jump_info_unlink (b
, base
);
2130 /* Sort jumps by their size and starting point using a stable
2131 minsort. This could be improved if sorting performance is
2132 an issue, for example by using mergesort. */
2135 jump_info_sort (struct jump_info
**base
)
2137 struct jump_info
*current_element
= *base
;
2139 while (current_element
)
2141 struct jump_info
*best_match
= current_element
;
2142 struct jump_info
*runner
= current_element
->next
;
2143 bfd_vma best_size
= jump_info_size (best_match
);
2147 bfd_vma runner_size
= jump_info_size (runner
);
2149 if ((runner_size
< best_size
)
2150 || ((runner_size
== best_size
)
2151 && (jump_info_min_address (runner
)
2152 < jump_info_min_address (best_match
))))
2154 best_match
= runner
;
2155 best_size
= runner_size
;
2158 runner
= runner
->next
;
2161 if (best_match
== current_element
)
2162 current_element
= current_element
->next
;
2164 jump_info_move_linked (best_match
, current_element
, base
);
2168 /* Visualize all jumps at a given address. */
2171 jump_info_visualize_address (bfd_vma address
,
2174 uint8_t *color_buffer
)
2176 struct jump_info
*ji
= detected_jumps
;
2177 size_t len
= (max_level
+ 1) * 3;
2179 /* Clear line buffer. */
2180 memset (line_buffer
, ' ', len
);
2181 memset (color_buffer
, 0, len
);
2183 /* Iterate over jumps and add their ASCII art. */
2186 /* Discard jumps that are never needed again. */
2187 if (jump_info_max_address (ji
) < address
)
2189 struct jump_info
*tmp
= ji
;
2192 jump_info_unlink (tmp
, &detected_jumps
);
2193 jump_info_free (tmp
);
2197 /* This jump intersects with the current address. */
2198 if (jump_info_min_address (ji
) <= address
)
2200 /* Hash target address to get an even
2201 distribution between all values. */
2202 bfd_vma hash_address
= jump_info_end_address (ji
);
2203 uint8_t color
= iterative_hash_object (hash_address
, 0);
2204 /* Fetch line offset. */
2205 int offset
= (max_level
- ji
->level
) * 3;
2207 /* Draw start line. */
2208 if (jump_info_is_start_address (ji
, address
))
2210 size_t i
= offset
+ 1;
2212 for (; i
< len
- 1; ++i
)
2213 if (line_buffer
[i
] == ' ')
2215 line_buffer
[i
] = '-';
2216 color_buffer
[i
] = color
;
2219 if (line_buffer
[i
] == ' ')
2221 line_buffer
[i
] = '-';
2222 color_buffer
[i
] = color
;
2224 else if (line_buffer
[i
] == '>')
2226 line_buffer
[i
] = 'X';
2227 color_buffer
[i
] = color
;
2230 if (line_buffer
[offset
] == ' ')
2232 if (address
<= ji
->end
)
2233 line_buffer
[offset
] =
2234 (jump_info_min_address (ji
) == address
) ? '/': '+';
2236 line_buffer
[offset
] =
2237 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2238 color_buffer
[offset
] = color
;
2241 /* Draw jump target. */
2242 else if (jump_info_is_end_address (ji
, address
))
2244 size_t i
= offset
+ 1;
2246 for (; i
< len
- 1; ++i
)
2247 if (line_buffer
[i
] == ' ')
2249 line_buffer
[i
] = '-';
2250 color_buffer
[i
] = color
;
2253 if (line_buffer
[i
] == ' ')
2255 line_buffer
[i
] = '>';
2256 color_buffer
[i
] = color
;
2258 else if (line_buffer
[i
] == '-')
2260 line_buffer
[i
] = 'X';
2261 color_buffer
[i
] = color
;
2264 if (line_buffer
[offset
] == ' ')
2266 if (jump_info_min_address (ji
) < address
)
2267 line_buffer
[offset
] =
2268 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2270 line_buffer
[offset
] = '/';
2271 color_buffer
[offset
] = color
;
2274 /* Draw intermediate line segment. */
2275 else if (line_buffer
[offset
] == ' ')
2277 line_buffer
[offset
] = '|';
2278 color_buffer
[offset
] = color
;
2286 /* Clone of disassemble_bytes to detect jumps inside a function. */
2287 /* FIXME: is this correct? Can we strip it down even further? */
2289 static struct jump_info
*
2290 disassemble_jumps (struct disassemble_info
* inf
,
2291 disassembler_ftype disassemble_fn
,
2292 bfd_vma start_offset
,
2293 bfd_vma stop_offset
,
2296 arelent
** relppend
)
2298 struct objdump_disasm_info
*aux
;
2299 struct jump_info
*jumps
= NULL
;
2301 bfd_vma addr_offset
;
2302 unsigned int opb
= inf
->octets_per_byte
;
2306 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2307 section
= inf
->section
;
2310 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2313 inf
->insn_info_valid
= 0;
2314 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2315 inf
->stream
= &sfile
;
2317 addr_offset
= start_offset
;
2318 while (addr_offset
< stop_offset
)
2320 int previous_octets
;
2322 /* Remember the length of the previous instruction. */
2323 previous_octets
= octets
;
2327 inf
->bytes_per_line
= 0;
2328 inf
->bytes_per_chunk
= 0;
2329 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2330 | (wide_output
? WIDE_OUTPUT
: 0));
2332 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2334 if (inf
->disassembler_needs_relocs
2335 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2336 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2337 && *relppp
< relppend
)
2339 bfd_signed_vma distance_to_rel
;
2341 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2343 /* Check to see if the current reloc is associated with
2344 the instruction that we are about to disassemble. */
2345 if (distance_to_rel
== 0
2346 /* FIXME: This is wrong. We are trying to catch
2347 relocs that are addressed part way through the
2348 current instruction, as might happen with a packed
2349 VLIW instruction. Unfortunately we do not know the
2350 length of the current instruction since we have not
2351 disassembled it yet. Instead we take a guess based
2352 upon the length of the previous instruction. The
2353 proper solution is to have a new target-specific
2354 disassembler function which just returns the length
2355 of an instruction at a given address without trying
2356 to display its disassembly. */
2357 || (distance_to_rel
> 0
2358 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2360 inf
->flags
|= INSN_HAS_RELOC
;
2364 if (! disassemble_all
2365 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2366 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2367 /* Set a stop_vma so that the disassembler will not read
2368 beyond the next symbol. We assume that symbols appear on
2369 the boundaries between instructions. We only do this when
2370 disassembling code of course, and when -D is in effect. */
2371 inf
->stop_vma
= section
->vma
+ stop_offset
;
2373 inf
->stop_offset
= stop_offset
;
2375 /* Extract jump information. */
2376 inf
->insn_info_valid
= 0;
2377 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2378 /* Test if a jump was detected. */
2379 if (inf
->insn_info_valid
2380 && ((inf
->insn_type
== dis_branch
)
2381 || (inf
->insn_type
== dis_condbranch
)
2382 || (inf
->insn_type
== dis_jsr
)
2383 || (inf
->insn_type
== dis_condjsr
))
2384 && (inf
->target
>= section
->vma
+ start_offset
)
2385 && (inf
->target
< section
->vma
+ stop_offset
))
2387 struct jump_info
*ji
=
2388 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2389 jump_info_add_front (ji
, &jumps
);
2394 addr_offset
+= octets
/ opb
;
2397 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2398 inf
->stream
= stdout
;
2400 free (sfile
.buffer
);
2403 jump_info_merge (&jumps
);
2404 /* Process jumps. */
2405 jump_info_sort (&jumps
);
2407 /* Group jumps by level. */
2408 struct jump_info
*last_jump
= jumps
;
2413 /* The last jump is part of the next group. */
2414 struct jump_info
*base
= last_jump
;
2415 /* Increment level. */
2416 base
->level
= ++max_level
;
2418 /* Find jumps that can be combined on the same
2419 level, with the largest jumps tested first.
2420 This has the advantage that large jumps are on
2421 lower levels and do not intersect with small
2422 jumps that get grouped on higher levels. */
2423 struct jump_info
*exchange_item
= last_jump
->next
;
2424 struct jump_info
*it
= exchange_item
;
2426 for (; it
; it
= it
->next
)
2428 /* Test if the jump intersects with any
2429 jump from current group. */
2430 bfd_boolean ok
= TRUE
;
2431 struct jump_info
*it_collision
;
2433 for (it_collision
= base
;
2434 it_collision
!= exchange_item
;
2435 it_collision
= it_collision
->next
)
2437 /* This jump intersects so we leave it out. */
2438 if (jump_info_intersect (it_collision
, it
))
2445 /* Add jump to group. */
2448 /* Move current element to the front. */
2449 if (it
!= exchange_item
)
2451 struct jump_info
*save
= it
->prev
;
2452 jump_info_move_linked (it
, exchange_item
, &jumps
);
2458 last_jump
= exchange_item
;
2459 exchange_item
= exchange_item
->next
;
2461 last_jump
->level
= max_level
;
2465 /* Move to next group. */
2466 last_jump
= exchange_item
;
2472 /* The number of zeroes we want to see before we start skipping them.
2473 The number is arbitrarily chosen. */
2475 #define DEFAULT_SKIP_ZEROES 8
2477 /* The number of zeroes to skip at the end of a section. If the
2478 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2479 SKIP_ZEROES, they will be disassembled. If there are fewer than
2480 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2481 attempt to avoid disassembling zeroes inserted by section
2484 #define DEFAULT_SKIP_ZEROES_AT_END 3
2487 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2492 /* Print out jump visualization. */
2495 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2496 uint8_t *color_buffer
)
2501 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2503 size_t line_buffer_size
= strlen (line_buffer
);
2504 char last_color
= 0;
2507 for (i
= 0; i
<= line_buffer_size
; ++i
)
2511 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2513 if (color
!= last_color
)
2516 if (extended_color_output
)
2517 /* Use extended 8bit color, but
2518 do not choose dark colors. */
2519 printf ("\033[38;5;%dm", 124 + (color
% 108));
2521 /* Use simple terminal colors. */
2522 printf ("\033[%dm", 31 + (color
% 7));
2529 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2533 /* Disassemble some data in memory between given values. */
2536 disassemble_bytes (struct disassemble_info
* inf
,
2537 disassembler_ftype disassemble_fn
,
2540 bfd_vma start_offset
,
2541 bfd_vma stop_offset
,
2544 arelent
** relppend
)
2546 struct objdump_disasm_info
*aux
;
2548 int octets_per_line
;
2549 int skip_addr_chars
;
2550 bfd_vma addr_offset
;
2551 unsigned int opb
= inf
->octets_per_byte
;
2552 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2553 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2557 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2558 section
= inf
->section
;
2561 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2565 octets_per_line
= insn_width
;
2567 octets_per_line
= 4;
2569 octets_per_line
= 16;
2571 /* Figure out how many characters to skip at the start of an
2572 address, to make the disassembly look nicer. We discard leading
2573 zeroes in chunks of 4, ensuring that there is always a leading
2575 skip_addr_chars
= 0;
2576 if (! prefix_addresses
)
2580 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2582 while (buf
[skip_addr_chars
] == '0')
2585 /* Don't discard zeros on overflow. */
2586 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2587 skip_addr_chars
= 0;
2589 if (skip_addr_chars
!= 0)
2590 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2593 inf
->insn_info_valid
= 0;
2595 /* Determine maximum level. */
2596 uint8_t *color_buffer
= NULL
;
2597 char *line_buffer
= NULL
;
2600 /* Some jumps were detected. */
2603 struct jump_info
*ji
;
2605 /* Find maximum jump level. */
2606 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2608 if (ji
->level
> max_level
)
2609 max_level
= ji
->level
;
2612 /* Allocate buffers. */
2613 size_t len
= (max_level
+ 1) * 3 + 1;
2614 line_buffer
= xmalloc (len
);
2615 line_buffer
[len
- 1] = 0;
2616 color_buffer
= xmalloc (len
);
2617 color_buffer
[len
- 1] = 0;
2620 addr_offset
= start_offset
;
2621 while (addr_offset
< stop_offset
)
2624 bfd_boolean need_nl
= FALSE
;
2628 /* Make sure we don't use relocs from previous instructions. */
2631 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2633 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2636 if (! disassemble_zeroes
2637 && (inf
->insn_info_valid
== 0
2638 || inf
->branch_delay_insns
== 0)
2639 && (z
- addr_offset
* opb
>= skip_zeroes
2640 || (z
== stop_offset
* opb
&&
2641 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2643 /* If there are more nonzero octets to follow, we only skip
2644 zeroes in multiples of 4, to try to avoid running over
2645 the start of an instruction which happens to start with
2647 if (z
!= stop_offset
* opb
)
2648 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2650 octets
= z
- addr_offset
* opb
;
2652 /* If we are going to display more data, and we are displaying
2653 file offsets, then tell the user how many zeroes we skip
2654 and the file offset from where we resume dumping. */
2655 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2656 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2658 (unsigned long) (section
->filepos
2659 + (addr_offset
+ (octets
/ opb
))));
2669 if (with_line_numbers
|| with_source_code
)
2670 show_line (aux
->abfd
, section
, addr_offset
);
2672 if (! prefix_addresses
)
2676 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2677 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2681 printf ("%s:\t", buf
+ skip_addr_chars
);
2685 aux
->require_sec
= TRUE
;
2686 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2687 aux
->require_sec
= FALSE
;
2691 print_jump_visualisation (section
->vma
+ addr_offset
,
2692 max_level
, line_buffer
,
2698 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2699 inf
->stream
= &sfile
;
2700 inf
->bytes_per_line
= 0;
2701 inf
->bytes_per_chunk
= 0;
2702 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2703 | (wide_output
? WIDE_OUTPUT
: 0));
2705 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2707 if (inf
->disassembler_needs_relocs
2708 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2709 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2710 && *relppp
< relppend
)
2712 bfd_signed_vma distance_to_rel
;
2714 int max_reloc_offset
2715 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2717 distance_to_rel
= ((**relppp
)->address
- rel_offset
2720 if (distance_to_rel
> 0
2721 && (max_reloc_offset
< 0
2722 || distance_to_rel
<= max_reloc_offset
))
2724 /* This reloc *might* apply to the current insn,
2725 starting somewhere inside it. Discover the length
2726 of the current insn so that the check below will
2729 insn_size
= insn_width
;
2732 /* We find the length by calling the dissassembler
2733 function with a dummy print handler. This should
2734 work unless the disassembler is not expecting to
2735 be called multiple times for the same address.
2737 This does mean disassembling the instruction
2738 twice, but we only do this when there is a high
2739 probability that there is a reloc that will
2740 affect the instruction. */
2741 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2742 insn_size
= disassemble_fn (section
->vma
2743 + addr_offset
, inf
);
2744 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2748 /* Check to see if the current reloc is associated with
2749 the instruction that we are about to disassemble. */
2750 if (distance_to_rel
== 0
2751 || (distance_to_rel
> 0
2752 && distance_to_rel
< insn_size
/ (int) opb
))
2754 inf
->flags
|= INSN_HAS_RELOC
;
2755 aux
->reloc
= **relppp
;
2759 if (! disassemble_all
2760 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2761 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2762 /* Set a stop_vma so that the disassembler will not read
2763 beyond the next symbol. We assume that symbols appear on
2764 the boundaries between instructions. We only do this when
2765 disassembling code of course, and when -D is in effect. */
2766 inf
->stop_vma
= section
->vma
+ stop_offset
;
2768 inf
->stop_offset
= stop_offset
;
2769 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2772 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2773 inf
->stream
= stdout
;
2774 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2775 octets_per_line
= inf
->bytes_per_line
;
2776 if (octets
< (int) opb
)
2779 printf ("%s\n", sfile
.buffer
);
2782 non_fatal (_("disassemble_fn returned length %d"),
2793 octets
= octets_per_line
;
2794 if (addr_offset
+ octets
/ opb
> stop_offset
)
2795 octets
= (stop_offset
- addr_offset
) * opb
;
2797 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2799 if (ISPRINT (data
[j
]))
2800 buf
[j
- addr_offset
* opb
] = data
[j
];
2802 buf
[j
- addr_offset
* opb
] = '.';
2804 buf
[j
- addr_offset
* opb
] = '\0';
2807 if (prefix_addresses
2809 : show_raw_insn
>= 0)
2813 /* If ! prefix_addresses and ! wide_output, we print
2814 octets_per_line octets per line. */
2816 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2817 pb
= octets_per_line
;
2819 if (inf
->bytes_per_chunk
)
2820 bpc
= inf
->bytes_per_chunk
;
2824 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2826 /* PR 21580: Check for a buffer ending early. */
2827 if (j
+ bpc
<= stop_offset
* opb
)
2831 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2833 for (k
= bpc
- 1; k
>= 0; k
--)
2834 printf ("%02x", (unsigned) data
[j
+ k
]);
2838 for (k
= 0; k
< bpc
; k
++)
2839 printf ("%02x", (unsigned) data
[j
+ k
]);
2845 for (; pb
< octets_per_line
; pb
+= bpc
)
2849 for (k
= 0; k
< bpc
; k
++)
2854 /* Separate raw data from instruction by extra space. */
2864 printf ("%s", sfile
.buffer
);
2866 if (prefix_addresses
2868 : show_raw_insn
>= 0)
2876 j
= addr_offset
* opb
+ pb
;
2878 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2879 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2883 printf ("%s:\t", buf
+ skip_addr_chars
);
2885 print_jump_visualisation (section
->vma
+ j
/ opb
,
2886 max_level
, line_buffer
,
2889 pb
+= octets_per_line
;
2892 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2894 /* PR 21619: Check for a buffer ending early. */
2895 if (j
+ bpc
<= stop_offset
* opb
)
2899 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2901 for (k
= bpc
- 1; k
>= 0; k
--)
2902 printf ("%02x", (unsigned) data
[j
+ k
]);
2906 for (k
= 0; k
< bpc
; k
++)
2907 printf ("%02x", (unsigned) data
[j
+ k
]);
2921 while ((*relppp
) < relppend
2922 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2924 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2935 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2938 if (q
->howto
== NULL
)
2939 printf (": *unknown*\t");
2940 else if (q
->howto
->name
)
2941 printf (": %s\t", q
->howto
->name
);
2943 printf (": %d\t", q
->howto
->type
);
2945 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2946 printf ("*unknown*");
2949 const char *sym_name
;
2951 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2952 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2953 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2958 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2959 sym_name
= bfd_section_name (sym_sec
);
2960 if (sym_name
== NULL
|| *sym_name
== '\0')
2961 sym_name
= "*unknown*";
2962 printf ("%s", sanitize_string (sym_name
));
2968 bfd_signed_vma addend
= q
->addend
;
2976 objdump_print_value (addend
, inf
, TRUE
);
2988 addr_offset
+= octets
/ opb
;
2991 free (sfile
.buffer
);
2993 free (color_buffer
);
2997 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2999 const struct elf_backend_data
* bed
;
3000 bfd_vma sign_adjust
= 0;
3001 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
3002 struct objdump_disasm_info
* paux
;
3003 unsigned int opb
= pinfo
->octets_per_byte
;
3004 bfd_byte
* data
= NULL
;
3005 bfd_size_type datasize
= 0;
3006 arelent
** rel_pp
= NULL
;
3007 arelent
** rel_ppstart
= NULL
;
3008 arelent
** rel_ppend
;
3009 bfd_vma stop_offset
;
3010 asymbol
* sym
= NULL
;
3014 unsigned long addr_offset
;
3015 bfd_boolean do_print
;
3018 stop_offset_reached
,
3023 /* Sections that do not contain machine
3024 code are not normally disassembled. */
3025 if (! disassemble_all
3026 && only_list
== NULL
3027 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3028 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3031 if (! process_section_p (section
))
3034 datasize
= bfd_section_size (section
);
3038 if (start_address
== (bfd_vma
) -1
3039 || start_address
< section
->vma
)
3042 addr_offset
= start_address
- section
->vma
;
3044 if (stop_address
== (bfd_vma
) -1)
3045 stop_offset
= datasize
/ opb
;
3048 if (stop_address
< section
->vma
)
3051 stop_offset
= stop_address
- section
->vma
;
3052 if (stop_offset
> datasize
/ opb
)
3053 stop_offset
= datasize
/ opb
;
3056 if (addr_offset
>= stop_offset
)
3059 /* Decide which set of relocs to use. Load them if necessary. */
3060 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3061 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3063 rel_pp
= paux
->dynrelbuf
;
3064 rel_count
= paux
->dynrelcount
;
3065 /* Dynamic reloc addresses are absolute, non-dynamic are section
3066 relative. REL_OFFSET specifies the reloc address corresponding
3067 to the start of this section. */
3068 rel_offset
= section
->vma
;
3076 if ((section
->flags
& SEC_RELOC
) != 0
3077 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3081 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3083 bfd_fatal (bfd_get_filename (abfd
));
3087 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3088 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3090 bfd_fatal (bfd_get_filename (abfd
));
3092 /* Sort the relocs by address. */
3093 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3097 rel_ppend
= rel_pp
+ rel_count
;
3099 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3101 non_fatal (_("Reading section %s failed because: %s"),
3102 section
->name
, bfd_errmsg (bfd_get_error ()));
3106 pinfo
->buffer
= data
;
3107 pinfo
->buffer_vma
= section
->vma
;
3108 pinfo
->buffer_length
= datasize
;
3109 pinfo
->section
= section
;
3111 /* Sort the symbols into value and section order. */
3112 compare_section
= section
;
3113 if (sorted_symcount
> 1)
3114 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3116 /* Skip over the relocs belonging to addresses below the
3118 while (rel_pp
< rel_ppend
3119 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3122 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3124 /* Find the nearest symbol forwards from our current position. */
3125 paux
->require_sec
= TRUE
;
3126 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3127 (struct disassemble_info
*) inf
,
3129 paux
->require_sec
= FALSE
;
3131 /* PR 9774: If the target used signed addresses then we must make
3132 sure that we sign extend the value that we calculate for 'addr'
3133 in the loop below. */
3134 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3135 && (bed
= get_elf_backend_data (abfd
)) != NULL
3136 && bed
->sign_extend_vma
)
3137 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3139 /* Disassemble a block of instructions up to the address associated with
3140 the symbol we have just found. Then print the symbol and find the
3141 next symbol on. Repeat until we have disassembled the entire section
3142 or we have reached the end of the address range we are interested in. */
3143 do_print
= paux
->symbol
== NULL
;
3144 loop_until
= stop_offset_reached
;
3146 while (addr_offset
< stop_offset
)
3150 bfd_vma nextstop_offset
;
3153 addr
= section
->vma
+ addr_offset
;
3154 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3156 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3161 (x
< sorted_symcount
3162 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3166 pinfo
->symbols
= sorted_syms
+ place
;
3167 pinfo
->num_symbols
= x
- place
;
3168 pinfo
->symtab_pos
= place
;
3172 pinfo
->symbols
= NULL
;
3173 pinfo
->num_symbols
= 0;
3174 pinfo
->symtab_pos
= -1;
3177 /* If we are only disassembling from a specific symbol,
3178 check to see if we should start or stop displaying. */
3179 if (sym
&& paux
->symbol
)
3183 /* See if we should stop printing. */
3187 if (sym
->flags
& BSF_FUNCTION
)
3191 case stop_offset_reached
:
3192 /* Handled by the while loop. */
3196 /* FIXME: There is an implicit assumption here
3197 that the name of sym is different from
3199 if (! bfd_is_local_label (abfd
, sym
))
3206 const char * name
= bfd_asymbol_name (sym
);
3207 char * alloc
= NULL
;
3209 if (do_demangle
&& name
[0] != '\0')
3211 /* Demangle the name. */
3212 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3217 /* We are not currently printing. Check to see
3218 if the current symbol matches the requested symbol. */
3219 if (streq (name
, paux
->symbol
))
3223 if (sym
->flags
& BSF_FUNCTION
)
3225 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3226 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3228 /* Sym is a function symbol with a size associated
3229 with it. Turn on automatic disassembly for the
3230 next VALUE bytes. */
3231 stop_offset
= addr_offset
3232 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3233 loop_until
= stop_offset_reached
;
3237 /* Otherwise we need to tell the loop heuristic to
3238 loop until the next function symbol is encountered. */
3239 loop_until
= function_sym
;
3244 /* Otherwise loop until the next symbol is encountered. */
3245 loop_until
= next_sym
;
3253 if (! prefix_addresses
&& do_print
)
3255 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3256 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3258 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3261 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3263 else if (sym
== NULL
)
3267 #define is_valid_next_sym(SYM) \
3268 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3269 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3270 && pinfo->symbol_is_valid (SYM, pinfo))
3272 /* Search forward for the next appropriate symbol in
3273 SECTION. Note that all the symbols are sorted
3274 together into one big array, and that some sections
3275 may have overlapping addresses. */
3276 while (place
< sorted_symcount
3277 && ! is_valid_next_sym (sorted_syms
[place
]))
3280 if (place
>= sorted_symcount
)
3283 nextsym
= sorted_syms
[place
];
3286 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3287 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3288 else if (nextsym
== NULL
)
3289 nextstop_offset
= stop_offset
;
3291 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3293 if (nextstop_offset
> stop_offset
3294 || nextstop_offset
<= addr_offset
)
3295 nextstop_offset
= stop_offset
;
3297 /* If a symbol is explicitly marked as being an object
3298 rather than a function, just dump the bytes without
3299 disassembling them. */
3302 || sym
->section
!= section
3303 || bfd_asymbol_value (sym
) > addr
3304 || ((sym
->flags
& BSF_OBJECT
) == 0
3305 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3307 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3309 || (sym
->flags
& BSF_FUNCTION
) != 0)
3316 /* Resolve symbol name. */
3317 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3319 struct disassemble_info di
;
3322 sf
.alloc
= strlen (sym
->name
) + 40;
3323 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3325 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3328 objdump_print_symname (abfd
, &di
, sym
);
3330 /* Fetch jump information. */
3331 detected_jumps
= disassemble_jumps
3332 (pinfo
, paux
->disassemble_fn
,
3333 addr_offset
, nextstop_offset
,
3334 rel_offset
, &rel_pp
, rel_ppend
);
3336 /* Free symbol name. */
3340 /* Add jumps to output. */
3341 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3342 addr_offset
, nextstop_offset
,
3343 rel_offset
, &rel_pp
, rel_ppend
);
3346 while (detected_jumps
)
3348 detected_jumps
= jump_info_free (detected_jumps
);
3352 addr_offset
= nextstop_offset
;
3358 if (rel_ppstart
!= NULL
)
3362 /* Disassemble the contents of an object file. */
3365 disassemble_data (bfd
*abfd
)
3367 struct disassemble_info disasm_info
;
3368 struct objdump_disasm_info aux
;
3372 prev_functionname
= NULL
;
3374 prev_discriminator
= 0;
3376 /* We make a copy of syms to sort. We don't want to sort syms
3377 because that will screw up the relocs. */
3378 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3379 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3380 * sizeof (asymbol
*));
3381 if (sorted_symcount
!= 0)
3383 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3384 sorted_symcount
* sizeof (asymbol
*));
3386 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3389 for (i
= 0; i
< synthcount
; ++i
)
3391 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3395 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3397 disasm_info
.application_data
= (void *) &aux
;
3399 aux
.require_sec
= FALSE
;
3400 aux
.dynrelbuf
= NULL
;
3401 aux
.dynrelcount
= 0;
3403 aux
.symbol
= disasm_sym
;
3405 disasm_info
.print_address_func
= objdump_print_address
;
3406 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3408 if (machine
!= NULL
)
3410 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3413 fatal (_("can't use supplied machine %s"), machine
);
3415 abfd
->arch_info
= inf
;
3418 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3420 struct bfd_target
*xvec
;
3422 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3423 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3424 xvec
->byteorder
= endian
;
3428 /* Use libopcodes to locate a suitable disassembler. */
3429 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3430 bfd_big_endian (abfd
),
3431 bfd_get_mach (abfd
), abfd
);
3432 if (!aux
.disassemble_fn
)
3434 non_fatal (_("can't disassemble for architecture %s\n"),
3435 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3440 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3441 disasm_info
.arch
= bfd_get_arch (abfd
);
3442 disasm_info
.mach
= bfd_get_mach (abfd
);
3443 disasm_info
.disassembler_options
= disassembler_options
;
3444 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3445 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3446 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3447 disasm_info
.disassembler_needs_relocs
= FALSE
;
3449 if (bfd_big_endian (abfd
))
3450 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3451 else if (bfd_little_endian (abfd
))
3452 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3454 /* ??? Aborting here seems too drastic. We could default to big or little
3456 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3458 /* Allow the target to customize the info structure. */
3459 disassemble_init_for_target (& disasm_info
);
3461 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3463 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3465 if (relsize
< 0 && dump_dynamic_reloc_info
)
3466 bfd_fatal (bfd_get_filename (abfd
));
3470 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3471 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3474 if (aux
.dynrelcount
< 0)
3475 bfd_fatal (bfd_get_filename (abfd
));
3477 /* Sort the relocs by address. */
3478 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3482 disasm_info
.symtab
= sorted_syms
;
3483 disasm_info
.symtab_size
= sorted_symcount
;
3485 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3487 if (aux
.dynrelbuf
!= NULL
)
3488 free (aux
.dynrelbuf
);
3490 disassemble_free_target (&disasm_info
);
3494 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3495 asection
*sec
, void *file
)
3497 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3498 bfd
*abfd
= (bfd
*) file
;
3503 if (section
->start
!= NULL
)
3505 /* If it is already loaded, do nothing. */
3506 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3508 free (section
->start
);
3511 section
->filename
= bfd_get_filename (abfd
);
3512 section
->reloc_info
= NULL
;
3513 section
->num_relocs
= 0;
3514 section
->address
= bfd_section_vma (sec
);
3515 section
->user_data
= sec
;
3516 section
->size
= bfd_section_size (sec
);
3517 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3518 alloced
= amt
= section
->size
+ 1;
3519 if (alloced
!= amt
|| alloced
== 0)
3521 section
->start
= NULL
;
3522 free_debug_section (debug
);
3523 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3524 sanitize_string (section
->name
),
3525 (unsigned long long) section
->size
);
3528 section
->start
= contents
= malloc (alloced
);
3529 if (section
->start
== NULL
3530 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3532 free_debug_section (debug
);
3533 printf (_("\nCan't get contents for section '%s'.\n"),
3534 sanitize_string (section
->name
));
3537 /* Ensure any string section has a terminating NUL. */
3538 section
->start
[section
->size
] = 0;
3540 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3541 && debug_displays
[debug
].relocate
)
3546 bfd_cache_section_contents (sec
, section
->start
);
3548 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3555 free_debug_section (debug
);
3556 printf (_("\nCan't get contents for section '%s'.\n"),
3557 sanitize_string (section
->name
));
3561 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3564 unsigned long reloc_count
;
3567 relocs
= (arelent
**) xmalloc (reloc_size
);
3569 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3570 if (reloc_count
== 0)
3574 section
->reloc_info
= relocs
;
3575 section
->num_relocs
= reloc_count
;
3584 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3589 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3592 relocs
= (arelent
**) dsec
->reloc_info
;
3594 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3595 if (rp
->address
== offset
)
3602 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3604 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3605 bfd
*abfd
= (bfd
*) file
;
3608 /* If it is already loaded, do nothing. */
3609 if (section
->start
!= NULL
)
3611 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3615 /* Locate the debug section. */
3616 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3618 section
->name
= section
->uncompressed_name
;
3621 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3623 section
->name
= section
->compressed_name
;
3628 return load_specific_debug_section (debug
, sec
, file
);
3632 free_debug_section (enum dwarf_section_display_enum debug
)
3634 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3636 if (section
->start
== NULL
)
3639 /* PR 17512: file: 0f67f69d. */
3640 if (section
->user_data
!= NULL
)
3642 asection
* sec
= (asection
*) section
->user_data
;
3644 /* If we are freeing contents that are also pointed to by the BFD
3645 library's section structure then make sure to update those pointers
3646 too. Otherwise, the next time we try to load data for this section
3647 we can end up using a stale pointer. */
3648 if (section
->start
== sec
->contents
)
3650 sec
->contents
= NULL
;
3651 sec
->flags
&= ~ SEC_IN_MEMORY
;
3652 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3656 free ((char *) section
->start
);
3657 section
->start
= NULL
;
3658 section
->address
= 0;
3663 close_debug_file (void * file
)
3665 bfd
* abfd
= (bfd
*) file
;
3671 open_debug_file (const char * pathname
)
3675 data
= bfd_openr (pathname
, NULL
);
3679 if (! bfd_check_format (data
, bfd_object
))
3685 #if HAVE_LIBDEBUGINFOD
3686 /* Return a hex string represention of the build-id. */
3689 get_build_id (void * data
)
3692 char * build_id_str
;
3693 bfd
* abfd
= (bfd
*) data
;
3694 const struct bfd_build_id
* build_id
;
3696 build_id
= abfd
->build_id
;
3697 if (build_id
== NULL
)
3700 build_id_str
= malloc (build_id
->size
* 2 + 1);
3701 if (build_id_str
== NULL
)
3704 for (i
= 0; i
< build_id
->size
; i
++)
3705 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3706 build_id_str
[build_id
->size
* 2] = '\0';
3708 return (unsigned char *)build_id_str
;
3710 #endif /* HAVE_LIBDEBUGINFOD */
3713 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3714 void *arg ATTRIBUTE_UNUSED
)
3716 const char *name
= bfd_section_name (section
);
3720 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3721 match
= ".debug_info";
3725 for (i
= 0; i
< max
; i
++)
3726 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3727 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3728 && debug_displays
[i
].enabled
!= NULL
3729 && *debug_displays
[i
].enabled
)
3731 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3733 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3734 sec
->name
= sec
->uncompressed_name
;
3736 sec
->name
= sec
->compressed_name
;
3737 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3740 debug_displays
[i
].display (sec
, abfd
);
3742 if (i
!= info
&& i
!= abbrev
)
3743 free_debug_section ((enum dwarf_section_display_enum
) i
);
3749 /* Dump the dwarf debugging information. */
3752 dump_dwarf (bfd
*abfd
)
3754 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3755 if (byte_get
== NULL
)
3757 warn (_("File %s does not contain any dwarf debug information\n"),
3758 bfd_get_filename (abfd
));
3762 switch (bfd_get_arch (abfd
))
3765 /* S12Z has a 24 bit address space. But the only known
3766 producer of dwarf_info encodes addresses into 32 bits. */
3771 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3775 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3776 bfd_get_mach (abfd
));
3778 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3781 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3782 it. Return NULL on failure. */
3785 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3786 bfd_size_type
*entsize_ptr
)
3791 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3792 if (stabsect
== NULL
)
3794 printf (_("No %s section present\n\n"),
3795 sanitize_string (sect_name
));
3799 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3801 non_fatal (_("reading %s section of %s failed: %s"),
3802 sect_name
, bfd_get_filename (abfd
),
3803 bfd_errmsg (bfd_get_error ()));
3809 *size_ptr
= bfd_section_size (stabsect
);
3811 *entsize_ptr
= stabsect
->entsize
;
3816 /* Stabs entries use a 12 byte format:
3817 4 byte string table index
3819 1 byte stab other field
3820 2 byte stab desc field
3822 FIXME: This will have to change for a 64 bit object format. */
3824 #define STRDXOFF (0)
3826 #define OTHEROFF (5)
3829 #define STABSIZE (12)
3831 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3832 using string table section STRSECT_NAME (in `strtab'). */
3835 print_section_stabs (bfd
*abfd
,
3836 const char *stabsect_name
,
3837 unsigned *string_offset_ptr
)
3840 unsigned file_string_table_offset
= 0;
3841 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3842 bfd_byte
*stabp
, *stabs_end
;
3845 stabs_end
= stabp
+ stab_size
;
3847 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3848 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3850 /* Loop through all symbols and print them.
3852 We start the index at -1 because there is a dummy symbol on
3853 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3854 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3858 unsigned char type
, other
;
3859 unsigned short desc
;
3862 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3863 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3864 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3865 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3866 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3868 printf ("\n%-6d ", i
);
3869 /* Either print the stab name, or, if unnamed, print its number
3870 again (makes consistent formatting for tools like awk). */
3871 name
= bfd_get_stab_name (type
);
3873 printf ("%-6s", sanitize_string (name
));
3874 else if (type
== N_UNDF
)
3877 printf ("%-6d", type
);
3878 printf (" %-6d %-6d ", other
, desc
);
3879 bfd_printf_vma (abfd
, value
);
3880 printf (" %-6lu", strx
);
3882 /* Symbols with type == 0 (N_UNDF) specify the length of the
3883 string table associated with this file. We use that info
3884 to know how to relocate the *next* file's string table indices. */
3887 file_string_table_offset
= next_file_string_table_offset
;
3888 next_file_string_table_offset
+= value
;
3892 bfd_size_type amt
= strx
+ file_string_table_offset
;
3894 /* Using the (possibly updated) string table offset, print the
3895 string (if any) associated with this symbol. */
3896 if (amt
< stabstr_size
)
3897 /* PR 17512: file: 079-79389-0.001:0.1.
3898 FIXME: May need to sanitize this string before displaying. */
3899 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3905 *string_offset_ptr
= next_file_string_table_offset
;
3910 const char * section_name
;
3911 const char * string_section_name
;
3912 unsigned string_offset
;
3917 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3920 stab_section_names
* sought
= (stab_section_names
*) names
;
3922 /* Check for section names for which stabsect_name is a prefix, to
3923 handle .stab.N, etc. */
3924 len
= strlen (sought
->section_name
);
3926 /* If the prefix matches, and the files section name ends with a
3927 nul or a digit, then we match. I.e., we want either an exact
3928 match or a section followed by a number. */
3929 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3930 && (section
->name
[len
] == 0
3931 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3934 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3935 &stabstr_size
, NULL
);
3939 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3941 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3947 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3949 stab_section_names s
;
3951 s
.section_name
= stabsect_name
;
3952 s
.string_section_name
= strsect_name
;
3953 s
.string_offset
= 0;
3955 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3961 /* Dump the any sections containing stabs debugging information. */
3964 dump_stabs (bfd
*abfd
)
3966 dump_stabs_section (abfd
, ".stab", ".stabstr");
3967 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3968 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3971 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3973 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3977 dump_bfd_header (bfd
*abfd
)
3981 printf (_("architecture: %s, "),
3982 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3983 bfd_get_mach (abfd
)));
3984 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3986 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
3987 PF (HAS_RELOC
, "HAS_RELOC");
3988 PF (EXEC_P
, "EXEC_P");
3989 PF (HAS_LINENO
, "HAS_LINENO");
3990 PF (HAS_DEBUG
, "HAS_DEBUG");
3991 PF (HAS_SYMS
, "HAS_SYMS");
3992 PF (HAS_LOCALS
, "HAS_LOCALS");
3993 PF (DYNAMIC
, "DYNAMIC");
3994 PF (WP_TEXT
, "WP_TEXT");
3995 PF (D_PAGED
, "D_PAGED");
3996 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3997 printf (_("\nstart address 0x"));
3998 bfd_printf_vma (abfd
, abfd
->start_address
);
4003 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4004 it is passed, or a pointer to newly-allocated storage, in which case
4005 dump_ctf() will free it when it no longer needs it. */
4008 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4011 const char *blanks
= arg
;
4014 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4019 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4021 make_ctfsect (const char *name
, bfd_byte
*data
,
4026 ctfsect
.cts_name
= name
;
4027 ctfsect
.cts_entsize
= 1;
4028 ctfsect
.cts_size
= size
;
4029 ctfsect
.cts_data
= data
;
4034 /* Dump one CTF archive member. */
4037 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4039 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4040 const char *things
[] = {"Header", "Labels", "Data objects",
4041 "Function objects", "Variables", "Types", "Strings",
4046 /* Only print out the name of non-default-named archive members.
4047 The name .ctf appears everywhere, even for things that aren't
4048 really archives, so printing it out is liable to be confusing.
4050 The parent, if there is one, is the default-owned archive member:
4051 avoid importing it into itself. (This does no harm, but looks
4054 if (strcmp (name
, ".ctf") != 0)
4056 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4057 ctf_import (ctf
, parent
);
4060 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4062 ctf_dump_state_t
*s
= NULL
;
4065 printf ("\n %s:\n", *thing
);
4066 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4067 (void *) " ")) != NULL
)
4069 printf ("%s\n", item
);
4073 if (ctf_errno (ctf
))
4075 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4076 ctf_errmsg (ctf_errno (ctf
)));
4083 /* Dump the CTF debugging information. */
4086 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4088 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4089 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4090 bfd_size_type ctfsize
, parentsize
;
4092 ctf_file_t
*parent
= NULL
;
4095 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4096 bfd_fatal (bfd_get_filename (abfd
));
4099 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4101 bfd_fatal (bfd_get_filename (abfd
));
4103 /* Load the CTF file and dump it. */
4105 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4106 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4108 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4109 bfd_fatal (bfd_get_filename (abfd
));
4114 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4115 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4117 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4118 bfd_fatal (bfd_get_filename (abfd
));
4121 lookparent
= parenta
;
4126 /* Assume that the applicable parent archive member is the default one.
4127 (This is what all known implementations are expected to do, if they
4128 put CTFs and their parents in archives together.) */
4129 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4131 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4132 bfd_fatal (bfd_get_filename (abfd
));
4135 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4137 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4138 ctf_file_close (parent
);
4140 ctf_close (parenta
);
4147 dump_bfd_private_header (bfd
*abfd
)
4149 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4150 non_fatal (_("warning: private headers incomplete: %s"),
4151 bfd_errmsg (bfd_get_error ()));
4155 dump_target_specific (bfd
*abfd
)
4157 const struct objdump_private_desc
* const *desc
;
4158 struct objdump_private_option
*opt
;
4161 /* Find the desc. */
4162 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4163 if ((*desc
)->filter (abfd
))
4168 non_fatal (_("option -P/--private not supported by this file"));
4172 /* Clear all options. */
4173 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4174 opt
->selected
= FALSE
;
4176 /* Decode options. */
4177 b
= dump_private_options
;
4180 e
= strchr (b
, ',');
4185 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4186 if (strcmp (opt
->name
, b
) == 0)
4188 opt
->selected
= TRUE
;
4191 if (opt
->name
== NULL
)
4192 non_fatal (_("target specific dump '%s' not supported"), b
);
4203 (*desc
)->dump (abfd
);
4206 /* Display a section in hexadecimal format with associated characters.
4207 Each line prefixed by the zero padded address. */
4210 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4212 bfd_byte
*data
= NULL
;
4213 bfd_size_type datasize
;
4214 bfd_vma addr_offset
;
4215 bfd_vma start_offset
;
4216 bfd_vma stop_offset
;
4217 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4218 /* Bytes per line. */
4219 const int onaline
= 16;
4224 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4227 if (! process_section_p (section
))
4230 if ((datasize
= bfd_section_size (section
)) == 0)
4233 /* Compute the address range to display. */
4234 if (start_address
== (bfd_vma
) -1
4235 || start_address
< section
->vma
)
4238 start_offset
= start_address
- section
->vma
;
4240 if (stop_address
== (bfd_vma
) -1)
4241 stop_offset
= datasize
/ opb
;
4244 if (stop_address
< section
->vma
)
4247 stop_offset
= stop_address
- section
->vma
;
4249 if (stop_offset
> datasize
/ opb
)
4250 stop_offset
= datasize
/ opb
;
4253 if (start_offset
>= stop_offset
)
4256 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4257 if (display_file_offsets
)
4258 printf (_(" (Starting at file offset: 0x%lx)"),
4259 (unsigned long) (section
->filepos
+ start_offset
));
4262 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4264 non_fatal (_("Reading section %s failed because: %s"),
4265 section
->name
, bfd_errmsg (bfd_get_error ()));
4271 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4272 if (strlen (buf
) >= sizeof (buf
))
4276 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4278 count
= strlen (buf
) - count
;
4282 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4283 if (strlen (buf
) >= sizeof (buf
))
4287 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4289 count
= strlen (buf
) - count
;
4293 for (addr_offset
= start_offset
;
4294 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4298 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4299 count
= strlen (buf
);
4300 if ((size_t) count
>= sizeof (buf
))
4304 while (count
< width
)
4309 fputs (buf
+ count
- width
, stdout
);
4312 for (j
= addr_offset
* opb
;
4313 j
< addr_offset
* opb
+ onaline
; j
++)
4315 if (j
< stop_offset
* opb
)
4316 printf ("%02x", (unsigned) (data
[j
]));
4324 for (j
= addr_offset
* opb
;
4325 j
< addr_offset
* opb
+ onaline
; j
++)
4327 if (j
>= stop_offset
* opb
)
4330 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4337 /* Actually display the various requested regions. */
4340 dump_data (bfd
*abfd
)
4342 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4345 /* Should perhaps share code and display with nm? */
4348 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4357 max_count
= dynsymcount
;
4358 printf ("DYNAMIC SYMBOL TABLE:\n");
4363 max_count
= symcount
;
4364 printf ("SYMBOL TABLE:\n");
4368 printf (_("no symbols\n"));
4370 for (count
= 0; count
< max_count
; count
++)
4374 if (*current
== NULL
)
4375 printf (_("no information for symbol number %ld\n"), count
);
4377 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4378 printf (_("could not determine the type of symbol number %ld\n"),
4381 else if (process_section_p ((* current
)->section
)
4382 && (dump_special_syms
4383 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4385 const char *name
= (*current
)->name
;
4387 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4391 /* If we want to demangle the name, we demangle it
4392 here, and temporarily clobber it while calling
4393 bfd_print_symbol. FIXME: This is a gross hack. */
4394 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4396 (*current
)->name
= alloc
;
4397 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4398 bfd_print_symbol_all
);
4401 (*current
)->name
= name
;
4406 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4407 bfd_print_symbol_all
);
4417 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4420 char *last_filename
, *last_functionname
;
4421 unsigned int last_line
;
4422 unsigned int last_discriminator
;
4424 /* Get column headers lined up reasonably. */
4432 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4433 width
= strlen (buf
) - 7;
4435 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4438 last_filename
= NULL
;
4439 last_functionname
= NULL
;
4441 last_discriminator
= 0;
4443 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4446 const char *filename
, *functionname
;
4447 unsigned int linenumber
;
4448 unsigned int discriminator
;
4449 const char *sym_name
;
4450 const char *section_name
;
4451 bfd_vma addend2
= 0;
4453 if (start_address
!= (bfd_vma
) -1
4454 && q
->address
< start_address
)
4456 if (stop_address
!= (bfd_vma
) -1
4457 && q
->address
> stop_address
)
4460 if (with_line_numbers
4462 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4463 &filename
, &functionname
,
4464 &linenumber
, &discriminator
))
4466 if (functionname
!= NULL
4467 && (last_functionname
== NULL
4468 || strcmp (functionname
, last_functionname
) != 0))
4470 printf ("%s():\n", sanitize_string (functionname
));
4471 if (last_functionname
!= NULL
)
4472 free (last_functionname
);
4473 last_functionname
= xstrdup (functionname
);
4477 && (linenumber
!= last_line
4478 || (filename
!= NULL
4479 && last_filename
!= NULL
4480 && filename_cmp (filename
, last_filename
) != 0)
4481 || (discriminator
!= last_discriminator
)))
4483 if (discriminator
> 0)
4484 printf ("%s:%u\n", filename
== NULL
? "???" :
4485 sanitize_string (filename
), linenumber
);
4487 printf ("%s:%u (discriminator %u)\n",
4488 filename
== NULL
? "???" : sanitize_string (filename
),
4489 linenumber
, discriminator
);
4490 last_line
= linenumber
;
4491 last_discriminator
= discriminator
;
4492 if (last_filename
!= NULL
)
4493 free (last_filename
);
4494 if (filename
== NULL
)
4495 last_filename
= NULL
;
4497 last_filename
= xstrdup (filename
);
4501 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4503 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4504 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4509 section_name
= NULL
;
4512 bfd_printf_vma (abfd
, q
->address
);
4513 if (q
->howto
== NULL
)
4514 printf (" *unknown* ");
4515 else if (q
->howto
->name
)
4517 const char *name
= q
->howto
->name
;
4519 /* R_SPARC_OLO10 relocations contain two addends.
4520 But because 'arelent' lacks enough storage to
4521 store them both, the 64-bit ELF Sparc backend
4522 records this as two relocations. One R_SPARC_LO10
4523 and one R_SPARC_13, both pointing to the same
4524 address. This is merely so that we have some
4525 place to store both addend fields.
4527 Undo this transformation, otherwise the output
4528 will be confusing. */
4529 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4530 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4532 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4534 arelent
*q2
= *(p
+ 1);
4537 && q
->address
== q2
->address
4538 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4540 name
= "R_SPARC_OLO10";
4541 addend2
= q2
->addend
;
4545 printf (" %-16s ", name
);
4548 printf (" %-16d ", q
->howto
->type
);
4552 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4556 if (section_name
== NULL
)
4557 section_name
= "*unknown*";
4558 printf ("[%s]", sanitize_string (section_name
));
4563 bfd_signed_vma addend
= q
->addend
;
4571 bfd_printf_vma (abfd
, addend
);
4576 bfd_printf_vma (abfd
, addend2
);
4582 if (last_filename
!= NULL
)
4583 free (last_filename
);
4584 if (last_functionname
!= NULL
)
4585 free (last_functionname
);
4589 dump_relocs_in_section (bfd
*abfd
,
4591 void *dummy ATTRIBUTE_UNUSED
)
4593 arelent
**relpp
= NULL
;
4597 if ( bfd_is_abs_section (section
)
4598 || bfd_is_und_section (section
)
4599 || bfd_is_com_section (section
)
4600 || (! process_section_p (section
))
4601 || ((section
->flags
& SEC_RELOC
) == 0))
4604 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4606 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4609 printf (" (none)\n\n");
4617 relpp
= (arelent
**) xmalloc (relsize
);
4618 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4624 non_fatal (_("failed to read relocs in: %s"),
4625 sanitize_string (bfd_get_filename (abfd
)));
4626 bfd_fatal (_("error message was"));
4628 else if (relcount
== 0)
4629 printf (" (none)\n\n");
4633 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4640 dump_relocs (bfd
*abfd
)
4642 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4646 dump_dynamic_relocs (bfd
*abfd
)
4652 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4654 bfd_fatal (bfd_get_filename (abfd
));
4656 printf ("DYNAMIC RELOCATION RECORDS");
4659 printf (" (none)\n\n");
4662 relpp
= (arelent
**) xmalloc (relsize
);
4663 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4666 bfd_fatal (bfd_get_filename (abfd
));
4667 else if (relcount
== 0)
4668 printf (" (none)\n\n");
4672 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4679 /* Creates a table of paths, to search for source files. */
4682 add_include_path (const char *path
)
4686 include_path_count
++;
4687 include_paths
= (const char **)
4688 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4689 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4690 if (path
[1] == ':' && path
[2] == 0)
4691 path
= concat (path
, ".", (const char *) 0);
4693 include_paths
[include_path_count
- 1] = path
;
4697 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4701 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4703 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4704 section
->vma
+= adjust_section_vma
;
4706 section
->lma
+= adjust_section_vma
;
4710 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4713 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4718 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4719 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4722 /* Dump selected contents of ABFD. */
4725 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4727 const struct elf_backend_data
* bed
;
4729 if (bfd_big_endian (abfd
))
4730 byte_get
= byte_get_big_endian
;
4731 else if (bfd_little_endian (abfd
))
4732 byte_get
= byte_get_little_endian
;
4736 /* Load any separate debug information files.
4737 We do this now and without checking do_follow_links because separate
4738 debug info files may contain symbol tables that we will need when
4739 displaying information about the main file. Any memory allocated by
4740 load_separate_debug_files will be released when we call
4741 free_debug_memory below.
4743 The test on is_mainfile is there because the chain of separate debug
4744 info files is a global variable shared by all invocations of dump_bfd. */
4747 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4749 /* If asked to do so, recursively dump the separate files. */
4750 if (do_follow_links
)
4754 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4755 dump_bfd (i
->handle
, FALSE
);
4759 /* Adjust user-specified start and stop limits for targets that use
4760 signed addresses. */
4761 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4762 && (bed
= get_elf_backend_data (abfd
)) != NULL
4763 && bed
->sign_extend_vma
)
4765 start_address
= sign_extend_address (abfd
, start_address
,
4767 stop_address
= sign_extend_address (abfd
, stop_address
,
4771 /* If we are adjusting section VMA's, change them all now. Changing
4772 the BFD information is a hack. However, we must do it, or
4773 bfd_find_nearest_line will not do the right thing. */
4774 if (adjust_section_vma
!= 0)
4776 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4777 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4780 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4781 printf (_("\n%s: file format %s\n"),
4782 sanitize_string (bfd_get_filename (abfd
)),
4785 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4786 if (dump_file_header
)
4787 dump_bfd_header (abfd
);
4788 if (dump_private_headers
)
4789 dump_bfd_private_header (abfd
);
4790 if (dump_private_options
!= NULL
)
4791 dump_target_specific (abfd
);
4792 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4799 || dump_dwarf_section_info
)
4801 syms
= slurp_symtab (abfd
);
4803 /* If following links, load any symbol tables from the linked files as well. */
4804 if (do_follow_links
&& is_mainfile
)
4808 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4810 asymbol
** extra_syms
;
4811 long old_symcount
= symcount
;
4813 extra_syms
= slurp_symtab (i
->handle
);
4817 if (old_symcount
== 0)
4823 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4824 memcpy (syms
+ old_symcount
,
4826 symcount
* sizeof (asymbol
*));
4830 symcount
+= old_symcount
;
4835 if (dump_section_headers
)
4836 dump_headers (abfd
);
4838 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4839 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4840 dynsyms
= slurp_dynamic_symtab (abfd
);
4844 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4845 dynsymcount
, dynsyms
, &synthsyms
);
4851 dump_symbols (abfd
, FALSE
);
4852 if (dump_dynamic_symtab
)
4853 dump_symbols (abfd
, TRUE
);
4854 if (dump_dwarf_section_info
)
4856 if (dump_ctf_section_info
)
4857 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4858 if (dump_stab_section_info
)
4860 if (dump_reloc_info
&& ! disassemble
)
4862 if (dump_dynamic_reloc_info
&& ! disassemble
)
4863 dump_dynamic_relocs (abfd
);
4864 if (dump_section_contents
)
4867 disassemble_data (abfd
);
4873 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4874 if (dhandle
!= NULL
)
4876 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4878 dump_debugging_tags
? TRUE
: FALSE
))
4880 non_fatal (_("%s: printing debugging information failed"),
4881 bfd_get_filename (abfd
));
4887 /* PR 6483: If there was no STABS debug info in the file, try
4889 else if (! dump_dwarf_section_info
)
4891 dwarf_select_sections_all ();
4919 free_debug_memory ();
4923 display_object_bfd (bfd
*abfd
)
4927 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4929 dump_bfd (abfd
, TRUE
);
4933 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4935 nonfatal (bfd_get_filename (abfd
));
4936 list_matching_formats (matching
);
4941 if (bfd_get_error () != bfd_error_file_not_recognized
)
4943 nonfatal (bfd_get_filename (abfd
));
4947 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4949 dump_bfd (abfd
, TRUE
);
4953 nonfatal (bfd_get_filename (abfd
));
4955 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4957 list_matching_formats (matching
);
4963 display_any_bfd (bfd
*file
, int level
)
4965 /* Decompress sections unless dumping the section contents. */
4966 if (!dump_section_contents
)
4967 file
->flags
|= BFD_DECOMPRESS
;
4969 /* If the file is an archive, process all of its elements. */
4970 if (bfd_check_format (file
, bfd_archive
))
4973 bfd
*last_arfile
= NULL
;
4976 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4977 else if (level
> 100)
4979 /* Prevent corrupted files from spinning us into an
4980 infinite loop. 100 is an arbitrary heuristic. */
4981 fatal (_("Archive nesting is too deep"));
4985 printf (_("In nested archive %s:\n"),
4986 sanitize_string (bfd_get_filename (file
)));
4990 bfd_set_error (bfd_error_no_error
);
4992 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4995 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4996 nonfatal (bfd_get_filename (file
));
5000 display_any_bfd (arfile
, level
+ 1);
5002 if (last_arfile
!= NULL
)
5004 bfd_close (last_arfile
);
5005 /* PR 17512: file: ac585d01. */
5006 if (arfile
== last_arfile
)
5012 last_arfile
= arfile
;
5015 if (last_arfile
!= NULL
)
5016 bfd_close (last_arfile
);
5019 display_object_bfd (file
);
5023 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5027 if (get_file_size (filename
) < 1)
5033 file
= bfd_openr (filename
, target
);
5036 nonfatal (filename
);
5040 display_any_bfd (file
, 0);
5042 /* This is an optimization to improve the speed of objdump, especially when
5043 dumping a file with lots of associated debug informatiom. Calling
5044 bfd_close on such a file can take a non-trivial amount of time as there
5045 are lots of lists to walk and buffers to free. This is only really
5046 necessary however if we are about to load another file and we need the
5047 memory back. Otherwise, if we are about to exit, then we can save (a lot
5048 of) time by only doing a quick close, and allowing the OS to reclaim the
5053 bfd_close_all_done (file
);
5057 main (int argc
, char **argv
)
5060 char *target
= default_target
;
5061 bfd_boolean seenflag
= FALSE
;
5063 #if defined (HAVE_SETLOCALE)
5064 #if defined (HAVE_LC_MESSAGES)
5065 setlocale (LC_MESSAGES
, "");
5067 setlocale (LC_CTYPE
, "");
5070 bindtextdomain (PACKAGE
, LOCALEDIR
);
5071 textdomain (PACKAGE
);
5073 program_name
= *argv
;
5074 xmalloc_set_program_name (program_name
);
5075 bfd_set_error_program_name (program_name
);
5077 START_PROGRESS (program_name
, 0);
5079 expandargv (&argc
, &argv
);
5081 if (bfd_init () != BFD_INIT_MAGIC
)
5082 fatal (_("fatal error: libbfd ABI mismatch"));
5083 set_default_bfd_target ();
5085 while ((c
= getopt_long (argc
, argv
,
5086 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5087 long_options
, (int *) 0))
5093 break; /* We've been given a long option. */
5100 if (disassembler_options
)
5101 /* Ignore potential memory leak for now. */
5102 options
= concat (disassembler_options
, ",",
5103 optarg
, (const char *) NULL
);
5106 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5113 display_file_offsets
= TRUE
;
5116 with_line_numbers
= TRUE
;
5125 enum demangling_styles style
;
5127 style
= cplus_demangle_name_to_style (optarg
);
5128 if (style
== unknown_demangling
)
5129 fatal (_("unknown demangling style `%s'"),
5132 cplus_demangle_set_style (style
);
5135 case OPTION_RECURSE_LIMIT
:
5136 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5138 case OPTION_NO_RECURSE_LIMIT
:
5139 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5142 do_wide
= wide_output
= TRUE
;
5144 case OPTION_ADJUST_VMA
:
5145 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5147 case OPTION_START_ADDRESS
:
5148 start_address
= parse_vma (optarg
, "--start-address");
5149 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5150 fatal (_("error: the start address should be before the end address"));
5152 case OPTION_STOP_ADDRESS
:
5153 stop_address
= parse_vma (optarg
, "--stop-address");
5154 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5155 fatal (_("error: the stop address should be after the start address"));
5159 prefix_length
= strlen (prefix
);
5160 /* Remove an unnecessary trailing '/' */
5161 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5164 case OPTION_PREFIX_STRIP
:
5165 prefix_strip
= atoi (optarg
);
5166 if (prefix_strip
< 0)
5167 fatal (_("error: prefix strip must be non-negative"));
5169 case OPTION_INSN_WIDTH
:
5170 insn_width
= strtoul (optarg
, NULL
, 0);
5171 if (insn_width
<= 0)
5172 fatal (_("error: instruction width must be positive"));
5174 case OPTION_INLINES
:
5175 unwind_inlines
= TRUE
;
5177 case OPTION_VISUALIZE_JUMPS
:
5178 visualize_jumps
= TRUE
;
5179 color_output
= FALSE
;
5180 extended_color_output
= FALSE
;
5183 if (streq (optarg
, "color"))
5184 color_output
= TRUE
;
5185 else if (streq (optarg
, "extended-color"))
5187 color_output
= TRUE
;
5188 extended_color_output
= TRUE
;
5190 else if (streq (optarg
, "off"))
5191 visualize_jumps
= FALSE
;
5193 nonfatal (_("unrecognized argument to --visualize-option"));
5197 if (strcmp (optarg
, "B") == 0)
5198 endian
= BFD_ENDIAN_BIG
;
5199 else if (strcmp (optarg
, "L") == 0)
5200 endian
= BFD_ENDIAN_LITTLE
;
5203 nonfatal (_("unrecognized -E option"));
5208 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5209 endian
= BFD_ENDIAN_BIG
;
5210 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5211 endian
= BFD_ENDIAN_LITTLE
;
5214 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5221 dump_file_header
= TRUE
;
5225 formats_info
= TRUE
;
5229 add_include_path (optarg
);
5232 dump_private_headers
= TRUE
;
5236 dump_private_options
= optarg
;
5240 dump_private_headers
= TRUE
;
5242 dump_reloc_info
= TRUE
;
5243 dump_file_header
= TRUE
;
5244 dump_ar_hdrs
= TRUE
;
5245 dump_section_headers
= TRUE
;
5253 dump_dynamic_symtab
= TRUE
;
5259 disasm_sym
= optarg
;
5262 disassemble_zeroes
= TRUE
;
5266 disassemble_all
= TRUE
;
5271 with_source_code
= TRUE
;
5274 case OPTION_SOURCE_COMMENT
:
5276 with_source_code
= TRUE
;
5279 source_comment
= xstrdup (sanitize_string (optarg
));
5281 source_comment
= xstrdup ("# ");
5289 dump_debugging_tags
= 1;
5294 dump_dwarf_section_info
= TRUE
;
5297 dwarf_select_sections_by_letters (optarg
);
5299 dwarf_select_sections_all ();
5302 dump_dwarf_section_info
= TRUE
;
5305 dwarf_select_sections_by_names (optarg
);
5307 dwarf_select_sections_all ();
5309 case OPTION_DWARF_DEPTH
:
5312 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5315 case OPTION_DWARF_START
:
5318 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5319 suppress_bfd_header
= 1;
5322 case OPTION_DWARF_CHECK
:
5326 dump_ctf_section_info
= TRUE
;
5327 dump_ctf_section_name
= xstrdup (optarg
);
5330 case OPTION_CTF_PARENT
:
5331 dump_ctf_parent_name
= xstrdup (optarg
);
5334 dump_stab_section_info
= TRUE
;
5338 dump_section_contents
= TRUE
;
5342 dump_reloc_info
= TRUE
;
5346 dump_dynamic_reloc_info
= TRUE
;
5350 dump_ar_hdrs
= TRUE
;
5354 dump_section_headers
= TRUE
;
5359 show_version
= TRUE
;
5365 /* No need to set seenflag or to break - usage() does not return. */
5372 print_version ("objdump");
5378 exit_status
= display_info ();
5382 display_file ("a.out", target
, TRUE
);
5384 for (; optind
< argc
;)
5386 display_file (argv
[optind
], target
, optind
== argc
- 1);
5392 free (dump_ctf_section_name
);
5393 free (dump_ctf_parent_name
);
5394 free ((void *) source_comment
);
5396 END_PROGRESS (program_name
);