1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
127 static bfd_boolean visualize_jumps
= FALSE
; /* --visualize-jumps. */
128 static bfd_boolean color_output
= FALSE
; /* --visualize-jumps=color. */
129 static bfd_boolean extended_color_output
= FALSE
; /* --visualize-jumps=extended-color. */
131 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
133 /* A structure to record the sections mentioned in -j switches. */
136 const char * name
; /* The name of the section. */
137 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
138 struct only
* next
; /* Pointer to the next structure in the list. */
140 /* Pointer to an array of 'only' structures.
141 This pointer is NULL if the -j switch has not been used. */
142 static struct only
* only_list
= NULL
;
144 /* Variables for handling include file path table. */
145 static const char **include_paths
;
146 static int include_path_count
;
148 /* Extra info to pass to the section disassembler and address printing
150 struct objdump_disasm_info
153 bfd_boolean require_sec
;
154 arelent
** dynrelbuf
;
156 disassembler_ftype disassemble_fn
;
161 /* Architecture to disassemble for, or default if NULL. */
162 static char *machine
= NULL
;
164 /* Target specific options to the disassembler. */
165 static char *disassembler_options
= NULL
;
167 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
168 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
170 /* The symbol table. */
171 static asymbol
**syms
;
173 /* Number of symbols in `syms'. */
174 static long symcount
= 0;
176 /* The sorted symbol table. */
177 static asymbol
**sorted_syms
;
179 /* Number of symbols in `sorted_syms'. */
180 static long sorted_symcount
= 0;
182 /* The dynamic symbol table. */
183 static asymbol
**dynsyms
;
185 /* The synthetic symbol table. */
186 static asymbol
*synthsyms
;
187 static long synthcount
= 0;
189 /* Number of symbols in `dynsyms'. */
190 static long dynsymcount
= 0;
192 static bfd_byte
*stabs
;
193 static bfd_size_type stab_size
;
195 static bfd_byte
*strtab
;
196 static bfd_size_type stabstr_size
;
198 /* Handlers for -P/--private. */
199 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
201 OBJDUMP_PRIVATE_VECTORS
205 /* The list of detected jumps inside a function. */
206 static struct jump_info
*detected_jumps
= NULL
;
208 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
210 usage (FILE *stream
, int status
)
212 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
213 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
214 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
215 fprintf (stream
, _("\
216 -a, --archive-headers Display archive header information\n\
217 -f, --file-headers Display the contents of the overall file header\n\
218 -p, --private-headers Display object format specific file header contents\n\
219 -P, --private=OPT,OPT... Display object format specific contents\n\
220 -h, --[section-]headers Display the contents of the section headers\n\
221 -x, --all-headers Display the contents of all headers\n\
222 -d, --disassemble Display assembler contents of executable sections\n\
223 -D, --disassemble-all Display assembler contents of all sections\n\
224 --disassemble=<sym> Display assembler contents from <sym>\n\
225 -S, --source Intermix source code with disassembly\n\
226 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
227 -s, --full-contents Display the full contents of all sections requested\n\
228 -g, --debugging Display debug information in object file\n\
229 -e, --debugging-tags Display debug information using ctags style\n\
230 -G, --stabs Display (in raw form) any STABS info in the file\n\
231 -W[lLiaprmfFsoRtUuTgAckK] or\n\
232 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
233 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
234 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
235 =addr,=cu_index,=links,=follow-links]\n\
236 Display DWARF info in the file\n\
237 --ctf=SECTION Display CTF info from SECTION\n\
238 -t, --syms Display the contents of the symbol table(s)\n\
239 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
240 -r, --reloc Display the relocation entries in the file\n\
241 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
242 @<file> Read options from <file>\n\
243 -v, --version Display this program's version number\n\
244 -i, --info List object formats and architectures supported\n\
245 -H, --help Display this information\n\
249 const struct objdump_private_desc
* const *desc
;
251 fprintf (stream
, _("\n The following switches are optional:\n"));
252 fprintf (stream
, _("\
253 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
254 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
255 -j, --section=NAME Only display information for section NAME\n\
256 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
257 -EB --endian=big Assume big endian format when disassembling\n\
258 -EL --endian=little Assume little endian format when disassembling\n\
259 --file-start-context Include context from start of file (with -S)\n\
260 -I, --include=DIR Add DIR to search list for source files\n\
261 -l, --line-numbers Include line numbers and filenames in output\n\
262 -F, --file-offsets Include file offsets when displaying information\n\
263 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
264 The STYLE, if specified, can be `auto', `gnu',\n\
265 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
267 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
268 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
269 -w, --wide Format output for more than 80 columns\n\
270 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
271 --start-address=ADDR Only process data whose address is >= ADDR\n\
272 --stop-address=ADDR Only process data whose address is < ADDR\n\
273 --prefix-addresses Print complete address alongside disassembly\n\
274 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
275 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
276 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
277 --special-syms Include special symbols in symbol dumps\n\
278 --inlines Print all inlines for source line (with -l)\n\
279 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
280 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
281 fprintf (stream
, _("\
282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
285 --dwarf-check Make additional dwarf internal consistency checks.\
287 --ctf-parent=SECTION Use SECTION as the CTF parent\n\
288 --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
289 --visualize-jumps=color Use colors in the ASCII art\n\
290 --visualize-jumps=extended-color Use extended 8-bit color codes\n\
291 --visualize-jumps=off Disable jump visualization\n\n"));
293 list_supported_targets (program_name
, stream
);
294 list_supported_architectures (program_name
, stream
);
296 disassembler_usage (stream
);
298 if (objdump_private_vectors
[0] != NULL
)
301 _("\nOptions supported for -P/--private switch:\n"));
302 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
303 (*desc
)->help (stream
);
306 if (REPORT_BUGS_TO
[0] && status
== 0)
307 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
311 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
315 OPTION_START_ADDRESS
,
325 OPTION_RECURSE_LIMIT
,
326 OPTION_NO_RECURSE_LIMIT
,
328 OPTION_SOURCE_COMMENT
,
331 OPTION_VISUALIZE_JUMPS
334 static struct option long_options
[]=
336 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
337 {"all-headers", no_argument
, NULL
, 'x'},
338 {"private-headers", no_argument
, NULL
, 'p'},
339 {"private", required_argument
, NULL
, 'P'},
340 {"architecture", required_argument
, NULL
, 'm'},
341 {"archive-headers", no_argument
, NULL
, 'a'},
342 {"debugging", no_argument
, NULL
, 'g'},
343 {"debugging-tags", no_argument
, NULL
, 'e'},
344 {"demangle", optional_argument
, NULL
, 'C'},
345 {"disassemble", optional_argument
, NULL
, 'd'},
346 {"disassemble-all", no_argument
, NULL
, 'D'},
347 {"disassembler-options", required_argument
, NULL
, 'M'},
348 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
349 {"dynamic-reloc", no_argument
, NULL
, 'R'},
350 {"dynamic-syms", no_argument
, NULL
, 'T'},
351 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
352 {"file-headers", no_argument
, NULL
, 'f'},
353 {"file-offsets", no_argument
, NULL
, 'F'},
354 {"file-start-context", no_argument
, &file_start_context
, 1},
355 {"full-contents", no_argument
, NULL
, 's'},
356 {"headers", no_argument
, NULL
, 'h'},
357 {"help", no_argument
, NULL
, 'H'},
358 {"info", no_argument
, NULL
, 'i'},
359 {"line-numbers", no_argument
, NULL
, 'l'},
360 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
361 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
362 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
363 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
364 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
365 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
366 {"reloc", no_argument
, NULL
, 'r'},
367 {"section", required_argument
, NULL
, 'j'},
368 {"section-headers", no_argument
, NULL
, 'h'},
369 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
370 {"source", no_argument
, NULL
, 'S'},
371 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
372 {"special-syms", no_argument
, &dump_special_syms
, 1},
373 {"include", required_argument
, NULL
, 'I'},
374 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
375 {"ctf", required_argument
, NULL
, OPTION_CTF
},
376 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
377 {"stabs", no_argument
, NULL
, 'G'},
378 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
379 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
380 {"syms", no_argument
, NULL
, 't'},
381 {"target", required_argument
, NULL
, 'b'},
382 {"version", no_argument
, NULL
, 'V'},
383 {"wide", no_argument
, NULL
, 'w'},
384 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
385 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
386 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
387 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
388 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
389 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
390 {"inlines", no_argument
, 0, OPTION_INLINES
},
391 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
392 {0, no_argument
, 0, 0}
396 nonfatal (const char *msg
)
402 /* Returns a version of IN with any control characters
403 replaced by escape sequences. Uses a static buffer
407 sanitize_string (const char * in
)
409 static char * buffer
= NULL
;
410 static size_t buffer_len
= 0;
411 const char * original
= in
;
418 /* See if any conversion is necessary. In the majority
419 of cases it will not be needed. */
432 /* Copy the input, translating as needed. */
434 if (buffer_len
< (strlen (in
) * 2))
436 free ((void *) buffer
);
437 buffer_len
= strlen (in
) * 2;
438 buffer
= xmalloc (buffer_len
+ 1);
464 /* Returns TRUE if the specified section should be dumped. */
467 process_section_p (asection
* section
)
471 if (only_list
== NULL
)
474 for (only
= only_list
; only
; only
= only
->next
)
475 if (strcmp (only
->name
, section
->name
) == 0)
484 /* Add an entry to the 'only' list. */
487 add_only (char * name
)
491 /* First check to make sure that we do not
492 already have an entry for this name. */
493 for (only
= only_list
; only
; only
= only
->next
)
494 if (strcmp (only
->name
, name
) == 0)
497 only
= xmalloc (sizeof * only
);
500 only
->next
= only_list
;
504 /* Release the memory used by the 'only' list.
505 PR 11225: Issue a warning message for unseen sections.
506 Only do this if none of the sections were seen. This is mainly to support
507 tools like the GAS testsuite where an object file is dumped with a list of
508 generic section names known to be present in a range of different file
512 free_only_list (void)
514 bfd_boolean at_least_one_seen
= FALSE
;
518 if (only_list
== NULL
)
521 for (only
= only_list
; only
; only
= only
->next
)
524 at_least_one_seen
= TRUE
;
528 for (only
= only_list
; only
; only
= next
)
530 if (! at_least_one_seen
)
532 non_fatal (_("section '%s' mentioned in a -j option, "
533 "but not found in any input file"),
544 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
547 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
548 int longest_section_name
= *((int *) data
);
550 /* Ignore linker created section. See elfNN_ia64_object_p in
552 if (section
->flags
& SEC_LINKER_CREATED
)
555 /* PR 10413: Skip sections that we are ignoring. */
556 if (! process_section_p (section
))
559 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
560 sanitize_string (bfd_section_name (section
)),
561 (unsigned long) bfd_section_size (section
) / opb
);
562 bfd_printf_vma (abfd
, bfd_section_vma (section
));
564 bfd_printf_vma (abfd
, section
->lma
);
565 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
566 bfd_section_alignment (section
));
572 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
574 PF (SEC_HAS_CONTENTS
, "CONTENTS");
575 PF (SEC_ALLOC
, "ALLOC");
576 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
577 PF (SEC_LOAD
, "LOAD");
578 PF (SEC_RELOC
, "RELOC");
579 PF (SEC_READONLY
, "READONLY");
580 PF (SEC_CODE
, "CODE");
581 PF (SEC_DATA
, "DATA");
583 PF (SEC_DEBUGGING
, "DEBUGGING");
584 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
585 PF (SEC_EXCLUDE
, "EXCLUDE");
586 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
587 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
589 PF (SEC_TIC54X_BLOCK
, "BLOCK");
590 PF (SEC_TIC54X_CLINK
, "CLINK");
592 PF (SEC_SMALL_DATA
, "SMALL_DATA");
593 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
595 PF (SEC_COFF_SHARED
, "SHARED");
596 PF (SEC_COFF_NOREAD
, "NOREAD");
598 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
600 PF (SEC_ELF_OCTETS
, "OCTETS");
601 PF (SEC_ELF_PURECODE
, "PURECODE");
603 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
604 PF (SEC_GROUP
, "GROUP");
605 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
607 PF (SEC_MEP_VLIW
, "VLIW");
610 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
613 struct coff_comdat_info
*comdat
;
615 switch (section
->flags
& SEC_LINK_DUPLICATES
)
619 case SEC_LINK_DUPLICATES_DISCARD
:
620 ls
= "LINK_ONCE_DISCARD";
622 case SEC_LINK_DUPLICATES_ONE_ONLY
:
623 ls
= "LINK_ONCE_ONE_ONLY";
625 case SEC_LINK_DUPLICATES_SAME_SIZE
:
626 ls
= "LINK_ONCE_SAME_SIZE";
628 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
629 ls
= "LINK_ONCE_SAME_CONTENTS";
632 printf ("%s%s", comma
, ls
);
634 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
636 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
645 /* Called on each SECTION in ABFD, update the int variable pointed to by
646 DATA which contains the string length of the longest section name. */
649 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
650 asection
*section
, void *data
)
652 int *longest_so_far
= (int *) data
;
656 /* Ignore linker created section. */
657 if (section
->flags
& SEC_LINKER_CREATED
)
660 /* Skip sections that we are ignoring. */
661 if (! process_section_p (section
))
664 name
= bfd_section_name (section
);
665 len
= (int) strlen (name
);
666 if (len
> *longest_so_far
)
667 *longest_so_far
= len
;
671 dump_headers (bfd
*abfd
)
673 /* The default width of 13 is just an arbitrary choice. */
674 int max_section_name_length
= 13;
680 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
681 if (bfd_get_arch_size (abfd
) == 32)
687 printf (_("Sections:\n"));
690 bfd_map_over_sections (abfd
, find_longest_section_name
,
691 &max_section_name_length
);
693 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
694 max_section_name_length
, "Name",
695 bfd_vma_width
, "VMA",
696 bfd_vma_width
, "LMA");
699 printf (_(" Flags"));
702 bfd_map_over_sections (abfd
, dump_section_header
,
703 &max_section_name_length
);
707 slurp_symtab (bfd
*abfd
)
712 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
718 storage
= bfd_get_symtab_upper_bound (abfd
);
721 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
722 bfd_fatal (_("error message was"));
726 off_t filesize
= bfd_get_file_size (abfd
);
730 && filesize
< storage
731 /* The MMO file format supports its own special compression
732 technique, so its sections can be larger than the file size. */
733 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
735 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
736 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
737 storage
, (long) filesize
);
743 sy
= (asymbol
**) xmalloc (storage
);
746 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
748 bfd_fatal (bfd_get_filename (abfd
));
752 /* Read in the dynamic symbols. */
755 slurp_dynamic_symtab (bfd
*abfd
)
760 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
763 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
765 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
771 bfd_fatal (bfd_get_filename (abfd
));
774 sy
= (asymbol
**) xmalloc (storage
);
776 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
778 bfd_fatal (bfd_get_filename (abfd
));
782 /* Some symbol names are significant and should be kept in the
783 table of sorted symbol names, even if they are marked as
784 debugging/section symbols. */
787 is_significant_symbol_name (const char * name
)
789 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
792 /* Filter out (in place) symbols that are useless for disassembly.
793 COUNT is the number of elements in SYMBOLS.
794 Return the number of useful symbols. */
797 remove_useless_symbols (asymbol
**symbols
, long count
)
799 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
803 asymbol
*sym
= *in_ptr
++;
805 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
807 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
808 && ! is_significant_symbol_name (sym
->name
))
810 if (bfd_is_und_section (sym
->section
)
811 || bfd_is_com_section (sym
->section
))
816 return out_ptr
- symbols
;
819 static const asection
*compare_section
;
821 /* Sort symbols into value order. */
824 compare_symbols (const void *ap
, const void *bp
)
826 const asymbol
*a
= * (const asymbol
**) ap
;
827 const asymbol
*b
= * (const asymbol
**) bp
;
832 bfd_boolean as
, af
, bs
, bf
;
836 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
838 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
841 /* Prefer symbols from the section currently being disassembled.
842 Don't sort symbols from other sections by section, since there
843 isn't much reason to prefer one section over another otherwise.
844 See sym_ok comment for why we compare by section name. */
845 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
846 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
852 an
= bfd_asymbol_name (a
);
853 bn
= bfd_asymbol_name (b
);
857 /* The symbols gnu_compiled and gcc2_compiled convey no real
858 information, so put them after other symbols with the same value. */
859 af
= (strstr (an
, "gnu_compiled") != NULL
860 || strstr (an
, "gcc2_compiled") != NULL
);
861 bf
= (strstr (bn
, "gnu_compiled") != NULL
862 || strstr (bn
, "gcc2_compiled") != NULL
);
869 /* We use a heuristic for the file name, to try to sort it after
870 more useful symbols. It may not work on non Unix systems, but it
871 doesn't really matter; the only difference is precisely which
872 symbol names get printed. */
874 #define file_symbol(s, sn, snl) \
875 (((s)->flags & BSF_FILE) != 0 \
877 && (sn)[(snl) - 2] == '.' \
878 && ((sn)[(snl) - 1] == 'o' \
879 || (sn)[(snl) - 1] == 'a')))
881 af
= file_symbol (a
, an
, anl
);
882 bf
= file_symbol (b
, bn
, bnl
);
889 /* Sort function and object symbols before global symbols before
890 local symbols before section symbols before debugging symbols. */
895 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
897 if ((aflags
& BSF_DEBUGGING
) != 0)
902 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
904 if ((aflags
& BSF_SECTION_SYM
) != 0)
909 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
911 if ((aflags
& BSF_FUNCTION
) != 0)
916 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
918 if ((aflags
& BSF_OBJECT
) != 0)
923 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
925 if ((aflags
& BSF_LOCAL
) != 0)
930 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
932 if ((aflags
& BSF_GLOBAL
) != 0)
938 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
939 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
944 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
945 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
947 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
948 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
950 return asz
> bsz
? -1 : 1;
953 /* Symbols that start with '.' might be section names, so sort them
954 after symbols that don't start with '.'. */
955 if (an
[0] == '.' && bn
[0] != '.')
957 if (an
[0] != '.' && bn
[0] == '.')
960 /* Finally, if we can't distinguish them in any other way, try to
961 get consistent results by sorting the symbols by name. */
962 return strcmp (an
, bn
);
965 /* Sort relocs into address order. */
968 compare_relocs (const void *ap
, const void *bp
)
970 const arelent
*a
= * (const arelent
**) ap
;
971 const arelent
*b
= * (const arelent
**) bp
;
973 if (a
->address
> b
->address
)
975 else if (a
->address
< b
->address
)
978 /* So that associated relocations tied to the same address show up
979 in the correct order, we don't do any further sorting. */
988 /* Print an address (VMA) to the output stream in INFO.
989 If SKIP_ZEROES is TRUE, omit leading zeroes. */
992 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
993 bfd_boolean skip_zeroes
)
997 struct objdump_disasm_info
*aux
;
999 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1000 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1005 for (p
= buf
; *p
== '0'; ++p
)
1010 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1013 /* Print the name of a symbol. */
1016 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1020 const char *name
, *version_string
= NULL
;
1021 bfd_boolean hidden
= FALSE
;
1024 name
= bfd_asymbol_name (sym
);
1025 if (do_demangle
&& name
[0] != '\0')
1027 /* Demangle the name. */
1028 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1033 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1034 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1036 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1039 name
= sanitize_string (name
);
1043 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1044 if (version_string
&& *version_string
!= '\0')
1045 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1050 printf ("%s", name
);
1051 if (version_string
&& *version_string
!= '\0')
1052 printf (hidden
? "@%s" : "@@%s", version_string
);
1059 static inline bfd_boolean
1060 sym_ok (bfd_boolean want_section
,
1061 bfd
* abfd ATTRIBUTE_UNUSED
,
1064 struct disassemble_info
* inf
)
1068 /* NB: An object file can have different sections with the same
1069 section name. Compare compare section pointers if they have
1071 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1072 && sorted_syms
[place
]->section
!= sec
)
1075 /* Note - we cannot just compare section pointers because they could
1076 be different, but the same... Ie the symbol that we are trying to
1077 find could have come from a separate debug info file. Under such
1078 circumstances the symbol will be associated with a section in the
1079 debug info file, whilst the section we want is in a normal file.
1080 So the section pointers will be different, but the section names
1081 will be the same. */
1082 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1083 bfd_section_name (sec
)) != 0)
1087 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1090 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1091 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1092 require the symbol to be in the section. Returns NULL if there is no
1093 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1094 of the symbol in sorted_syms. */
1097 find_symbol_for_address (bfd_vma vma
,
1098 struct disassemble_info
*inf
,
1101 /* @@ Would it speed things up to cache the last two symbols returned,
1102 and maybe their address ranges? For many processors, only one memory
1103 operand can be present at a time, so the 2-entry cache wouldn't be
1104 constantly churned by code doing heavy memory accesses. */
1106 /* Indices in `sorted_syms'. */
1108 long max_count
= sorted_symcount
;
1110 struct objdump_disasm_info
*aux
;
1114 bfd_boolean want_section
;
1117 if (sorted_symcount
< 1)
1120 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1123 opb
= inf
->octets_per_byte
;
1125 /* Perform a binary search looking for the closest symbol to the
1126 required value. We are searching the range (min, max_count]. */
1127 while (min
+ 1 < max_count
)
1131 thisplace
= (max_count
+ min
) / 2;
1132 sym
= sorted_syms
[thisplace
];
1134 if (bfd_asymbol_value (sym
) > vma
)
1135 max_count
= thisplace
;
1136 else if (bfd_asymbol_value (sym
) < vma
)
1145 /* The symbol we want is now in min, the low end of the range we
1146 were searching. If there are several symbols with the same
1147 value, we want the first one. */
1149 while (thisplace
> 0
1150 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1151 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1154 /* Prefer a symbol in the current section if we have multple symbols
1155 with the same value, as can occur with overlays or zero size
1158 while (min
< max_count
1159 && (bfd_asymbol_value (sorted_syms
[min
])
1160 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1162 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1169 return sorted_syms
[thisplace
];
1174 /* If the file is relocatable, and the symbol could be from this
1175 section, prefer a symbol from this section over symbols from
1176 others, even if the other symbol's value might be closer.
1178 Note that this may be wrong for some symbol references if the
1179 sections have overlapping memory ranges, but in that case there's
1180 no way to tell what's desired without looking at the relocation
1183 Also give the target a chance to reject symbols. */
1184 want_section
= (aux
->require_sec
1185 || ((abfd
->flags
& HAS_RELOC
) != 0
1186 && vma
>= bfd_section_vma (sec
)
1187 && vma
< (bfd_section_vma (sec
)
1188 + bfd_section_size (sec
) / opb
)));
1190 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1193 long newplace
= sorted_symcount
;
1195 for (i
= min
- 1; i
>= 0; i
--)
1197 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1199 if (newplace
== sorted_symcount
)
1202 if (bfd_asymbol_value (sorted_syms
[i
])
1203 != bfd_asymbol_value (sorted_syms
[newplace
]))
1206 /* Remember this symbol and keep searching until we reach
1207 an earlier address. */
1212 if (newplace
!= sorted_symcount
)
1213 thisplace
= newplace
;
1216 /* We didn't find a good symbol with a smaller value.
1217 Look for one with a larger value. */
1218 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1220 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1228 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1229 /* There is no suitable symbol. */
1233 /* If we have not found an exact match for the specified address
1234 and we have dynamic relocations available, then we can produce
1235 a better result by matching a relocation to the address and
1236 using the symbol associated with that relocation. */
1237 rel_count
= aux
->dynrelcount
;
1239 && sorted_syms
[thisplace
]->value
!= vma
1241 && aux
->dynrelbuf
!= NULL
1242 && aux
->dynrelbuf
[0]->address
<= vma
1243 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1244 /* If we have matched a synthetic symbol, then stick with that. */
1245 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1248 arelent
** rel_high
;
1250 rel_low
= aux
->dynrelbuf
;
1251 rel_high
= rel_low
+ rel_count
- 1;
1252 while (rel_low
<= rel_high
)
1254 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1255 arelent
* rel
= *rel_mid
;
1257 if (rel
->address
== vma
)
1259 /* Absolute relocations do not provide a more helpful
1260 symbolic address. Find a non-absolute relocation
1261 with the same address. */
1262 arelent
**rel_vma
= rel_mid
;
1264 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1268 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1272 if (rel
->sym_ptr_ptr
!= NULL
1273 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1276 * place
= thisplace
;
1277 return * rel
->sym_ptr_ptr
;
1283 if (vma
< rel
->address
)
1285 else if (vma
>= rel_mid
[1]->address
)
1286 rel_low
= rel_mid
+ 1;
1295 return sorted_syms
[thisplace
];
1298 /* Print an address and the offset to the nearest symbol. */
1301 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1302 bfd_vma vma
, struct disassemble_info
*inf
,
1303 bfd_boolean skip_zeroes
)
1305 objdump_print_value (vma
, inf
, skip_zeroes
);
1311 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1312 sanitize_string (bfd_section_name (sec
)));
1313 secaddr
= bfd_section_vma (sec
);
1316 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1317 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1319 else if (vma
> secaddr
)
1321 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1322 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1324 (*inf
->fprintf_func
) (inf
->stream
, ">");
1328 (*inf
->fprintf_func
) (inf
->stream
, " <");
1330 objdump_print_symname (abfd
, inf
, sym
);
1332 if (bfd_asymbol_value (sym
) == vma
)
1334 /* Undefined symbols in an executables and dynamic objects do not have
1335 a value associated with them, so it does not make sense to display
1336 an offset relative to them. Normally we would not be provided with
1337 this kind of symbol, but the target backend might choose to do so,
1338 and the code in find_symbol_for_address might return an as yet
1339 unresolved symbol associated with a dynamic reloc. */
1340 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1341 && bfd_is_und_section (sym
->section
))
1343 else if (bfd_asymbol_value (sym
) > vma
)
1345 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1346 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1348 else if (vma
> bfd_asymbol_value (sym
))
1350 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1351 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1354 (*inf
->fprintf_func
) (inf
->stream
, ">");
1357 if (display_file_offsets
)
1358 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1359 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1362 /* Print an address (VMA), symbolically if possible.
1363 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1366 objdump_print_addr (bfd_vma vma
,
1367 struct disassemble_info
*inf
,
1368 bfd_boolean skip_zeroes
)
1370 struct objdump_disasm_info
*aux
;
1371 asymbol
*sym
= NULL
;
1372 bfd_boolean skip_find
= FALSE
;
1374 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1376 if (sorted_symcount
< 1)
1378 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1379 objdump_print_value (vma
, inf
, skip_zeroes
);
1381 if (display_file_offsets
)
1382 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1383 (long int) (inf
->section
->filepos
1384 + (vma
- inf
->section
->vma
)));
1388 if (aux
->reloc
!= NULL
1389 && aux
->reloc
->sym_ptr_ptr
!= NULL
1390 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1392 sym
= * aux
->reloc
->sym_ptr_ptr
;
1394 /* Adjust the vma to the reloc. */
1395 vma
+= bfd_asymbol_value (sym
);
1397 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1402 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1404 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1408 /* Print VMA to INFO. This function is passed to the disassembler
1412 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1414 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1417 /* Determine if the given address has a symbol associated with it. */
1420 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1424 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1426 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1429 /* Hold the last function name and the last line number we displayed
1430 in a disassembly. */
1432 static char *prev_functionname
;
1433 static unsigned int prev_line
;
1434 static unsigned int prev_discriminator
;
1436 /* We keep a list of all files that we have seen when doing a
1437 disassembly with source, so that we know how much of the file to
1438 display. This can be important for inlined functions. */
1440 struct print_file_list
1442 struct print_file_list
*next
;
1443 const char *filename
;
1444 const char *modname
;
1447 const char **linemap
;
1450 unsigned max_printed
;
1454 static struct print_file_list
*print_files
;
1456 /* The number of preceding context lines to show when we start
1457 displaying a file for the first time. */
1459 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1461 /* Read a complete file into memory. */
1464 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1467 int ps
= getpagesize ();
1471 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1475 if (fstat (fd
, fst
) < 0)
1480 *size
= fst
->st_size
;
1482 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1483 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1484 if (map
!= (char *) -1L)
1490 map
= (const char *) malloc (*size
);
1491 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1493 free ((void *) map
);
1500 #define line_map_decrease 5
1502 /* Precompute array of lines for a mapped file. */
1504 static const char **
1505 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1507 const char *p
, *lstart
, *end
;
1508 int chars_per_line
= 45; /* First iteration will use 40. */
1509 unsigned int lineno
;
1510 const char **linemap
= NULL
;
1511 unsigned long line_map_size
= 0;
1517 for (p
= map
; p
< end
; p
++)
1521 if (p
+ 1 < end
&& p
[1] == '\r')
1524 else if (*p
== '\r')
1526 if (p
+ 1 < end
&& p
[1] == '\n')
1532 /* End of line found. */
1534 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1536 unsigned long newsize
;
1538 chars_per_line
-= line_map_decrease
;
1539 if (chars_per_line
<= 1)
1541 line_map_size
= size
/ chars_per_line
+ 1;
1542 if (line_map_size
< lineno
+ 1)
1543 line_map_size
= lineno
+ 1;
1544 newsize
= line_map_size
* sizeof (char *);
1545 linemap
= (const char **) xrealloc (linemap
, newsize
);
1548 linemap
[lineno
++] = lstart
;
1556 /* Tries to open MODNAME, and if successful adds a node to print_files
1557 linked list and returns that node. Returns NULL on failure. */
1559 static struct print_file_list
*
1560 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1562 struct print_file_list
*p
;
1564 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1566 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1573 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1576 p
->filename
= origname
;
1577 p
->modname
= modname
;
1578 p
->next
= print_files
;
1584 /* If the source file, as described in the symtab, is not found
1585 try to locate it in one of the paths specified with -I
1586 If found, add location to print_files linked list. */
1588 static struct print_file_list
*
1589 update_source_path (const char *filename
, bfd
*abfd
)
1591 struct print_file_list
*p
;
1596 p
= try_print_file_open (filename
, filename
, &fst
);
1599 if (include_path_count
== 0)
1602 /* Get the name of the file. */
1603 fname
= lbasename (filename
);
1605 /* If file exists under a new path, we need to add it to the list
1606 so that show_line knows about it. */
1607 for (i
= 0; i
< include_path_count
; i
++)
1609 char *modname
= concat (include_paths
[i
], "/", fname
,
1612 p
= try_print_file_open (filename
, modname
, &fst
);
1622 long mtime
= bfd_get_mtime (abfd
);
1624 if (fst
.st_mtime
> mtime
)
1625 warn (_("source file %s is more recent than object file\n"),
1632 /* Print a source file line. */
1635 print_line (struct print_file_list
*p
, unsigned int linenum
)
1641 if (linenum
>= p
->maxline
)
1643 l
= p
->linemap
[linenum
];
1644 if (source_comment
!= NULL
&& strlen (l
) > 0)
1645 printf ("%s", source_comment
);
1646 len
= strcspn (l
, "\n\r");
1647 /* Test fwrite return value to quiet glibc warning. */
1648 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1652 /* Print a range of source code lines. */
1655 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1659 while (start
<= end
)
1661 print_line (p
, start
);
1666 /* Show the line number, or the source line, in a disassembly
1670 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1672 const char *filename
;
1673 const char *functionname
;
1674 unsigned int linenumber
;
1675 unsigned int discriminator
;
1679 if (! with_line_numbers
&& ! with_source_code
)
1682 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1683 &filename
, &functionname
,
1684 &linenumber
, &discriminator
))
1687 if (filename
!= NULL
&& *filename
== '\0')
1689 if (functionname
!= NULL
&& *functionname
== '\0')
1690 functionname
= NULL
;
1693 && IS_ABSOLUTE_PATH (filename
)
1697 const char *fname
= filename
;
1699 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1702 memcpy (path
, prefix
, prefix_length
);
1703 path_up
= path
+ prefix_length
;
1705 /* Build relocated filename, stripping off leading directories
1706 from the initial filename if requested. */
1707 if (prefix_strip
> 0)
1712 /* Skip selected directory levels. */
1713 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1714 if (IS_DIR_SEPARATOR (*s
))
1721 /* Update complete filename. */
1722 strncpy (path_up
, fname
, PATH_MAX
);
1723 path_up
[PATH_MAX
] = '\0';
1731 if (with_line_numbers
)
1733 if (functionname
!= NULL
1734 && (prev_functionname
== NULL
1735 || strcmp (functionname
, prev_functionname
) != 0))
1737 char *demangle_alloc
= NULL
;
1738 if (do_demangle
&& functionname
[0] != '\0')
1740 /* Demangle the name. */
1741 demangle_alloc
= bfd_demangle (abfd
, functionname
,
1745 /* Demangling adds trailing parens, so don't print those. */
1746 if (demangle_alloc
!= NULL
)
1747 printf ("%s:\n", sanitize_string (demangle_alloc
));
1749 printf ("%s():\n", sanitize_string (functionname
));
1752 free (demangle_alloc
);
1755 && (linenumber
!= prev_line
1756 || discriminator
!= prev_discriminator
))
1758 if (discriminator
> 0)
1759 printf ("%s:%u (discriminator %u)\n",
1760 filename
== NULL
? "???" : sanitize_string (filename
),
1761 linenumber
, discriminator
);
1763 printf ("%s:%u\n", filename
== NULL
1764 ? "???" : sanitize_string (filename
),
1769 const char *filename2
;
1770 const char *functionname2
;
1773 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1776 printf ("inlined by %s:%u",
1777 sanitize_string (filename2
), line2
);
1778 printf (" (%s)\n", sanitize_string (functionname2
));
1783 if (with_source_code
1787 struct print_file_list
**pp
, *p
;
1790 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1791 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1798 filename
= xstrdup (filename
);
1799 p
= update_source_path (filename
, abfd
);
1802 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1804 if (file_start_context
&& p
->first
)
1808 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1809 if (l
>= linenumber
)
1811 if (p
->max_printed
>= l
)
1813 if (p
->max_printed
< linenumber
)
1814 l
= p
->max_printed
+ 1;
1819 dump_lines (p
, l
, linenumber
);
1820 if (p
->max_printed
< linenumber
)
1821 p
->max_printed
= linenumber
;
1822 p
->last_line
= linenumber
;
1827 if (functionname
!= NULL
1828 && (prev_functionname
== NULL
1829 || strcmp (functionname
, prev_functionname
) != 0))
1831 if (prev_functionname
!= NULL
)
1832 free (prev_functionname
);
1833 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1834 strcpy (prev_functionname
, functionname
);
1837 if (linenumber
> 0 && linenumber
!= prev_line
)
1838 prev_line
= linenumber
;
1840 if (discriminator
!= prev_discriminator
)
1841 prev_discriminator
= discriminator
;
1847 /* Pseudo FILE object for strings. */
1855 /* sprintf to a "stream". */
1857 static int ATTRIBUTE_PRINTF_2
1858 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1865 size_t space
= f
->alloc
- f
->pos
;
1867 va_start (args
, format
);
1868 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1874 f
->alloc
= (f
->alloc
+ n
) * 2;
1875 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1882 /* Code for generating (colored) diagrams of control flow start and end
1885 /* Structure used to store the properties of a jump. */
1889 /* The next jump, or NULL if this is the last object. */
1890 struct jump_info
*next
;
1891 /* The previous jump, or NULL if this is the first object. */
1892 struct jump_info
*prev
;
1893 /* The start addresses of the jump. */
1896 /* The list of start addresses. */
1898 /* The number of elements. */
1900 /* The maximum number of elements that fit into the array. */
1903 /* The end address of the jump. */
1905 /* The drawing level of the jump. */
1909 /* Construct a jump object for a jump from start
1910 to end with the corresponding level. */
1912 static struct jump_info
*
1913 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1915 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1917 result
->next
= NULL
;
1918 result
->prev
= NULL
;
1919 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1920 result
->start
.addresses
[0] = start
;
1921 result
->start
.count
= 1;
1922 result
->start
.max_count
= 2;
1924 result
->level
= level
;
1929 /* Free a jump object and return the next object
1930 or NULL if this was the last one. */
1932 static struct jump_info
*
1933 jump_info_free (struct jump_info
*ji
)
1935 struct jump_info
*result
= NULL
;
1940 if (ji
->start
.addresses
)
1941 free (ji
->start
.addresses
);
1948 /* Get the smallest value of all start and end addresses. */
1951 jump_info_min_address (const struct jump_info
*ji
)
1953 bfd_vma min_address
= ji
->end
;
1956 for (i
= ji
->start
.count
; i
-- > 0;)
1957 if (ji
->start
.addresses
[i
] < min_address
)
1958 min_address
= ji
->start
.addresses
[i
];
1962 /* Get the largest value of all start and end addresses. */
1965 jump_info_max_address (const struct jump_info
*ji
)
1967 bfd_vma max_address
= ji
->end
;
1970 for (i
= ji
->start
.count
; i
-- > 0;)
1971 if (ji
->start
.addresses
[i
] > max_address
)
1972 max_address
= ji
->start
.addresses
[i
];
1976 /* Get the target address of a jump. */
1979 jump_info_end_address (const struct jump_info
*ji
)
1984 /* Test if an address is one of the start addresses of a jump. */
1987 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
1989 bfd_boolean result
= FALSE
;
1992 for (i
= ji
->start
.count
; i
-- > 0;)
1993 if (address
== ji
->start
.addresses
[i
])
2002 /* Test if an address is the target address of a jump. */
2005 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2007 return (address
== ji
->end
);
2010 /* Get the difference between the smallest and largest address of a jump. */
2013 jump_info_size (const struct jump_info
*ji
)
2015 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2018 /* Unlink a jump object from a list. */
2021 jump_info_unlink (struct jump_info
*node
,
2022 struct jump_info
**base
)
2025 node
->next
->prev
= node
->prev
;
2027 node
->prev
->next
= node
->next
;
2034 /* Insert unlinked jump info node into a list. */
2037 jump_info_insert (struct jump_info
*node
,
2038 struct jump_info
*target
,
2039 struct jump_info
**base
)
2041 node
->next
= target
;
2042 node
->prev
= target
->prev
;
2043 target
->prev
= node
;
2045 node
->prev
->next
= node
;
2050 /* Add unlinked node to the front of a list. */
2053 jump_info_add_front (struct jump_info
*node
,
2054 struct jump_info
**base
)
2058 node
->next
->prev
= node
;
2063 /* Move linked node to target position. */
2066 jump_info_move_linked (struct jump_info
*node
,
2067 struct jump_info
*target
,
2068 struct jump_info
**base
)
2071 jump_info_unlink (node
, base
);
2072 /* Insert node at target position. */
2073 jump_info_insert (node
, target
, base
);
2076 /* Test if two jumps intersect. */
2079 jump_info_intersect (const struct jump_info
*a
,
2080 const struct jump_info
*b
)
2082 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2083 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2086 /* Merge two compatible jump info objects. */
2089 jump_info_merge (struct jump_info
**base
)
2091 struct jump_info
*a
;
2093 for (a
= *base
; a
; a
= a
->next
)
2095 struct jump_info
*b
;
2097 for (b
= a
->next
; b
; b
= b
->next
)
2099 /* Merge both jumps into one. */
2100 if (a
->end
== b
->end
)
2102 /* Reallocate addresses. */
2103 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2106 if (needed_size
> a
->start
.max_count
)
2108 a
->start
.max_count
+= b
->start
.max_count
;
2109 a
->start
.addresses
=
2110 xrealloc (a
->start
.addresses
,
2111 a
->start
.max_count
* sizeof (bfd_vma
*));
2114 /* Append start addresses. */
2115 for (i
= 0; i
< b
->start
.count
; ++i
)
2116 a
->start
.addresses
[a
->start
.count
++] =
2117 b
->start
.addresses
[i
];
2119 /* Remove and delete jump. */
2120 struct jump_info
*tmp
= b
->prev
;
2121 jump_info_unlink (b
, base
);
2129 /* Sort jumps by their size and starting point using a stable
2130 minsort. This could be improved if sorting performance is
2131 an issue, for example by using mergesort. */
2134 jump_info_sort (struct jump_info
**base
)
2136 struct jump_info
*current_element
= *base
;
2138 while (current_element
)
2140 struct jump_info
*best_match
= current_element
;
2141 struct jump_info
*runner
= current_element
->next
;
2142 bfd_vma best_size
= jump_info_size (best_match
);
2146 bfd_vma runner_size
= jump_info_size (runner
);
2148 if ((runner_size
< best_size
)
2149 || ((runner_size
== best_size
)
2150 && (jump_info_min_address (runner
)
2151 < jump_info_min_address (best_match
))))
2153 best_match
= runner
;
2154 best_size
= runner_size
;
2157 runner
= runner
->next
;
2160 if (best_match
== current_element
)
2161 current_element
= current_element
->next
;
2163 jump_info_move_linked (best_match
, current_element
, base
);
2167 /* Visualize all jumps at a given address. */
2170 jump_info_visualize_address (bfd_vma address
,
2173 uint8_t *color_buffer
)
2175 struct jump_info
*ji
= detected_jumps
;
2176 size_t len
= (max_level
+ 1) * 3;
2178 /* Clear line buffer. */
2179 memset (line_buffer
, ' ', len
);
2180 memset (color_buffer
, 0, len
);
2182 /* Iterate over jumps and add their ASCII art. */
2185 /* Discard jumps that are never needed again. */
2186 if (jump_info_max_address (ji
) < address
)
2188 struct jump_info
*tmp
= ji
;
2191 jump_info_unlink (tmp
, &detected_jumps
);
2192 jump_info_free (tmp
);
2196 /* This jump intersects with the current address. */
2197 if (jump_info_min_address (ji
) <= address
)
2199 /* Hash target address to get an even
2200 distribution between all values. */
2201 bfd_vma hash_address
= jump_info_end_address (ji
);
2202 uint8_t color
= iterative_hash_object (hash_address
, 0);
2203 /* Fetch line offset. */
2204 int offset
= (max_level
- ji
->level
) * 3;
2206 /* Draw start line. */
2207 if (jump_info_is_start_address (ji
, address
))
2209 size_t i
= offset
+ 1;
2211 for (; i
< len
- 1; ++i
)
2212 if (line_buffer
[i
] == ' ')
2214 line_buffer
[i
] = '-';
2215 color_buffer
[i
] = color
;
2218 if (line_buffer
[i
] == ' ')
2220 line_buffer
[i
] = '-';
2221 color_buffer
[i
] = color
;
2223 else if (line_buffer
[i
] == '>')
2225 line_buffer
[i
] = 'X';
2226 color_buffer
[i
] = color
;
2229 if (line_buffer
[offset
] == ' ')
2231 if (address
<= ji
->end
)
2232 line_buffer
[offset
] =
2233 (jump_info_min_address (ji
) == address
) ? '/': '+';
2235 line_buffer
[offset
] =
2236 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2237 color_buffer
[offset
] = color
;
2240 /* Draw jump target. */
2241 else if (jump_info_is_end_address (ji
, address
))
2243 size_t i
= offset
+ 1;
2245 for (; i
< len
- 1; ++i
)
2246 if (line_buffer
[i
] == ' ')
2248 line_buffer
[i
] = '-';
2249 color_buffer
[i
] = color
;
2252 if (line_buffer
[i
] == ' ')
2254 line_buffer
[i
] = '>';
2255 color_buffer
[i
] = color
;
2257 else if (line_buffer
[i
] == '-')
2259 line_buffer
[i
] = 'X';
2260 color_buffer
[i
] = color
;
2263 if (line_buffer
[offset
] == ' ')
2265 if (jump_info_min_address (ji
) < address
)
2266 line_buffer
[offset
] =
2267 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2269 line_buffer
[offset
] = '/';
2270 color_buffer
[offset
] = color
;
2273 /* Draw intermediate line segment. */
2274 else if (line_buffer
[offset
] == ' ')
2276 line_buffer
[offset
] = '|';
2277 color_buffer
[offset
] = color
;
2285 /* Clone of disassemble_bytes to detect jumps inside a function. */
2286 /* FIXME: is this correct? Can we strip it down even further? */
2288 static struct jump_info
*
2289 disassemble_jumps (struct disassemble_info
* inf
,
2290 disassembler_ftype disassemble_fn
,
2291 bfd_vma start_offset
,
2292 bfd_vma stop_offset
,
2295 arelent
** relppend
)
2297 struct objdump_disasm_info
*aux
;
2298 struct jump_info
*jumps
= NULL
;
2300 bfd_vma addr_offset
;
2301 unsigned int opb
= inf
->octets_per_byte
;
2305 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2306 section
= inf
->section
;
2309 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2312 inf
->insn_info_valid
= 0;
2313 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2314 inf
->stream
= &sfile
;
2316 addr_offset
= start_offset
;
2317 while (addr_offset
< stop_offset
)
2319 int previous_octets
;
2321 /* Remember the length of the previous instruction. */
2322 previous_octets
= octets
;
2326 inf
->bytes_per_line
= 0;
2327 inf
->bytes_per_chunk
= 0;
2328 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2329 | (wide_output
? WIDE_OUTPUT
: 0));
2331 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2333 if (inf
->disassembler_needs_relocs
2334 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2335 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2336 && *relppp
< relppend
)
2338 bfd_signed_vma distance_to_rel
;
2340 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2342 /* Check to see if the current reloc is associated with
2343 the instruction that we are about to disassemble. */
2344 if (distance_to_rel
== 0
2345 /* FIXME: This is wrong. We are trying to catch
2346 relocs that are addressed part way through the
2347 current instruction, as might happen with a packed
2348 VLIW instruction. Unfortunately we do not know the
2349 length of the current instruction since we have not
2350 disassembled it yet. Instead we take a guess based
2351 upon the length of the previous instruction. The
2352 proper solution is to have a new target-specific
2353 disassembler function which just returns the length
2354 of an instruction at a given address without trying
2355 to display its disassembly. */
2356 || (distance_to_rel
> 0
2357 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2359 inf
->flags
|= INSN_HAS_RELOC
;
2363 if (! disassemble_all
2364 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2365 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2366 /* Set a stop_vma so that the disassembler will not read
2367 beyond the next symbol. We assume that symbols appear on
2368 the boundaries between instructions. We only do this when
2369 disassembling code of course, and when -D is in effect. */
2370 inf
->stop_vma
= section
->vma
+ stop_offset
;
2372 inf
->stop_offset
= stop_offset
;
2374 /* Extract jump information. */
2375 inf
->insn_info_valid
= 0;
2376 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2377 /* Test if a jump was detected. */
2378 if (inf
->insn_info_valid
2379 && ((inf
->insn_type
== dis_branch
)
2380 || (inf
->insn_type
== dis_condbranch
)
2381 || (inf
->insn_type
== dis_jsr
)
2382 || (inf
->insn_type
== dis_condjsr
))
2383 && (inf
->target
>= section
->vma
+ start_offset
)
2384 && (inf
->target
< section
->vma
+ stop_offset
))
2386 struct jump_info
*ji
=
2387 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2388 jump_info_add_front (ji
, &jumps
);
2393 addr_offset
+= octets
/ opb
;
2396 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2397 inf
->stream
= stdout
;
2399 free (sfile
.buffer
);
2402 jump_info_merge (&jumps
);
2403 /* Process jumps. */
2404 jump_info_sort (&jumps
);
2406 /* Group jumps by level. */
2407 struct jump_info
*last_jump
= jumps
;
2412 /* The last jump is part of the next group. */
2413 struct jump_info
*base
= last_jump
;
2414 /* Increment level. */
2415 base
->level
= ++max_level
;
2417 /* Find jumps that can be combined on the same
2418 level, with the largest jumps tested first.
2419 This has the advantage that large jumps are on
2420 lower levels and do not intersect with small
2421 jumps that get grouped on higher levels. */
2422 struct jump_info
*exchange_item
= last_jump
->next
;
2423 struct jump_info
*it
= exchange_item
;
2425 for (; it
; it
= it
->next
)
2427 /* Test if the jump intersects with any
2428 jump from current group. */
2429 bfd_boolean ok
= TRUE
;
2430 struct jump_info
*it_collision
;
2432 for (it_collision
= base
;
2433 it_collision
!= exchange_item
;
2434 it_collision
= it_collision
->next
)
2436 /* This jump intersects so we leave it out. */
2437 if (jump_info_intersect (it_collision
, it
))
2444 /* Add jump to group. */
2447 /* Move current element to the front. */
2448 if (it
!= exchange_item
)
2450 struct jump_info
*save
= it
->prev
;
2451 jump_info_move_linked (it
, exchange_item
, &jumps
);
2457 last_jump
= exchange_item
;
2458 exchange_item
= exchange_item
->next
;
2460 last_jump
->level
= max_level
;
2464 /* Move to next group. */
2465 last_jump
= exchange_item
;
2471 /* The number of zeroes we want to see before we start skipping them.
2472 The number is arbitrarily chosen. */
2474 #define DEFAULT_SKIP_ZEROES 8
2476 /* The number of zeroes to skip at the end of a section. If the
2477 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2478 SKIP_ZEROES, they will be disassembled. If there are fewer than
2479 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2480 attempt to avoid disassembling zeroes inserted by section
2483 #define DEFAULT_SKIP_ZEROES_AT_END 3
2486 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2491 /* Print out jump visualization. */
2494 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2495 uint8_t *color_buffer
)
2500 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2502 size_t line_buffer_size
= strlen (line_buffer
);
2503 char last_color
= 0;
2506 for (i
= 0; i
<= line_buffer_size
; ++i
)
2510 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2512 if (color
!= last_color
)
2515 if (extended_color_output
)
2516 /* Use extended 8bit color, but
2517 do not choose dark colors. */
2518 printf ("\033[38;5;%dm", 124 + (color
% 108));
2520 /* Use simple terminal colors. */
2521 printf ("\033[%dm", 31 + (color
% 7));
2528 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2532 /* Disassemble some data in memory between given values. */
2535 disassemble_bytes (struct disassemble_info
* inf
,
2536 disassembler_ftype disassemble_fn
,
2539 bfd_vma start_offset
,
2540 bfd_vma stop_offset
,
2543 arelent
** relppend
)
2545 struct objdump_disasm_info
*aux
;
2547 int octets_per_line
;
2548 int skip_addr_chars
;
2549 bfd_vma addr_offset
;
2550 unsigned int opb
= inf
->octets_per_byte
;
2551 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2552 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2556 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2557 section
= inf
->section
;
2560 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2564 octets_per_line
= insn_width
;
2566 octets_per_line
= 4;
2568 octets_per_line
= 16;
2570 /* Figure out how many characters to skip at the start of an
2571 address, to make the disassembly look nicer. We discard leading
2572 zeroes in chunks of 4, ensuring that there is always a leading
2574 skip_addr_chars
= 0;
2575 if (! prefix_addresses
)
2579 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2581 while (buf
[skip_addr_chars
] == '0')
2584 /* Don't discard zeros on overflow. */
2585 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2586 skip_addr_chars
= 0;
2588 if (skip_addr_chars
!= 0)
2589 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2592 inf
->insn_info_valid
= 0;
2594 /* Determine maximum level. */
2595 uint8_t *color_buffer
= NULL
;
2596 char *line_buffer
= NULL
;
2599 /* Some jumps were detected. */
2602 struct jump_info
*ji
;
2604 /* Find maximum jump level. */
2605 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2607 if (ji
->level
> max_level
)
2608 max_level
= ji
->level
;
2611 /* Allocate buffers. */
2612 size_t len
= (max_level
+ 1) * 3 + 1;
2613 line_buffer
= xmalloc (len
);
2614 line_buffer
[len
- 1] = 0;
2615 color_buffer
= xmalloc (len
);
2616 color_buffer
[len
- 1] = 0;
2619 addr_offset
= start_offset
;
2620 while (addr_offset
< stop_offset
)
2623 bfd_boolean need_nl
= FALSE
;
2627 /* Make sure we don't use relocs from previous instructions. */
2630 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2632 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2635 if (! disassemble_zeroes
2636 && (inf
->insn_info_valid
== 0
2637 || inf
->branch_delay_insns
== 0)
2638 && (z
- addr_offset
* opb
>= skip_zeroes
2639 || (z
== stop_offset
* opb
&&
2640 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2642 /* If there are more nonzero octets to follow, we only skip
2643 zeroes in multiples of 4, to try to avoid running over
2644 the start of an instruction which happens to start with
2646 if (z
!= stop_offset
* opb
)
2647 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2649 octets
= z
- addr_offset
* opb
;
2651 /* If we are going to display more data, and we are displaying
2652 file offsets, then tell the user how many zeroes we skip
2653 and the file offset from where we resume dumping. */
2654 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2655 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2657 (unsigned long) (section
->filepos
2658 + (addr_offset
+ (octets
/ opb
))));
2668 if (with_line_numbers
|| with_source_code
)
2669 show_line (aux
->abfd
, section
, addr_offset
);
2671 if (! prefix_addresses
)
2675 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2676 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2680 printf ("%s:\t", buf
+ skip_addr_chars
);
2684 aux
->require_sec
= TRUE
;
2685 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2686 aux
->require_sec
= FALSE
;
2690 print_jump_visualisation (section
->vma
+ addr_offset
,
2691 max_level
, line_buffer
,
2697 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2698 inf
->stream
= &sfile
;
2699 inf
->bytes_per_line
= 0;
2700 inf
->bytes_per_chunk
= 0;
2701 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2702 | (wide_output
? WIDE_OUTPUT
: 0));
2704 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2706 if (inf
->disassembler_needs_relocs
2707 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2708 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2709 && *relppp
< relppend
)
2711 bfd_signed_vma distance_to_rel
;
2713 int max_reloc_offset
2714 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2716 distance_to_rel
= ((**relppp
)->address
- rel_offset
2719 if (distance_to_rel
> 0
2720 && (max_reloc_offset
< 0
2721 || distance_to_rel
<= max_reloc_offset
))
2723 /* This reloc *might* apply to the current insn,
2724 starting somewhere inside it. Discover the length
2725 of the current insn so that the check below will
2728 insn_size
= insn_width
;
2731 /* We find the length by calling the dissassembler
2732 function with a dummy print handler. This should
2733 work unless the disassembler is not expecting to
2734 be called multiple times for the same address.
2736 This does mean disassembling the instruction
2737 twice, but we only do this when there is a high
2738 probability that there is a reloc that will
2739 affect the instruction. */
2740 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2741 insn_size
= disassemble_fn (section
->vma
2742 + addr_offset
, inf
);
2743 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2747 /* Check to see if the current reloc is associated with
2748 the instruction that we are about to disassemble. */
2749 if (distance_to_rel
== 0
2750 || (distance_to_rel
> 0
2751 && distance_to_rel
< insn_size
/ (int) opb
))
2753 inf
->flags
|= INSN_HAS_RELOC
;
2754 aux
->reloc
= **relppp
;
2758 if (! disassemble_all
2759 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2760 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2761 /* Set a stop_vma so that the disassembler will not read
2762 beyond the next symbol. We assume that symbols appear on
2763 the boundaries between instructions. We only do this when
2764 disassembling code of course, and when -D is in effect. */
2765 inf
->stop_vma
= section
->vma
+ stop_offset
;
2767 inf
->stop_offset
= stop_offset
;
2768 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2771 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2772 inf
->stream
= stdout
;
2773 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2774 octets_per_line
= inf
->bytes_per_line
;
2775 if (octets
< (int) opb
)
2778 printf ("%s\n", sfile
.buffer
);
2781 non_fatal (_("disassemble_fn returned length %d"),
2792 octets
= octets_per_line
;
2793 if (addr_offset
+ octets
/ opb
> stop_offset
)
2794 octets
= (stop_offset
- addr_offset
) * opb
;
2796 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2798 if (ISPRINT (data
[j
]))
2799 buf
[j
- addr_offset
* opb
] = data
[j
];
2801 buf
[j
- addr_offset
* opb
] = '.';
2803 buf
[j
- addr_offset
* opb
] = '\0';
2806 if (prefix_addresses
2808 : show_raw_insn
>= 0)
2812 /* If ! prefix_addresses and ! wide_output, we print
2813 octets_per_line octets per line. */
2815 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2816 pb
= octets_per_line
;
2818 if (inf
->bytes_per_chunk
)
2819 bpc
= inf
->bytes_per_chunk
;
2823 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2825 /* PR 21580: Check for a buffer ending early. */
2826 if (j
+ bpc
<= stop_offset
* opb
)
2830 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2832 for (k
= bpc
- 1; k
>= 0; k
--)
2833 printf ("%02x", (unsigned) data
[j
+ k
]);
2837 for (k
= 0; k
< bpc
; k
++)
2838 printf ("%02x", (unsigned) data
[j
+ k
]);
2844 for (; pb
< octets_per_line
; pb
+= bpc
)
2848 for (k
= 0; k
< bpc
; k
++)
2853 /* Separate raw data from instruction by extra space. */
2863 printf ("%s", sfile
.buffer
);
2865 if (prefix_addresses
2867 : show_raw_insn
>= 0)
2875 j
= addr_offset
* opb
+ pb
;
2877 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2878 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2882 printf ("%s:\t", buf
+ skip_addr_chars
);
2884 print_jump_visualisation (section
->vma
+ j
/ opb
,
2885 max_level
, line_buffer
,
2888 pb
+= octets_per_line
;
2891 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2893 /* PR 21619: Check for a buffer ending early. */
2894 if (j
+ bpc
<= stop_offset
* opb
)
2898 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2900 for (k
= bpc
- 1; k
>= 0; k
--)
2901 printf ("%02x", (unsigned) data
[j
+ k
]);
2905 for (k
= 0; k
< bpc
; k
++)
2906 printf ("%02x", (unsigned) data
[j
+ k
]);
2920 while ((*relppp
) < relppend
2921 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2923 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2934 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2937 if (q
->howto
== NULL
)
2938 printf (": *unknown*\t");
2939 else if (q
->howto
->name
)
2940 printf (": %s\t", q
->howto
->name
);
2942 printf (": %d\t", q
->howto
->type
);
2944 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2945 printf ("*unknown*");
2948 const char *sym_name
;
2950 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2951 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2952 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2957 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2958 sym_name
= bfd_section_name (sym_sec
);
2959 if (sym_name
== NULL
|| *sym_name
== '\0')
2960 sym_name
= "*unknown*";
2961 printf ("%s", sanitize_string (sym_name
));
2967 bfd_signed_vma addend
= q
->addend
;
2975 objdump_print_value (addend
, inf
, TRUE
);
2987 addr_offset
+= octets
/ opb
;
2990 free (sfile
.buffer
);
2992 free (color_buffer
);
2996 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2998 const struct elf_backend_data
* bed
;
2999 bfd_vma sign_adjust
= 0;
3000 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
3001 struct objdump_disasm_info
* paux
;
3002 unsigned int opb
= pinfo
->octets_per_byte
;
3003 bfd_byte
* data
= NULL
;
3004 bfd_size_type datasize
= 0;
3005 arelent
** rel_pp
= NULL
;
3006 arelent
** rel_ppstart
= NULL
;
3007 arelent
** rel_ppend
;
3008 bfd_vma stop_offset
;
3009 asymbol
* sym
= NULL
;
3013 unsigned long addr_offset
;
3014 bfd_boolean do_print
;
3017 stop_offset_reached
,
3022 /* Sections that do not contain machine
3023 code are not normally disassembled. */
3024 if (! disassemble_all
3025 && only_list
== NULL
3026 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3027 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3030 if (! process_section_p (section
))
3033 datasize
= bfd_section_size (section
);
3037 if (start_address
== (bfd_vma
) -1
3038 || start_address
< section
->vma
)
3041 addr_offset
= start_address
- section
->vma
;
3043 if (stop_address
== (bfd_vma
) -1)
3044 stop_offset
= datasize
/ opb
;
3047 if (stop_address
< section
->vma
)
3050 stop_offset
= stop_address
- section
->vma
;
3051 if (stop_offset
> datasize
/ opb
)
3052 stop_offset
= datasize
/ opb
;
3055 if (addr_offset
>= stop_offset
)
3058 /* Decide which set of relocs to use. Load them if necessary. */
3059 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3060 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3062 rel_pp
= paux
->dynrelbuf
;
3063 rel_count
= paux
->dynrelcount
;
3064 /* Dynamic reloc addresses are absolute, non-dynamic are section
3065 relative. REL_OFFSET specifies the reloc address corresponding
3066 to the start of this section. */
3067 rel_offset
= section
->vma
;
3075 if ((section
->flags
& SEC_RELOC
) != 0
3076 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3080 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3082 bfd_fatal (bfd_get_filename (abfd
));
3086 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3087 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3089 bfd_fatal (bfd_get_filename (abfd
));
3091 /* Sort the relocs by address. */
3092 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3096 rel_ppend
= rel_pp
+ rel_count
;
3098 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3100 non_fatal (_("Reading section %s failed because: %s"),
3101 section
->name
, bfd_errmsg (bfd_get_error ()));
3105 pinfo
->buffer
= data
;
3106 pinfo
->buffer_vma
= section
->vma
;
3107 pinfo
->buffer_length
= datasize
;
3108 pinfo
->section
= section
;
3110 /* Sort the symbols into value and section order. */
3111 compare_section
= section
;
3112 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3114 /* Skip over the relocs belonging to addresses below the
3116 while (rel_pp
< rel_ppend
3117 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3120 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3122 /* Find the nearest symbol forwards from our current position. */
3123 paux
->require_sec
= TRUE
;
3124 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3125 (struct disassemble_info
*) inf
,
3127 paux
->require_sec
= FALSE
;
3129 /* PR 9774: If the target used signed addresses then we must make
3130 sure that we sign extend the value that we calculate for 'addr'
3131 in the loop below. */
3132 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3133 && (bed
= get_elf_backend_data (abfd
)) != NULL
3134 && bed
->sign_extend_vma
)
3135 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3137 /* Disassemble a block of instructions up to the address associated with
3138 the symbol we have just found. Then print the symbol and find the
3139 next symbol on. Repeat until we have disassembled the entire section
3140 or we have reached the end of the address range we are interested in. */
3141 do_print
= paux
->symbol
== NULL
;
3142 loop_until
= stop_offset_reached
;
3144 while (addr_offset
< stop_offset
)
3148 bfd_vma nextstop_offset
;
3151 addr
= section
->vma
+ addr_offset
;
3152 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3154 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3159 (x
< sorted_symcount
3160 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3164 pinfo
->symbols
= sorted_syms
+ place
;
3165 pinfo
->num_symbols
= x
- place
;
3166 pinfo
->symtab_pos
= place
;
3170 pinfo
->symbols
= NULL
;
3171 pinfo
->num_symbols
= 0;
3172 pinfo
->symtab_pos
= -1;
3175 /* If we are only disassembling from a specific symbol,
3176 check to see if we should start or stop displaying. */
3177 if (sym
&& paux
->symbol
)
3181 /* See if we should stop printing. */
3185 if (sym
->flags
& BSF_FUNCTION
)
3189 case stop_offset_reached
:
3190 /* Handled by the while loop. */
3194 /* FIXME: There is an implicit assumption here
3195 that the name of sym is different from
3197 if (! bfd_is_local_label (abfd
, sym
))
3204 const char * name
= bfd_asymbol_name (sym
);
3205 char * alloc
= NULL
;
3207 if (do_demangle
&& name
[0] != '\0')
3209 /* Demangle the name. */
3210 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3215 /* We are not currently printing. Check to see
3216 if the current symbol matches the requested symbol. */
3217 if (streq (name
, paux
->symbol
))
3221 if (sym
->flags
& BSF_FUNCTION
)
3223 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3224 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3226 /* Sym is a function symbol with a size associated
3227 with it. Turn on automatic disassembly for the
3228 next VALUE bytes. */
3229 stop_offset
= addr_offset
3230 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3231 loop_until
= stop_offset_reached
;
3235 /* Otherwise we need to tell the loop heuristic to
3236 loop until the next function symbol is encountered. */
3237 loop_until
= function_sym
;
3242 /* Otherwise loop until the next symbol is encountered. */
3243 loop_until
= next_sym
;
3251 if (! prefix_addresses
&& do_print
)
3253 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3254 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3256 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3259 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3261 else if (sym
== NULL
)
3265 #define is_valid_next_sym(SYM) \
3266 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3267 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3268 && pinfo->symbol_is_valid (SYM, pinfo))
3270 /* Search forward for the next appropriate symbol in
3271 SECTION. Note that all the symbols are sorted
3272 together into one big array, and that some sections
3273 may have overlapping addresses. */
3274 while (place
< sorted_symcount
3275 && ! is_valid_next_sym (sorted_syms
[place
]))
3278 if (place
>= sorted_symcount
)
3281 nextsym
= sorted_syms
[place
];
3284 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3285 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3286 else if (nextsym
== NULL
)
3287 nextstop_offset
= stop_offset
;
3289 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3291 if (nextstop_offset
> stop_offset
3292 || nextstop_offset
<= addr_offset
)
3293 nextstop_offset
= stop_offset
;
3295 /* If a symbol is explicitly marked as being an object
3296 rather than a function, just dump the bytes without
3297 disassembling them. */
3300 || sym
->section
!= section
3301 || bfd_asymbol_value (sym
) > addr
3302 || ((sym
->flags
& BSF_OBJECT
) == 0
3303 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3305 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3307 || (sym
->flags
& BSF_FUNCTION
) != 0)
3314 /* Resolve symbol name. */
3315 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3317 struct disassemble_info di
;
3320 sf
.alloc
= strlen (sym
->name
) + 40;
3321 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3323 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3326 objdump_print_symname (abfd
, &di
, sym
);
3328 /* Fetch jump information. */
3329 detected_jumps
= disassemble_jumps
3330 (pinfo
, paux
->disassemble_fn
,
3331 addr_offset
, nextstop_offset
,
3332 rel_offset
, &rel_pp
, rel_ppend
);
3334 /* Free symbol name. */
3338 /* Add jumps to output. */
3339 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3340 addr_offset
, nextstop_offset
,
3341 rel_offset
, &rel_pp
, rel_ppend
);
3344 while (detected_jumps
)
3346 detected_jumps
= jump_info_free (detected_jumps
);
3350 addr_offset
= nextstop_offset
;
3356 if (rel_ppstart
!= NULL
)
3360 /* Disassemble the contents of an object file. */
3363 disassemble_data (bfd
*abfd
)
3365 struct disassemble_info disasm_info
;
3366 struct objdump_disasm_info aux
;
3370 prev_functionname
= NULL
;
3372 prev_discriminator
= 0;
3374 /* We make a copy of syms to sort. We don't want to sort syms
3375 because that will screw up the relocs. */
3376 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3377 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3378 * sizeof (asymbol
*));
3379 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3380 sorted_symcount
* sizeof (asymbol
*));
3382 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3384 for (i
= 0; i
< synthcount
; ++i
)
3386 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3390 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3392 disasm_info
.application_data
= (void *) &aux
;
3394 aux
.require_sec
= FALSE
;
3395 aux
.dynrelbuf
= NULL
;
3396 aux
.dynrelcount
= 0;
3398 aux
.symbol
= disasm_sym
;
3400 disasm_info
.print_address_func
= objdump_print_address
;
3401 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3403 if (machine
!= NULL
)
3405 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3408 fatal (_("can't use supplied machine %s"), machine
);
3410 abfd
->arch_info
= inf
;
3413 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3415 struct bfd_target
*xvec
;
3417 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3418 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3419 xvec
->byteorder
= endian
;
3423 /* Use libopcodes to locate a suitable disassembler. */
3424 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3425 bfd_big_endian (abfd
),
3426 bfd_get_mach (abfd
), abfd
);
3427 if (!aux
.disassemble_fn
)
3429 non_fatal (_("can't disassemble for architecture %s\n"),
3430 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3435 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3436 disasm_info
.arch
= bfd_get_arch (abfd
);
3437 disasm_info
.mach
= bfd_get_mach (abfd
);
3438 disasm_info
.disassembler_options
= disassembler_options
;
3439 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3440 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3441 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3442 disasm_info
.disassembler_needs_relocs
= FALSE
;
3444 if (bfd_big_endian (abfd
))
3445 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3446 else if (bfd_little_endian (abfd
))
3447 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3449 /* ??? Aborting here seems too drastic. We could default to big or little
3451 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3453 /* Allow the target to customize the info structure. */
3454 disassemble_init_for_target (& disasm_info
);
3456 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3458 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3460 if (relsize
< 0 && dump_dynamic_reloc_info
)
3461 bfd_fatal (bfd_get_filename (abfd
));
3465 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3466 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3469 if (aux
.dynrelcount
< 0)
3470 bfd_fatal (bfd_get_filename (abfd
));
3472 /* Sort the relocs by address. */
3473 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3477 disasm_info
.symtab
= sorted_syms
;
3478 disasm_info
.symtab_size
= sorted_symcount
;
3480 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3482 if (aux
.dynrelbuf
!= NULL
)
3483 free (aux
.dynrelbuf
);
3485 disassemble_free_target (&disasm_info
);
3489 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3490 asection
*sec
, void *file
)
3492 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3493 bfd
*abfd
= (bfd
*) file
;
3498 if (section
->start
!= NULL
)
3500 /* If it is already loaded, do nothing. */
3501 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3503 free (section
->start
);
3506 section
->filename
= bfd_get_filename (abfd
);
3507 section
->reloc_info
= NULL
;
3508 section
->num_relocs
= 0;
3509 section
->address
= bfd_section_vma (sec
);
3510 section
->user_data
= sec
;
3511 section
->size
= bfd_section_size (sec
);
3512 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3513 alloced
= amt
= section
->size
+ 1;
3514 if (alloced
!= amt
|| alloced
== 0)
3516 section
->start
= NULL
;
3517 free_debug_section (debug
);
3518 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3519 sanitize_string (section
->name
),
3520 (unsigned long long) section
->size
);
3523 section
->start
= contents
= malloc (alloced
);
3524 if (section
->start
== NULL
3525 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3527 free_debug_section (debug
);
3528 printf (_("\nCan't get contents for section '%s'.\n"),
3529 sanitize_string (section
->name
));
3532 /* Ensure any string section has a terminating NUL. */
3533 section
->start
[section
->size
] = 0;
3535 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3536 && debug_displays
[debug
].relocate
)
3541 bfd_cache_section_contents (sec
, section
->start
);
3543 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3550 free_debug_section (debug
);
3551 printf (_("\nCan't get contents for section '%s'.\n"),
3552 sanitize_string (section
->name
));
3556 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3559 unsigned long reloc_count
;
3562 relocs
= (arelent
**) xmalloc (reloc_size
);
3564 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3565 if (reloc_count
== 0)
3569 section
->reloc_info
= relocs
;
3570 section
->num_relocs
= reloc_count
;
3579 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3584 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3587 relocs
= (arelent
**) dsec
->reloc_info
;
3589 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3590 if (rp
->address
== offset
)
3597 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3599 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3600 bfd
*abfd
= (bfd
*) file
;
3603 /* If it is already loaded, do nothing. */
3604 if (section
->start
!= NULL
)
3606 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3610 /* Locate the debug section. */
3611 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3613 section
->name
= section
->uncompressed_name
;
3616 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3618 section
->name
= section
->compressed_name
;
3623 return load_specific_debug_section (debug
, sec
, file
);
3627 free_debug_section (enum dwarf_section_display_enum debug
)
3629 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3631 if (section
->start
== NULL
)
3634 /* PR 17512: file: 0f67f69d. */
3635 if (section
->user_data
!= NULL
)
3637 asection
* sec
= (asection
*) section
->user_data
;
3639 /* If we are freeing contents that are also pointed to by the BFD
3640 library's section structure then make sure to update those pointers
3641 too. Otherwise, the next time we try to load data for this section
3642 we can end up using a stale pointer. */
3643 if (section
->start
== sec
->contents
)
3645 sec
->contents
= NULL
;
3646 sec
->flags
&= ~ SEC_IN_MEMORY
;
3647 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3651 free ((char *) section
->start
);
3652 section
->start
= NULL
;
3653 section
->address
= 0;
3658 close_debug_file (void * file
)
3660 bfd
* abfd
= (bfd
*) file
;
3666 open_debug_file (const char * pathname
)
3670 data
= bfd_openr (pathname
, NULL
);
3674 if (! bfd_check_format (data
, bfd_object
))
3680 #if HAVE_LIBDEBUGINFOD
3681 /* Return a hex string represention of the build-id. */
3684 get_build_id (void * data
)
3687 char * build_id_str
;
3688 bfd
* abfd
= (bfd
*) data
;
3689 const struct bfd_build_id
* build_id
;
3691 build_id
= abfd
->build_id
;
3692 if (build_id
== NULL
)
3695 build_id_str
= malloc (build_id
->size
* 2 + 1);
3696 if (build_id_str
== NULL
)
3699 for (i
= 0; i
< build_id
->size
; i
++)
3700 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3701 build_id_str
[build_id
->size
* 2] = '\0';
3703 return (unsigned char *)build_id_str
;
3705 #endif /* HAVE_LIBDEBUGINFOD */
3708 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3709 void *arg ATTRIBUTE_UNUSED
)
3711 const char *name
= bfd_section_name (section
);
3715 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3716 match
= ".debug_info";
3720 for (i
= 0; i
< max
; i
++)
3721 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3722 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3723 && debug_displays
[i
].enabled
!= NULL
3724 && *debug_displays
[i
].enabled
)
3726 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3728 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3729 sec
->name
= sec
->uncompressed_name
;
3731 sec
->name
= sec
->compressed_name
;
3732 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3735 debug_displays
[i
].display (sec
, abfd
);
3737 if (i
!= info
&& i
!= abbrev
)
3738 free_debug_section ((enum dwarf_section_display_enum
) i
);
3744 /* Dump the dwarf debugging information. */
3747 dump_dwarf (bfd
*abfd
)
3749 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3750 if (byte_get
== NULL
)
3752 warn (_("File %s does not contain any dwarf debug information\n"),
3753 bfd_get_filename (abfd
));
3757 switch (bfd_get_arch (abfd
))
3760 /* S12Z has a 24 bit address space. But the only known
3761 producer of dwarf_info encodes addresses into 32 bits. */
3766 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3770 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3771 bfd_get_mach (abfd
));
3773 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3776 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3777 it. Return NULL on failure. */
3780 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3781 bfd_size_type
*entsize_ptr
)
3786 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3787 if (stabsect
== NULL
)
3789 printf (_("No %s section present\n\n"),
3790 sanitize_string (sect_name
));
3794 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3796 non_fatal (_("reading %s section of %s failed: %s"),
3797 sect_name
, bfd_get_filename (abfd
),
3798 bfd_errmsg (bfd_get_error ()));
3804 *size_ptr
= bfd_section_size (stabsect
);
3806 *entsize_ptr
= stabsect
->entsize
;
3811 /* Stabs entries use a 12 byte format:
3812 4 byte string table index
3814 1 byte stab other field
3815 2 byte stab desc field
3817 FIXME: This will have to change for a 64 bit object format. */
3819 #define STRDXOFF (0)
3821 #define OTHEROFF (5)
3824 #define STABSIZE (12)
3826 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3827 using string table section STRSECT_NAME (in `strtab'). */
3830 print_section_stabs (bfd
*abfd
,
3831 const char *stabsect_name
,
3832 unsigned *string_offset_ptr
)
3835 unsigned file_string_table_offset
= 0;
3836 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3837 bfd_byte
*stabp
, *stabs_end
;
3840 stabs_end
= stabp
+ stab_size
;
3842 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3843 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3845 /* Loop through all symbols and print them.
3847 We start the index at -1 because there is a dummy symbol on
3848 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3849 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3853 unsigned char type
, other
;
3854 unsigned short desc
;
3857 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3858 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3859 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3860 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3861 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3863 printf ("\n%-6d ", i
);
3864 /* Either print the stab name, or, if unnamed, print its number
3865 again (makes consistent formatting for tools like awk). */
3866 name
= bfd_get_stab_name (type
);
3868 printf ("%-6s", sanitize_string (name
));
3869 else if (type
== N_UNDF
)
3872 printf ("%-6d", type
);
3873 printf (" %-6d %-6d ", other
, desc
);
3874 bfd_printf_vma (abfd
, value
);
3875 printf (" %-6lu", strx
);
3877 /* Symbols with type == 0 (N_UNDF) specify the length of the
3878 string table associated with this file. We use that info
3879 to know how to relocate the *next* file's string table indices. */
3882 file_string_table_offset
= next_file_string_table_offset
;
3883 next_file_string_table_offset
+= value
;
3887 bfd_size_type amt
= strx
+ file_string_table_offset
;
3889 /* Using the (possibly updated) string table offset, print the
3890 string (if any) associated with this symbol. */
3891 if (amt
< stabstr_size
)
3892 /* PR 17512: file: 079-79389-0.001:0.1.
3893 FIXME: May need to sanitize this string before displaying. */
3894 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3900 *string_offset_ptr
= next_file_string_table_offset
;
3905 const char * section_name
;
3906 const char * string_section_name
;
3907 unsigned string_offset
;
3912 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3915 stab_section_names
* sought
= (stab_section_names
*) names
;
3917 /* Check for section names for which stabsect_name is a prefix, to
3918 handle .stab.N, etc. */
3919 len
= strlen (sought
->section_name
);
3921 /* If the prefix matches, and the files section name ends with a
3922 nul or a digit, then we match. I.e., we want either an exact
3923 match or a section followed by a number. */
3924 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3925 && (section
->name
[len
] == 0
3926 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3929 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3930 &stabstr_size
, NULL
);
3934 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3936 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3942 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3944 stab_section_names s
;
3946 s
.section_name
= stabsect_name
;
3947 s
.string_section_name
= strsect_name
;
3948 s
.string_offset
= 0;
3950 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3956 /* Dump the any sections containing stabs debugging information. */
3959 dump_stabs (bfd
*abfd
)
3961 dump_stabs_section (abfd
, ".stab", ".stabstr");
3962 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3963 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3966 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3968 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3972 dump_bfd_header (bfd
*abfd
)
3976 printf (_("architecture: %s, "),
3977 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3978 bfd_get_mach (abfd
)));
3979 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3981 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
3982 PF (HAS_RELOC
, "HAS_RELOC");
3983 PF (EXEC_P
, "EXEC_P");
3984 PF (HAS_LINENO
, "HAS_LINENO");
3985 PF (HAS_DEBUG
, "HAS_DEBUG");
3986 PF (HAS_SYMS
, "HAS_SYMS");
3987 PF (HAS_LOCALS
, "HAS_LOCALS");
3988 PF (DYNAMIC
, "DYNAMIC");
3989 PF (WP_TEXT
, "WP_TEXT");
3990 PF (D_PAGED
, "D_PAGED");
3991 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3992 printf (_("\nstart address 0x"));
3993 bfd_printf_vma (abfd
, abfd
->start_address
);
3998 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3999 it is passed, or a pointer to newly-allocated storage, in which case
4000 dump_ctf() will free it when it no longer needs it. */
4003 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4006 const char *blanks
= arg
;
4009 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4014 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4016 make_ctfsect (const char *name
, bfd_byte
*data
,
4021 ctfsect
.cts_name
= name
;
4022 ctfsect
.cts_entsize
= 1;
4023 ctfsect
.cts_size
= size
;
4024 ctfsect
.cts_data
= data
;
4029 /* Dump one CTF archive member. */
4032 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4034 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4035 const char *things
[] = {"Header", "Labels", "Data objects",
4036 "Function objects", "Variables", "Types", "Strings",
4041 /* Only print out the name of non-default-named archive members.
4042 The name .ctf appears everywhere, even for things that aren't
4043 really archives, so printing it out is liable to be confusing.
4045 The parent, if there is one, is the default-owned archive member:
4046 avoid importing it into itself. (This does no harm, but looks
4049 if (strcmp (name
, ".ctf") != 0)
4051 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4052 ctf_import (ctf
, parent
);
4055 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4057 ctf_dump_state_t
*s
= NULL
;
4060 printf ("\n %s:\n", *thing
);
4061 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4062 (void *) " ")) != NULL
)
4064 printf ("%s\n", item
);
4068 if (ctf_errno (ctf
))
4070 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4071 ctf_errmsg (ctf_errno (ctf
)));
4078 /* Dump the CTF debugging information. */
4081 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4083 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4084 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4085 bfd_size_type ctfsize
, parentsize
;
4087 ctf_file_t
*parent
= NULL
;
4090 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4091 bfd_fatal (bfd_get_filename (abfd
));
4094 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4096 bfd_fatal (bfd_get_filename (abfd
));
4098 /* Load the CTF file and dump it. */
4100 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4101 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4103 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4104 bfd_fatal (bfd_get_filename (abfd
));
4109 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4110 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4112 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4113 bfd_fatal (bfd_get_filename (abfd
));
4116 lookparent
= parenta
;
4121 /* Assume that the applicable parent archive member is the default one.
4122 (This is what all known implementations are expected to do, if they
4123 put CTFs and their parents in archives together.) */
4124 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4126 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4127 bfd_fatal (bfd_get_filename (abfd
));
4130 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4132 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4133 ctf_file_close (parent
);
4135 ctf_close (parenta
);
4142 dump_bfd_private_header (bfd
*abfd
)
4144 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4145 non_fatal (_("warning: private headers incomplete: %s"),
4146 bfd_errmsg (bfd_get_error ()));
4150 dump_target_specific (bfd
*abfd
)
4152 const struct objdump_private_desc
* const *desc
;
4153 struct objdump_private_option
*opt
;
4156 /* Find the desc. */
4157 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4158 if ((*desc
)->filter (abfd
))
4163 non_fatal (_("option -P/--private not supported by this file"));
4167 /* Clear all options. */
4168 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4169 opt
->selected
= FALSE
;
4171 /* Decode options. */
4172 b
= dump_private_options
;
4175 e
= strchr (b
, ',');
4180 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4181 if (strcmp (opt
->name
, b
) == 0)
4183 opt
->selected
= TRUE
;
4186 if (opt
->name
== NULL
)
4187 non_fatal (_("target specific dump '%s' not supported"), b
);
4198 (*desc
)->dump (abfd
);
4201 /* Display a section in hexadecimal format with associated characters.
4202 Each line prefixed by the zero padded address. */
4205 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4207 bfd_byte
*data
= NULL
;
4208 bfd_size_type datasize
;
4209 bfd_vma addr_offset
;
4210 bfd_vma start_offset
;
4211 bfd_vma stop_offset
;
4212 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4213 /* Bytes per line. */
4214 const int onaline
= 16;
4219 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4222 if (! process_section_p (section
))
4225 if ((datasize
= bfd_section_size (section
)) == 0)
4228 /* Compute the address range to display. */
4229 if (start_address
== (bfd_vma
) -1
4230 || start_address
< section
->vma
)
4233 start_offset
= start_address
- section
->vma
;
4235 if (stop_address
== (bfd_vma
) -1)
4236 stop_offset
= datasize
/ opb
;
4239 if (stop_address
< section
->vma
)
4242 stop_offset
= stop_address
- section
->vma
;
4244 if (stop_offset
> datasize
/ opb
)
4245 stop_offset
= datasize
/ opb
;
4248 if (start_offset
>= stop_offset
)
4251 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4252 if (display_file_offsets
)
4253 printf (_(" (Starting at file offset: 0x%lx)"),
4254 (unsigned long) (section
->filepos
+ start_offset
));
4257 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4259 non_fatal (_("Reading section %s failed because: %s"),
4260 section
->name
, bfd_errmsg (bfd_get_error ()));
4266 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4267 if (strlen (buf
) >= sizeof (buf
))
4271 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4273 count
= strlen (buf
) - count
;
4277 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4278 if (strlen (buf
) >= sizeof (buf
))
4282 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4284 count
= strlen (buf
) - count
;
4288 for (addr_offset
= start_offset
;
4289 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4293 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4294 count
= strlen (buf
);
4295 if ((size_t) count
>= sizeof (buf
))
4299 while (count
< width
)
4304 fputs (buf
+ count
- width
, stdout
);
4307 for (j
= addr_offset
* opb
;
4308 j
< addr_offset
* opb
+ onaline
; j
++)
4310 if (j
< stop_offset
* opb
)
4311 printf ("%02x", (unsigned) (data
[j
]));
4319 for (j
= addr_offset
* opb
;
4320 j
< addr_offset
* opb
+ onaline
; j
++)
4322 if (j
>= stop_offset
* opb
)
4325 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4332 /* Actually display the various requested regions. */
4335 dump_data (bfd
*abfd
)
4337 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4340 /* Should perhaps share code and display with nm? */
4343 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4352 max_count
= dynsymcount
;
4353 printf ("DYNAMIC SYMBOL TABLE:\n");
4358 max_count
= symcount
;
4359 printf ("SYMBOL TABLE:\n");
4363 printf (_("no symbols\n"));
4365 for (count
= 0; count
< max_count
; count
++)
4369 if (*current
== NULL
)
4370 printf (_("no information for symbol number %ld\n"), count
);
4372 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4373 printf (_("could not determine the type of symbol number %ld\n"),
4376 else if (process_section_p ((* current
)->section
)
4377 && (dump_special_syms
4378 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4380 const char *name
= (*current
)->name
;
4382 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4386 /* If we want to demangle the name, we demangle it
4387 here, and temporarily clobber it while calling
4388 bfd_print_symbol. FIXME: This is a gross hack. */
4389 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4391 (*current
)->name
= alloc
;
4392 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4393 bfd_print_symbol_all
);
4396 (*current
)->name
= name
;
4401 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4402 bfd_print_symbol_all
);
4412 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4415 char *last_filename
, *last_functionname
;
4416 unsigned int last_line
;
4417 unsigned int last_discriminator
;
4419 /* Get column headers lined up reasonably. */
4427 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4428 width
= strlen (buf
) - 7;
4430 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4433 last_filename
= NULL
;
4434 last_functionname
= NULL
;
4436 last_discriminator
= 0;
4438 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4441 const char *filename
, *functionname
;
4442 unsigned int linenumber
;
4443 unsigned int discriminator
;
4444 const char *sym_name
;
4445 const char *section_name
;
4446 bfd_vma addend2
= 0;
4448 if (start_address
!= (bfd_vma
) -1
4449 && q
->address
< start_address
)
4451 if (stop_address
!= (bfd_vma
) -1
4452 && q
->address
> stop_address
)
4455 if (with_line_numbers
4457 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4458 &filename
, &functionname
,
4459 &linenumber
, &discriminator
))
4461 if (functionname
!= NULL
4462 && (last_functionname
== NULL
4463 || strcmp (functionname
, last_functionname
) != 0))
4465 printf ("%s():\n", sanitize_string (functionname
));
4466 if (last_functionname
!= NULL
)
4467 free (last_functionname
);
4468 last_functionname
= xstrdup (functionname
);
4472 && (linenumber
!= last_line
4473 || (filename
!= NULL
4474 && last_filename
!= NULL
4475 && filename_cmp (filename
, last_filename
) != 0)
4476 || (discriminator
!= last_discriminator
)))
4478 if (discriminator
> 0)
4479 printf ("%s:%u\n", filename
== NULL
? "???" :
4480 sanitize_string (filename
), linenumber
);
4482 printf ("%s:%u (discriminator %u)\n",
4483 filename
== NULL
? "???" : sanitize_string (filename
),
4484 linenumber
, discriminator
);
4485 last_line
= linenumber
;
4486 last_discriminator
= discriminator
;
4487 if (last_filename
!= NULL
)
4488 free (last_filename
);
4489 if (filename
== NULL
)
4490 last_filename
= NULL
;
4492 last_filename
= xstrdup (filename
);
4496 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4498 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4499 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4504 section_name
= NULL
;
4507 bfd_printf_vma (abfd
, q
->address
);
4508 if (q
->howto
== NULL
)
4509 printf (" *unknown* ");
4510 else if (q
->howto
->name
)
4512 const char *name
= q
->howto
->name
;
4514 /* R_SPARC_OLO10 relocations contain two addends.
4515 But because 'arelent' lacks enough storage to
4516 store them both, the 64-bit ELF Sparc backend
4517 records this as two relocations. One R_SPARC_LO10
4518 and one R_SPARC_13, both pointing to the same
4519 address. This is merely so that we have some
4520 place to store both addend fields.
4522 Undo this transformation, otherwise the output
4523 will be confusing. */
4524 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4525 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4527 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4529 arelent
*q2
= *(p
+ 1);
4532 && q
->address
== q2
->address
4533 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4535 name
= "R_SPARC_OLO10";
4536 addend2
= q2
->addend
;
4540 printf (" %-16s ", name
);
4543 printf (" %-16d ", q
->howto
->type
);
4547 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4551 if (section_name
== NULL
)
4552 section_name
= "*unknown*";
4553 printf ("[%s]", sanitize_string (section_name
));
4558 bfd_signed_vma addend
= q
->addend
;
4566 bfd_printf_vma (abfd
, addend
);
4571 bfd_printf_vma (abfd
, addend2
);
4577 if (last_filename
!= NULL
)
4578 free (last_filename
);
4579 if (last_functionname
!= NULL
)
4580 free (last_functionname
);
4584 dump_relocs_in_section (bfd
*abfd
,
4586 void *dummy ATTRIBUTE_UNUSED
)
4588 arelent
**relpp
= NULL
;
4592 if ( bfd_is_abs_section (section
)
4593 || bfd_is_und_section (section
)
4594 || bfd_is_com_section (section
)
4595 || (! process_section_p (section
))
4596 || ((section
->flags
& SEC_RELOC
) == 0))
4599 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4601 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4604 printf (" (none)\n\n");
4612 relpp
= (arelent
**) xmalloc (relsize
);
4613 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4619 non_fatal (_("failed to read relocs in: %s"),
4620 sanitize_string (bfd_get_filename (abfd
)));
4621 bfd_fatal (_("error message was"));
4623 else if (relcount
== 0)
4624 printf (" (none)\n\n");
4628 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4635 dump_relocs (bfd
*abfd
)
4637 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4641 dump_dynamic_relocs (bfd
*abfd
)
4647 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4649 bfd_fatal (bfd_get_filename (abfd
));
4651 printf ("DYNAMIC RELOCATION RECORDS");
4654 printf (" (none)\n\n");
4657 relpp
= (arelent
**) xmalloc (relsize
);
4658 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4661 bfd_fatal (bfd_get_filename (abfd
));
4662 else if (relcount
== 0)
4663 printf (" (none)\n\n");
4667 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4674 /* Creates a table of paths, to search for source files. */
4677 add_include_path (const char *path
)
4681 include_path_count
++;
4682 include_paths
= (const char **)
4683 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4684 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4685 if (path
[1] == ':' && path
[2] == 0)
4686 path
= concat (path
, ".", (const char *) 0);
4688 include_paths
[include_path_count
- 1] = path
;
4692 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4696 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4698 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4699 section
->vma
+= adjust_section_vma
;
4701 section
->lma
+= adjust_section_vma
;
4705 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4708 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4713 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4714 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4717 /* Dump selected contents of ABFD. */
4720 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4722 const struct elf_backend_data
* bed
;
4724 if (bfd_big_endian (abfd
))
4725 byte_get
= byte_get_big_endian
;
4726 else if (bfd_little_endian (abfd
))
4727 byte_get
= byte_get_little_endian
;
4731 /* Load any separate debug information files.
4732 We do this now and without checking do_follow_links because separate
4733 debug info files may contain symbol tables that we will need when
4734 displaying information about the main file. Any memory allocated by
4735 load_separate_debug_files will be released when we call
4736 free_debug_memory below.
4738 The test on is_mainfile is there because the chain of separate debug
4739 info files is a global variable shared by all invocations of dump_bfd. */
4742 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4744 /* If asked to do so, recursively dump the separate files. */
4745 if (do_follow_links
)
4749 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4750 dump_bfd (i
->handle
, FALSE
);
4754 /* Adjust user-specified start and stop limits for targets that use
4755 signed addresses. */
4756 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4757 && (bed
= get_elf_backend_data (abfd
)) != NULL
4758 && bed
->sign_extend_vma
)
4760 start_address
= sign_extend_address (abfd
, start_address
,
4762 stop_address
= sign_extend_address (abfd
, stop_address
,
4766 /* If we are adjusting section VMA's, change them all now. Changing
4767 the BFD information is a hack. However, we must do it, or
4768 bfd_find_nearest_line will not do the right thing. */
4769 if (adjust_section_vma
!= 0)
4771 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4772 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4775 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4776 printf (_("\n%s: file format %s\n"),
4777 sanitize_string (bfd_get_filename (abfd
)),
4780 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4781 if (dump_file_header
)
4782 dump_bfd_header (abfd
);
4783 if (dump_private_headers
)
4784 dump_bfd_private_header (abfd
);
4785 if (dump_private_options
!= NULL
)
4786 dump_target_specific (abfd
);
4787 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4794 || dump_dwarf_section_info
)
4796 syms
= slurp_symtab (abfd
);
4798 /* If following links, load any symbol tables from the linked files as well. */
4799 if (do_follow_links
&& is_mainfile
)
4803 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4805 asymbol
** extra_syms
;
4806 long old_symcount
= symcount
;
4808 extra_syms
= slurp_symtab (i
->handle
);
4812 if (old_symcount
== 0)
4818 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4819 memcpy (syms
+ old_symcount
,
4821 symcount
* sizeof (asymbol
*));
4825 symcount
+= old_symcount
;
4830 if (dump_section_headers
)
4831 dump_headers (abfd
);
4833 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4834 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4835 dynsyms
= slurp_dynamic_symtab (abfd
);
4839 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4840 dynsymcount
, dynsyms
, &synthsyms
);
4846 dump_symbols (abfd
, FALSE
);
4847 if (dump_dynamic_symtab
)
4848 dump_symbols (abfd
, TRUE
);
4849 if (dump_dwarf_section_info
)
4851 if (dump_ctf_section_info
)
4852 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4853 if (dump_stab_section_info
)
4855 if (dump_reloc_info
&& ! disassemble
)
4857 if (dump_dynamic_reloc_info
&& ! disassemble
)
4858 dump_dynamic_relocs (abfd
);
4859 if (dump_section_contents
)
4862 disassemble_data (abfd
);
4868 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4869 if (dhandle
!= NULL
)
4871 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4873 dump_debugging_tags
? TRUE
: FALSE
))
4875 non_fatal (_("%s: printing debugging information failed"),
4876 bfd_get_filename (abfd
));
4882 /* PR 6483: If there was no STABS debug info in the file, try
4884 else if (! dump_dwarf_section_info
)
4886 dwarf_select_sections_all ();
4914 free_debug_memory ();
4918 display_object_bfd (bfd
*abfd
)
4922 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4924 dump_bfd (abfd
, TRUE
);
4928 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4930 nonfatal (bfd_get_filename (abfd
));
4931 list_matching_formats (matching
);
4936 if (bfd_get_error () != bfd_error_file_not_recognized
)
4938 nonfatal (bfd_get_filename (abfd
));
4942 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4944 dump_bfd (abfd
, TRUE
);
4948 nonfatal (bfd_get_filename (abfd
));
4950 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4952 list_matching_formats (matching
);
4958 display_any_bfd (bfd
*file
, int level
)
4960 /* Decompress sections unless dumping the section contents. */
4961 if (!dump_section_contents
)
4962 file
->flags
|= BFD_DECOMPRESS
;
4964 /* If the file is an archive, process all of its elements. */
4965 if (bfd_check_format (file
, bfd_archive
))
4968 bfd
*last_arfile
= NULL
;
4971 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4972 else if (level
> 100)
4974 /* Prevent corrupted files from spinning us into an
4975 infinite loop. 100 is an arbitrary heuristic. */
4976 fatal (_("Archive nesting is too deep"));
4980 printf (_("In nested archive %s:\n"),
4981 sanitize_string (bfd_get_filename (file
)));
4985 bfd_set_error (bfd_error_no_error
);
4987 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4990 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4991 nonfatal (bfd_get_filename (file
));
4995 display_any_bfd (arfile
, level
+ 1);
4997 if (last_arfile
!= NULL
)
4999 bfd_close (last_arfile
);
5000 /* PR 17512: file: ac585d01. */
5001 if (arfile
== last_arfile
)
5007 last_arfile
= arfile
;
5010 if (last_arfile
!= NULL
)
5011 bfd_close (last_arfile
);
5014 display_object_bfd (file
);
5018 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5022 if (get_file_size (filename
) < 1)
5028 file
= bfd_openr (filename
, target
);
5031 nonfatal (filename
);
5035 display_any_bfd (file
, 0);
5037 /* This is an optimization to improve the speed of objdump, especially when
5038 dumping a file with lots of associated debug informatiom. Calling
5039 bfd_close on such a file can take a non-trivial amount of time as there
5040 are lots of lists to walk and buffers to free. This is only really
5041 necessary however if we are about to load another file and we need the
5042 memory back. Otherwise, if we are about to exit, then we can save (a lot
5043 of) time by only doing a quick close, and allowing the OS to reclaim the
5048 bfd_close_all_done (file
);
5052 main (int argc
, char **argv
)
5055 char *target
= default_target
;
5056 bfd_boolean seenflag
= FALSE
;
5058 #if defined (HAVE_SETLOCALE)
5059 #if defined (HAVE_LC_MESSAGES)
5060 setlocale (LC_MESSAGES
, "");
5062 setlocale (LC_CTYPE
, "");
5065 bindtextdomain (PACKAGE
, LOCALEDIR
);
5066 textdomain (PACKAGE
);
5068 program_name
= *argv
;
5069 xmalloc_set_program_name (program_name
);
5070 bfd_set_error_program_name (program_name
);
5072 START_PROGRESS (program_name
, 0);
5074 expandargv (&argc
, &argv
);
5076 if (bfd_init () != BFD_INIT_MAGIC
)
5077 fatal (_("fatal error: libbfd ABI mismatch"));
5078 set_default_bfd_target ();
5080 while ((c
= getopt_long (argc
, argv
,
5081 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5082 long_options
, (int *) 0))
5088 break; /* We've been given a long option. */
5095 if (disassembler_options
)
5096 /* Ignore potential memory leak for now. */
5097 options
= concat (disassembler_options
, ",",
5098 optarg
, (const char *) NULL
);
5101 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5108 display_file_offsets
= TRUE
;
5111 with_line_numbers
= TRUE
;
5120 enum demangling_styles style
;
5122 style
= cplus_demangle_name_to_style (optarg
);
5123 if (style
== unknown_demangling
)
5124 fatal (_("unknown demangling style `%s'"),
5127 cplus_demangle_set_style (style
);
5130 case OPTION_RECURSE_LIMIT
:
5131 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5133 case OPTION_NO_RECURSE_LIMIT
:
5134 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5137 do_wide
= wide_output
= TRUE
;
5139 case OPTION_ADJUST_VMA
:
5140 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5142 case OPTION_START_ADDRESS
:
5143 start_address
= parse_vma (optarg
, "--start-address");
5144 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5145 fatal (_("error: the start address should be before the end address"));
5147 case OPTION_STOP_ADDRESS
:
5148 stop_address
= parse_vma (optarg
, "--stop-address");
5149 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5150 fatal (_("error: the stop address should be after the start address"));
5154 prefix_length
= strlen (prefix
);
5155 /* Remove an unnecessary trailing '/' */
5156 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5159 case OPTION_PREFIX_STRIP
:
5160 prefix_strip
= atoi (optarg
);
5161 if (prefix_strip
< 0)
5162 fatal (_("error: prefix strip must be non-negative"));
5164 case OPTION_INSN_WIDTH
:
5165 insn_width
= strtoul (optarg
, NULL
, 0);
5166 if (insn_width
<= 0)
5167 fatal (_("error: instruction width must be positive"));
5169 case OPTION_INLINES
:
5170 unwind_inlines
= TRUE
;
5172 case OPTION_VISUALIZE_JUMPS
:
5173 visualize_jumps
= TRUE
;
5174 color_output
= FALSE
;
5175 extended_color_output
= FALSE
;
5178 if (streq (optarg
, "color"))
5179 color_output
= TRUE
;
5180 else if (streq (optarg
, "extended-color"))
5182 color_output
= TRUE
;
5183 extended_color_output
= TRUE
;
5185 else if (streq (optarg
, "off"))
5186 visualize_jumps
= FALSE
;
5188 nonfatal (_("unrecognized argument to --visualize-option"));
5192 if (strcmp (optarg
, "B") == 0)
5193 endian
= BFD_ENDIAN_BIG
;
5194 else if (strcmp (optarg
, "L") == 0)
5195 endian
= BFD_ENDIAN_LITTLE
;
5198 nonfatal (_("unrecognized -E option"));
5203 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5204 endian
= BFD_ENDIAN_BIG
;
5205 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5206 endian
= BFD_ENDIAN_LITTLE
;
5209 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5216 dump_file_header
= TRUE
;
5220 formats_info
= TRUE
;
5224 add_include_path (optarg
);
5227 dump_private_headers
= TRUE
;
5231 dump_private_options
= optarg
;
5235 dump_private_headers
= TRUE
;
5237 dump_reloc_info
= TRUE
;
5238 dump_file_header
= TRUE
;
5239 dump_ar_hdrs
= TRUE
;
5240 dump_section_headers
= TRUE
;
5248 dump_dynamic_symtab
= TRUE
;
5254 disasm_sym
= optarg
;
5257 disassemble_zeroes
= TRUE
;
5261 disassemble_all
= TRUE
;
5266 with_source_code
= TRUE
;
5269 case OPTION_SOURCE_COMMENT
:
5271 with_source_code
= TRUE
;
5274 source_comment
= xstrdup (sanitize_string (optarg
));
5276 source_comment
= xstrdup ("# ");
5284 dump_debugging_tags
= 1;
5289 dump_dwarf_section_info
= TRUE
;
5292 dwarf_select_sections_by_letters (optarg
);
5294 dwarf_select_sections_all ();
5297 dump_dwarf_section_info
= TRUE
;
5300 dwarf_select_sections_by_names (optarg
);
5302 dwarf_select_sections_all ();
5304 case OPTION_DWARF_DEPTH
:
5307 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5310 case OPTION_DWARF_START
:
5313 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5314 suppress_bfd_header
= 1;
5317 case OPTION_DWARF_CHECK
:
5321 dump_ctf_section_info
= TRUE
;
5322 dump_ctf_section_name
= xstrdup (optarg
);
5325 case OPTION_CTF_PARENT
:
5326 dump_ctf_parent_name
= xstrdup (optarg
);
5329 dump_stab_section_info
= TRUE
;
5333 dump_section_contents
= TRUE
;
5337 dump_reloc_info
= TRUE
;
5341 dump_dynamic_reloc_info
= TRUE
;
5345 dump_ar_hdrs
= TRUE
;
5349 dump_section_headers
= TRUE
;
5354 show_version
= TRUE
;
5360 /* No need to set seenflag or to break - usage() does not return. */
5367 print_version ("objdump");
5373 exit_status
= display_info ();
5377 display_file ("a.out", target
, TRUE
);
5379 for (; optind
< argc
;)
5381 display_file (argv
[optind
], target
, optind
== argc
- 1);
5387 free (dump_ctf_section_name
);
5388 free (dump_ctf_parent_name
);
5389 free ((void *) source_comment
);
5391 END_PROGRESS (program_name
);