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 if (sorted_symcount
> 1)
3113 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3115 /* Skip over the relocs belonging to addresses below the
3117 while (rel_pp
< rel_ppend
3118 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3121 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3123 /* Find the nearest symbol forwards from our current position. */
3124 paux
->require_sec
= TRUE
;
3125 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3126 (struct disassemble_info
*) inf
,
3128 paux
->require_sec
= FALSE
;
3130 /* PR 9774: If the target used signed addresses then we must make
3131 sure that we sign extend the value that we calculate for 'addr'
3132 in the loop below. */
3133 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3134 && (bed
= get_elf_backend_data (abfd
)) != NULL
3135 && bed
->sign_extend_vma
)
3136 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3138 /* Disassemble a block of instructions up to the address associated with
3139 the symbol we have just found. Then print the symbol and find the
3140 next symbol on. Repeat until we have disassembled the entire section
3141 or we have reached the end of the address range we are interested in. */
3142 do_print
= paux
->symbol
== NULL
;
3143 loop_until
= stop_offset_reached
;
3145 while (addr_offset
< stop_offset
)
3149 bfd_vma nextstop_offset
;
3152 addr
= section
->vma
+ addr_offset
;
3153 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3155 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3160 (x
< sorted_symcount
3161 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3165 pinfo
->symbols
= sorted_syms
+ place
;
3166 pinfo
->num_symbols
= x
- place
;
3167 pinfo
->symtab_pos
= place
;
3171 pinfo
->symbols
= NULL
;
3172 pinfo
->num_symbols
= 0;
3173 pinfo
->symtab_pos
= -1;
3176 /* If we are only disassembling from a specific symbol,
3177 check to see if we should start or stop displaying. */
3178 if (sym
&& paux
->symbol
)
3182 /* See if we should stop printing. */
3186 if (sym
->flags
& BSF_FUNCTION
)
3190 case stop_offset_reached
:
3191 /* Handled by the while loop. */
3195 /* FIXME: There is an implicit assumption here
3196 that the name of sym is different from
3198 if (! bfd_is_local_label (abfd
, sym
))
3205 const char * name
= bfd_asymbol_name (sym
);
3206 char * alloc
= NULL
;
3208 if (do_demangle
&& name
[0] != '\0')
3210 /* Demangle the name. */
3211 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3216 /* We are not currently printing. Check to see
3217 if the current symbol matches the requested symbol. */
3218 if (streq (name
, paux
->symbol
))
3222 if (sym
->flags
& BSF_FUNCTION
)
3224 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3225 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3227 /* Sym is a function symbol with a size associated
3228 with it. Turn on automatic disassembly for the
3229 next VALUE bytes. */
3230 stop_offset
= addr_offset
3231 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3232 loop_until
= stop_offset_reached
;
3236 /* Otherwise we need to tell the loop heuristic to
3237 loop until the next function symbol is encountered. */
3238 loop_until
= function_sym
;
3243 /* Otherwise loop until the next symbol is encountered. */
3244 loop_until
= next_sym
;
3252 if (! prefix_addresses
&& do_print
)
3254 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3255 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3257 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3260 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3262 else if (sym
== NULL
)
3266 #define is_valid_next_sym(SYM) \
3267 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3268 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3269 && pinfo->symbol_is_valid (SYM, pinfo))
3271 /* Search forward for the next appropriate symbol in
3272 SECTION. Note that all the symbols are sorted
3273 together into one big array, and that some sections
3274 may have overlapping addresses. */
3275 while (place
< sorted_symcount
3276 && ! is_valid_next_sym (sorted_syms
[place
]))
3279 if (place
>= sorted_symcount
)
3282 nextsym
= sorted_syms
[place
];
3285 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3286 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3287 else if (nextsym
== NULL
)
3288 nextstop_offset
= stop_offset
;
3290 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3292 if (nextstop_offset
> stop_offset
3293 || nextstop_offset
<= addr_offset
)
3294 nextstop_offset
= stop_offset
;
3296 /* If a symbol is explicitly marked as being an object
3297 rather than a function, just dump the bytes without
3298 disassembling them. */
3301 || sym
->section
!= section
3302 || bfd_asymbol_value (sym
) > addr
3303 || ((sym
->flags
& BSF_OBJECT
) == 0
3304 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3306 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3308 || (sym
->flags
& BSF_FUNCTION
) != 0)
3315 /* Resolve symbol name. */
3316 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3318 struct disassemble_info di
;
3321 sf
.alloc
= strlen (sym
->name
) + 40;
3322 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3324 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3327 objdump_print_symname (abfd
, &di
, sym
);
3329 /* Fetch jump information. */
3330 detected_jumps
= disassemble_jumps
3331 (pinfo
, paux
->disassemble_fn
,
3332 addr_offset
, nextstop_offset
,
3333 rel_offset
, &rel_pp
, rel_ppend
);
3335 /* Free symbol name. */
3339 /* Add jumps to output. */
3340 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3341 addr_offset
, nextstop_offset
,
3342 rel_offset
, &rel_pp
, rel_ppend
);
3345 while (detected_jumps
)
3347 detected_jumps
= jump_info_free (detected_jumps
);
3351 addr_offset
= nextstop_offset
;
3357 if (rel_ppstart
!= NULL
)
3361 /* Disassemble the contents of an object file. */
3364 disassemble_data (bfd
*abfd
)
3366 struct disassemble_info disasm_info
;
3367 struct objdump_disasm_info aux
;
3371 prev_functionname
= NULL
;
3373 prev_discriminator
= 0;
3375 /* We make a copy of syms to sort. We don't want to sort syms
3376 because that will screw up the relocs. */
3377 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3378 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3379 * sizeof (asymbol
*));
3380 if (sorted_symcount
!= 0)
3382 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3383 sorted_symcount
* sizeof (asymbol
*));
3385 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3388 for (i
= 0; i
< synthcount
; ++i
)
3390 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3394 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3396 disasm_info
.application_data
= (void *) &aux
;
3398 aux
.require_sec
= FALSE
;
3399 aux
.dynrelbuf
= NULL
;
3400 aux
.dynrelcount
= 0;
3402 aux
.symbol
= disasm_sym
;
3404 disasm_info
.print_address_func
= objdump_print_address
;
3405 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3407 if (machine
!= NULL
)
3409 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3412 fatal (_("can't use supplied machine %s"), machine
);
3414 abfd
->arch_info
= inf
;
3417 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3419 struct bfd_target
*xvec
;
3421 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3422 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3423 xvec
->byteorder
= endian
;
3427 /* Use libopcodes to locate a suitable disassembler. */
3428 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3429 bfd_big_endian (abfd
),
3430 bfd_get_mach (abfd
), abfd
);
3431 if (!aux
.disassemble_fn
)
3433 non_fatal (_("can't disassemble for architecture %s\n"),
3434 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3439 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3440 disasm_info
.arch
= bfd_get_arch (abfd
);
3441 disasm_info
.mach
= bfd_get_mach (abfd
);
3442 disasm_info
.disassembler_options
= disassembler_options
;
3443 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3444 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3445 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3446 disasm_info
.disassembler_needs_relocs
= FALSE
;
3448 if (bfd_big_endian (abfd
))
3449 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3450 else if (bfd_little_endian (abfd
))
3451 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3453 /* ??? Aborting here seems too drastic. We could default to big or little
3455 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3457 /* Allow the target to customize the info structure. */
3458 disassemble_init_for_target (& disasm_info
);
3460 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3462 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3464 if (relsize
< 0 && dump_dynamic_reloc_info
)
3465 bfd_fatal (bfd_get_filename (abfd
));
3469 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3470 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3473 if (aux
.dynrelcount
< 0)
3474 bfd_fatal (bfd_get_filename (abfd
));
3476 /* Sort the relocs by address. */
3477 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3481 disasm_info
.symtab
= sorted_syms
;
3482 disasm_info
.symtab_size
= sorted_symcount
;
3484 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3486 if (aux
.dynrelbuf
!= NULL
)
3487 free (aux
.dynrelbuf
);
3489 disassemble_free_target (&disasm_info
);
3493 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3494 asection
*sec
, void *file
)
3496 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3497 bfd
*abfd
= (bfd
*) file
;
3502 if (section
->start
!= NULL
)
3504 /* If it is already loaded, do nothing. */
3505 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3507 free (section
->start
);
3510 section
->filename
= bfd_get_filename (abfd
);
3511 section
->reloc_info
= NULL
;
3512 section
->num_relocs
= 0;
3513 section
->address
= bfd_section_vma (sec
);
3514 section
->user_data
= sec
;
3515 section
->size
= bfd_section_size (sec
);
3516 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3517 alloced
= amt
= section
->size
+ 1;
3518 if (alloced
!= amt
|| alloced
== 0)
3520 section
->start
= NULL
;
3521 free_debug_section (debug
);
3522 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3523 sanitize_string (section
->name
),
3524 (unsigned long long) section
->size
);
3527 section
->start
= contents
= malloc (alloced
);
3528 if (section
->start
== NULL
3529 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3531 free_debug_section (debug
);
3532 printf (_("\nCan't get contents for section '%s'.\n"),
3533 sanitize_string (section
->name
));
3536 /* Ensure any string section has a terminating NUL. */
3537 section
->start
[section
->size
] = 0;
3539 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3540 && debug_displays
[debug
].relocate
)
3545 bfd_cache_section_contents (sec
, section
->start
);
3547 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3554 free_debug_section (debug
);
3555 printf (_("\nCan't get contents for section '%s'.\n"),
3556 sanitize_string (section
->name
));
3560 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3563 unsigned long reloc_count
;
3566 relocs
= (arelent
**) xmalloc (reloc_size
);
3568 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3569 if (reloc_count
== 0)
3573 section
->reloc_info
= relocs
;
3574 section
->num_relocs
= reloc_count
;
3583 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3588 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3591 relocs
= (arelent
**) dsec
->reloc_info
;
3593 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3594 if (rp
->address
== offset
)
3601 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3603 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3604 bfd
*abfd
= (bfd
*) file
;
3607 /* If it is already loaded, do nothing. */
3608 if (section
->start
!= NULL
)
3610 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3614 /* Locate the debug section. */
3615 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3617 section
->name
= section
->uncompressed_name
;
3620 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3622 section
->name
= section
->compressed_name
;
3627 return load_specific_debug_section (debug
, sec
, file
);
3631 free_debug_section (enum dwarf_section_display_enum debug
)
3633 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3635 if (section
->start
== NULL
)
3638 /* PR 17512: file: 0f67f69d. */
3639 if (section
->user_data
!= NULL
)
3641 asection
* sec
= (asection
*) section
->user_data
;
3643 /* If we are freeing contents that are also pointed to by the BFD
3644 library's section structure then make sure to update those pointers
3645 too. Otherwise, the next time we try to load data for this section
3646 we can end up using a stale pointer. */
3647 if (section
->start
== sec
->contents
)
3649 sec
->contents
= NULL
;
3650 sec
->flags
&= ~ SEC_IN_MEMORY
;
3651 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3655 free ((char *) section
->start
);
3656 section
->start
= NULL
;
3657 section
->address
= 0;
3662 close_debug_file (void * file
)
3664 bfd
* abfd
= (bfd
*) file
;
3670 open_debug_file (const char * pathname
)
3674 data
= bfd_openr (pathname
, NULL
);
3678 if (! bfd_check_format (data
, bfd_object
))
3684 #if HAVE_LIBDEBUGINFOD
3685 /* Return a hex string represention of the build-id. */
3688 get_build_id (void * data
)
3691 char * build_id_str
;
3692 bfd
* abfd
= (bfd
*) data
;
3693 const struct bfd_build_id
* build_id
;
3695 build_id
= abfd
->build_id
;
3696 if (build_id
== NULL
)
3699 build_id_str
= malloc (build_id
->size
* 2 + 1);
3700 if (build_id_str
== NULL
)
3703 for (i
= 0; i
< build_id
->size
; i
++)
3704 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3705 build_id_str
[build_id
->size
* 2] = '\0';
3707 return (unsigned char *)build_id_str
;
3709 #endif /* HAVE_LIBDEBUGINFOD */
3712 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3713 void *arg ATTRIBUTE_UNUSED
)
3715 const char *name
= bfd_section_name (section
);
3719 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3720 match
= ".debug_info";
3724 for (i
= 0; i
< max
; i
++)
3725 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3726 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3727 && debug_displays
[i
].enabled
!= NULL
3728 && *debug_displays
[i
].enabled
)
3730 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3732 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3733 sec
->name
= sec
->uncompressed_name
;
3735 sec
->name
= sec
->compressed_name
;
3736 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3739 debug_displays
[i
].display (sec
, abfd
);
3741 if (i
!= info
&& i
!= abbrev
)
3742 free_debug_section ((enum dwarf_section_display_enum
) i
);
3748 /* Dump the dwarf debugging information. */
3751 dump_dwarf (bfd
*abfd
)
3753 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3754 if (byte_get
== NULL
)
3756 warn (_("File %s does not contain any dwarf debug information\n"),
3757 bfd_get_filename (abfd
));
3761 switch (bfd_get_arch (abfd
))
3764 /* S12Z has a 24 bit address space. But the only known
3765 producer of dwarf_info encodes addresses into 32 bits. */
3770 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3774 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3775 bfd_get_mach (abfd
));
3777 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3780 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3781 it. Return NULL on failure. */
3784 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3785 bfd_size_type
*entsize_ptr
)
3790 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3791 if (stabsect
== NULL
)
3793 printf (_("No %s section present\n\n"),
3794 sanitize_string (sect_name
));
3798 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3800 non_fatal (_("reading %s section of %s failed: %s"),
3801 sect_name
, bfd_get_filename (abfd
),
3802 bfd_errmsg (bfd_get_error ()));
3808 *size_ptr
= bfd_section_size (stabsect
);
3810 *entsize_ptr
= stabsect
->entsize
;
3815 /* Stabs entries use a 12 byte format:
3816 4 byte string table index
3818 1 byte stab other field
3819 2 byte stab desc field
3821 FIXME: This will have to change for a 64 bit object format. */
3823 #define STRDXOFF (0)
3825 #define OTHEROFF (5)
3828 #define STABSIZE (12)
3830 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3831 using string table section STRSECT_NAME (in `strtab'). */
3834 print_section_stabs (bfd
*abfd
,
3835 const char *stabsect_name
,
3836 unsigned *string_offset_ptr
)
3839 unsigned file_string_table_offset
= 0;
3840 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3841 bfd_byte
*stabp
, *stabs_end
;
3844 stabs_end
= stabp
+ stab_size
;
3846 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3847 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3849 /* Loop through all symbols and print them.
3851 We start the index at -1 because there is a dummy symbol on
3852 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3853 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3857 unsigned char type
, other
;
3858 unsigned short desc
;
3861 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3862 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3863 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3864 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3865 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3867 printf ("\n%-6d ", i
);
3868 /* Either print the stab name, or, if unnamed, print its number
3869 again (makes consistent formatting for tools like awk). */
3870 name
= bfd_get_stab_name (type
);
3872 printf ("%-6s", sanitize_string (name
));
3873 else if (type
== N_UNDF
)
3876 printf ("%-6d", type
);
3877 printf (" %-6d %-6d ", other
, desc
);
3878 bfd_printf_vma (abfd
, value
);
3879 printf (" %-6lu", strx
);
3881 /* Symbols with type == 0 (N_UNDF) specify the length of the
3882 string table associated with this file. We use that info
3883 to know how to relocate the *next* file's string table indices. */
3886 file_string_table_offset
= next_file_string_table_offset
;
3887 next_file_string_table_offset
+= value
;
3891 bfd_size_type amt
= strx
+ file_string_table_offset
;
3893 /* Using the (possibly updated) string table offset, print the
3894 string (if any) associated with this symbol. */
3895 if (amt
< stabstr_size
)
3896 /* PR 17512: file: 079-79389-0.001:0.1.
3897 FIXME: May need to sanitize this string before displaying. */
3898 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3904 *string_offset_ptr
= next_file_string_table_offset
;
3909 const char * section_name
;
3910 const char * string_section_name
;
3911 unsigned string_offset
;
3916 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3919 stab_section_names
* sought
= (stab_section_names
*) names
;
3921 /* Check for section names for which stabsect_name is a prefix, to
3922 handle .stab.N, etc. */
3923 len
= strlen (sought
->section_name
);
3925 /* If the prefix matches, and the files section name ends with a
3926 nul or a digit, then we match. I.e., we want either an exact
3927 match or a section followed by a number. */
3928 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3929 && (section
->name
[len
] == 0
3930 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3933 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3934 &stabstr_size
, NULL
);
3938 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3940 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3946 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3948 stab_section_names s
;
3950 s
.section_name
= stabsect_name
;
3951 s
.string_section_name
= strsect_name
;
3952 s
.string_offset
= 0;
3954 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3960 /* Dump the any sections containing stabs debugging information. */
3963 dump_stabs (bfd
*abfd
)
3965 dump_stabs_section (abfd
, ".stab", ".stabstr");
3966 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3967 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3970 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3972 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3976 dump_bfd_header (bfd
*abfd
)
3980 printf (_("architecture: %s, "),
3981 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3982 bfd_get_mach (abfd
)));
3983 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3985 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
3986 PF (HAS_RELOC
, "HAS_RELOC");
3987 PF (EXEC_P
, "EXEC_P");
3988 PF (HAS_LINENO
, "HAS_LINENO");
3989 PF (HAS_DEBUG
, "HAS_DEBUG");
3990 PF (HAS_SYMS
, "HAS_SYMS");
3991 PF (HAS_LOCALS
, "HAS_LOCALS");
3992 PF (DYNAMIC
, "DYNAMIC");
3993 PF (WP_TEXT
, "WP_TEXT");
3994 PF (D_PAGED
, "D_PAGED");
3995 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3996 printf (_("\nstart address 0x"));
3997 bfd_printf_vma (abfd
, abfd
->start_address
);
4002 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4003 it is passed, or a pointer to newly-allocated storage, in which case
4004 dump_ctf() will free it when it no longer needs it. */
4007 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4010 const char *blanks
= arg
;
4013 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4018 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4020 make_ctfsect (const char *name
, bfd_byte
*data
,
4025 ctfsect
.cts_name
= name
;
4026 ctfsect
.cts_entsize
= 1;
4027 ctfsect
.cts_size
= size
;
4028 ctfsect
.cts_data
= data
;
4033 /* Dump one CTF archive member. */
4036 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
4038 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
4039 const char *things
[] = {"Header", "Labels", "Data objects",
4040 "Function objects", "Variables", "Types", "Strings",
4045 /* Only print out the name of non-default-named archive members.
4046 The name .ctf appears everywhere, even for things that aren't
4047 really archives, so printing it out is liable to be confusing.
4049 The parent, if there is one, is the default-owned archive member:
4050 avoid importing it into itself. (This does no harm, but looks
4053 if (strcmp (name
, ".ctf") != 0)
4055 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4056 ctf_import (ctf
, parent
);
4059 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4061 ctf_dump_state_t
*s
= NULL
;
4064 printf ("\n %s:\n", *thing
);
4065 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4066 (void *) " ")) != NULL
)
4068 printf ("%s\n", item
);
4072 if (ctf_errno (ctf
))
4074 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4075 ctf_errmsg (ctf_errno (ctf
)));
4082 /* Dump the CTF debugging information. */
4085 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4087 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4088 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4089 bfd_size_type ctfsize
, parentsize
;
4091 ctf_file_t
*parent
= NULL
;
4094 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4095 bfd_fatal (bfd_get_filename (abfd
));
4098 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4100 bfd_fatal (bfd_get_filename (abfd
));
4102 /* Load the CTF file and dump it. */
4104 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4105 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4107 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4108 bfd_fatal (bfd_get_filename (abfd
));
4113 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4114 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4116 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4117 bfd_fatal (bfd_get_filename (abfd
));
4120 lookparent
= parenta
;
4125 /* Assume that the applicable parent archive member is the default one.
4126 (This is what all known implementations are expected to do, if they
4127 put CTFs and their parents in archives together.) */
4128 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4130 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4131 bfd_fatal (bfd_get_filename (abfd
));
4134 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4136 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4137 ctf_file_close (parent
);
4139 ctf_close (parenta
);
4146 dump_bfd_private_header (bfd
*abfd
)
4148 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4149 non_fatal (_("warning: private headers incomplete: %s"),
4150 bfd_errmsg (bfd_get_error ()));
4154 dump_target_specific (bfd
*abfd
)
4156 const struct objdump_private_desc
* const *desc
;
4157 struct objdump_private_option
*opt
;
4160 /* Find the desc. */
4161 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4162 if ((*desc
)->filter (abfd
))
4167 non_fatal (_("option -P/--private not supported by this file"));
4171 /* Clear all options. */
4172 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4173 opt
->selected
= FALSE
;
4175 /* Decode options. */
4176 b
= dump_private_options
;
4179 e
= strchr (b
, ',');
4184 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4185 if (strcmp (opt
->name
, b
) == 0)
4187 opt
->selected
= TRUE
;
4190 if (opt
->name
== NULL
)
4191 non_fatal (_("target specific dump '%s' not supported"), b
);
4202 (*desc
)->dump (abfd
);
4205 /* Display a section in hexadecimal format with associated characters.
4206 Each line prefixed by the zero padded address. */
4209 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4211 bfd_byte
*data
= NULL
;
4212 bfd_size_type datasize
;
4213 bfd_vma addr_offset
;
4214 bfd_vma start_offset
;
4215 bfd_vma stop_offset
;
4216 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4217 /* Bytes per line. */
4218 const int onaline
= 16;
4223 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4226 if (! process_section_p (section
))
4229 if ((datasize
= bfd_section_size (section
)) == 0)
4232 /* Compute the address range to display. */
4233 if (start_address
== (bfd_vma
) -1
4234 || start_address
< section
->vma
)
4237 start_offset
= start_address
- section
->vma
;
4239 if (stop_address
== (bfd_vma
) -1)
4240 stop_offset
= datasize
/ opb
;
4243 if (stop_address
< section
->vma
)
4246 stop_offset
= stop_address
- section
->vma
;
4248 if (stop_offset
> datasize
/ opb
)
4249 stop_offset
= datasize
/ opb
;
4252 if (start_offset
>= stop_offset
)
4255 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4256 if (display_file_offsets
)
4257 printf (_(" (Starting at file offset: 0x%lx)"),
4258 (unsigned long) (section
->filepos
+ start_offset
));
4261 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4263 non_fatal (_("Reading section %s failed because: %s"),
4264 section
->name
, bfd_errmsg (bfd_get_error ()));
4270 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4271 if (strlen (buf
) >= sizeof (buf
))
4275 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4277 count
= strlen (buf
) - count
;
4281 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4282 if (strlen (buf
) >= sizeof (buf
))
4286 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4288 count
= strlen (buf
) - count
;
4292 for (addr_offset
= start_offset
;
4293 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4297 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4298 count
= strlen (buf
);
4299 if ((size_t) count
>= sizeof (buf
))
4303 while (count
< width
)
4308 fputs (buf
+ count
- width
, stdout
);
4311 for (j
= addr_offset
* opb
;
4312 j
< addr_offset
* opb
+ onaline
; j
++)
4314 if (j
< stop_offset
* opb
)
4315 printf ("%02x", (unsigned) (data
[j
]));
4323 for (j
= addr_offset
* opb
;
4324 j
< addr_offset
* opb
+ onaline
; j
++)
4326 if (j
>= stop_offset
* opb
)
4329 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4336 /* Actually display the various requested regions. */
4339 dump_data (bfd
*abfd
)
4341 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4344 /* Should perhaps share code and display with nm? */
4347 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4356 max_count
= dynsymcount
;
4357 printf ("DYNAMIC SYMBOL TABLE:\n");
4362 max_count
= symcount
;
4363 printf ("SYMBOL TABLE:\n");
4367 printf (_("no symbols\n"));
4369 for (count
= 0; count
< max_count
; count
++)
4373 if (*current
== NULL
)
4374 printf (_("no information for symbol number %ld\n"), count
);
4376 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4377 printf (_("could not determine the type of symbol number %ld\n"),
4380 else if (process_section_p ((* current
)->section
)
4381 && (dump_special_syms
4382 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4384 const char *name
= (*current
)->name
;
4386 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4390 /* If we want to demangle the name, we demangle it
4391 here, and temporarily clobber it while calling
4392 bfd_print_symbol. FIXME: This is a gross hack. */
4393 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4395 (*current
)->name
= alloc
;
4396 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4397 bfd_print_symbol_all
);
4400 (*current
)->name
= name
;
4405 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4406 bfd_print_symbol_all
);
4416 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4419 char *last_filename
, *last_functionname
;
4420 unsigned int last_line
;
4421 unsigned int last_discriminator
;
4423 /* Get column headers lined up reasonably. */
4431 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4432 width
= strlen (buf
) - 7;
4434 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4437 last_filename
= NULL
;
4438 last_functionname
= NULL
;
4440 last_discriminator
= 0;
4442 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4445 const char *filename
, *functionname
;
4446 unsigned int linenumber
;
4447 unsigned int discriminator
;
4448 const char *sym_name
;
4449 const char *section_name
;
4450 bfd_vma addend2
= 0;
4452 if (start_address
!= (bfd_vma
) -1
4453 && q
->address
< start_address
)
4455 if (stop_address
!= (bfd_vma
) -1
4456 && q
->address
> stop_address
)
4459 if (with_line_numbers
4461 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4462 &filename
, &functionname
,
4463 &linenumber
, &discriminator
))
4465 if (functionname
!= NULL
4466 && (last_functionname
== NULL
4467 || strcmp (functionname
, last_functionname
) != 0))
4469 printf ("%s():\n", sanitize_string (functionname
));
4470 if (last_functionname
!= NULL
)
4471 free (last_functionname
);
4472 last_functionname
= xstrdup (functionname
);
4476 && (linenumber
!= last_line
4477 || (filename
!= NULL
4478 && last_filename
!= NULL
4479 && filename_cmp (filename
, last_filename
) != 0)
4480 || (discriminator
!= last_discriminator
)))
4482 if (discriminator
> 0)
4483 printf ("%s:%u\n", filename
== NULL
? "???" :
4484 sanitize_string (filename
), linenumber
);
4486 printf ("%s:%u (discriminator %u)\n",
4487 filename
== NULL
? "???" : sanitize_string (filename
),
4488 linenumber
, discriminator
);
4489 last_line
= linenumber
;
4490 last_discriminator
= discriminator
;
4491 if (last_filename
!= NULL
)
4492 free (last_filename
);
4493 if (filename
== NULL
)
4494 last_filename
= NULL
;
4496 last_filename
= xstrdup (filename
);
4500 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4502 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4503 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4508 section_name
= NULL
;
4511 bfd_printf_vma (abfd
, q
->address
);
4512 if (q
->howto
== NULL
)
4513 printf (" *unknown* ");
4514 else if (q
->howto
->name
)
4516 const char *name
= q
->howto
->name
;
4518 /* R_SPARC_OLO10 relocations contain two addends.
4519 But because 'arelent' lacks enough storage to
4520 store them both, the 64-bit ELF Sparc backend
4521 records this as two relocations. One R_SPARC_LO10
4522 and one R_SPARC_13, both pointing to the same
4523 address. This is merely so that we have some
4524 place to store both addend fields.
4526 Undo this transformation, otherwise the output
4527 will be confusing. */
4528 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4529 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4531 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4533 arelent
*q2
= *(p
+ 1);
4536 && q
->address
== q2
->address
4537 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4539 name
= "R_SPARC_OLO10";
4540 addend2
= q2
->addend
;
4544 printf (" %-16s ", name
);
4547 printf (" %-16d ", q
->howto
->type
);
4551 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4555 if (section_name
== NULL
)
4556 section_name
= "*unknown*";
4557 printf ("[%s]", sanitize_string (section_name
));
4562 bfd_signed_vma addend
= q
->addend
;
4570 bfd_printf_vma (abfd
, addend
);
4575 bfd_printf_vma (abfd
, addend2
);
4581 if (last_filename
!= NULL
)
4582 free (last_filename
);
4583 if (last_functionname
!= NULL
)
4584 free (last_functionname
);
4588 dump_relocs_in_section (bfd
*abfd
,
4590 void *dummy ATTRIBUTE_UNUSED
)
4592 arelent
**relpp
= NULL
;
4596 if ( bfd_is_abs_section (section
)
4597 || bfd_is_und_section (section
)
4598 || bfd_is_com_section (section
)
4599 || (! process_section_p (section
))
4600 || ((section
->flags
& SEC_RELOC
) == 0))
4603 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4605 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4608 printf (" (none)\n\n");
4616 relpp
= (arelent
**) xmalloc (relsize
);
4617 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4623 non_fatal (_("failed to read relocs in: %s"),
4624 sanitize_string (bfd_get_filename (abfd
)));
4625 bfd_fatal (_("error message was"));
4627 else if (relcount
== 0)
4628 printf (" (none)\n\n");
4632 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4639 dump_relocs (bfd
*abfd
)
4641 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4645 dump_dynamic_relocs (bfd
*abfd
)
4651 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4653 bfd_fatal (bfd_get_filename (abfd
));
4655 printf ("DYNAMIC RELOCATION RECORDS");
4658 printf (" (none)\n\n");
4661 relpp
= (arelent
**) xmalloc (relsize
);
4662 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4665 bfd_fatal (bfd_get_filename (abfd
));
4666 else if (relcount
== 0)
4667 printf (" (none)\n\n");
4671 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4678 /* Creates a table of paths, to search for source files. */
4681 add_include_path (const char *path
)
4685 include_path_count
++;
4686 include_paths
= (const char **)
4687 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4688 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4689 if (path
[1] == ':' && path
[2] == 0)
4690 path
= concat (path
, ".", (const char *) 0);
4692 include_paths
[include_path_count
- 1] = path
;
4696 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4700 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4702 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4703 section
->vma
+= adjust_section_vma
;
4705 section
->lma
+= adjust_section_vma
;
4709 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4712 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4717 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4718 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4721 /* Dump selected contents of ABFD. */
4724 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4726 const struct elf_backend_data
* bed
;
4728 if (bfd_big_endian (abfd
))
4729 byte_get
= byte_get_big_endian
;
4730 else if (bfd_little_endian (abfd
))
4731 byte_get
= byte_get_little_endian
;
4735 /* Load any separate debug information files.
4736 We do this now and without checking do_follow_links because separate
4737 debug info files may contain symbol tables that we will need when
4738 displaying information about the main file. Any memory allocated by
4739 load_separate_debug_files will be released when we call
4740 free_debug_memory below.
4742 The test on is_mainfile is there because the chain of separate debug
4743 info files is a global variable shared by all invocations of dump_bfd. */
4746 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4748 /* If asked to do so, recursively dump the separate files. */
4749 if (do_follow_links
)
4753 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4754 dump_bfd (i
->handle
, FALSE
);
4758 /* Adjust user-specified start and stop limits for targets that use
4759 signed addresses. */
4760 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4761 && (bed
= get_elf_backend_data (abfd
)) != NULL
4762 && bed
->sign_extend_vma
)
4764 start_address
= sign_extend_address (abfd
, start_address
,
4766 stop_address
= sign_extend_address (abfd
, stop_address
,
4770 /* If we are adjusting section VMA's, change them all now. Changing
4771 the BFD information is a hack. However, we must do it, or
4772 bfd_find_nearest_line will not do the right thing. */
4773 if (adjust_section_vma
!= 0)
4775 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4776 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4779 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4780 printf (_("\n%s: file format %s\n"),
4781 sanitize_string (bfd_get_filename (abfd
)),
4784 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4785 if (dump_file_header
)
4786 dump_bfd_header (abfd
);
4787 if (dump_private_headers
)
4788 dump_bfd_private_header (abfd
);
4789 if (dump_private_options
!= NULL
)
4790 dump_target_specific (abfd
);
4791 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4798 || dump_dwarf_section_info
)
4800 syms
= slurp_symtab (abfd
);
4802 /* If following links, load any symbol tables from the linked files as well. */
4803 if (do_follow_links
&& is_mainfile
)
4807 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4809 asymbol
** extra_syms
;
4810 long old_symcount
= symcount
;
4812 extra_syms
= slurp_symtab (i
->handle
);
4816 if (old_symcount
== 0)
4822 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4823 memcpy (syms
+ old_symcount
,
4825 symcount
* sizeof (asymbol
*));
4829 symcount
+= old_symcount
;
4834 if (dump_section_headers
)
4835 dump_headers (abfd
);
4837 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4838 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4839 dynsyms
= slurp_dynamic_symtab (abfd
);
4843 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4844 dynsymcount
, dynsyms
, &synthsyms
);
4850 dump_symbols (abfd
, FALSE
);
4851 if (dump_dynamic_symtab
)
4852 dump_symbols (abfd
, TRUE
);
4853 if (dump_dwarf_section_info
)
4855 if (dump_ctf_section_info
)
4856 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4857 if (dump_stab_section_info
)
4859 if (dump_reloc_info
&& ! disassemble
)
4861 if (dump_dynamic_reloc_info
&& ! disassemble
)
4862 dump_dynamic_relocs (abfd
);
4863 if (dump_section_contents
)
4866 disassemble_data (abfd
);
4872 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4873 if (dhandle
!= NULL
)
4875 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4877 dump_debugging_tags
? TRUE
: FALSE
))
4879 non_fatal (_("%s: printing debugging information failed"),
4880 bfd_get_filename (abfd
));
4886 /* PR 6483: If there was no STABS debug info in the file, try
4888 else if (! dump_dwarf_section_info
)
4890 dwarf_select_sections_all ();
4918 free_debug_memory ();
4922 display_object_bfd (bfd
*abfd
)
4926 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4928 dump_bfd (abfd
, TRUE
);
4932 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4934 nonfatal (bfd_get_filename (abfd
));
4935 list_matching_formats (matching
);
4940 if (bfd_get_error () != bfd_error_file_not_recognized
)
4942 nonfatal (bfd_get_filename (abfd
));
4946 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4948 dump_bfd (abfd
, TRUE
);
4952 nonfatal (bfd_get_filename (abfd
));
4954 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4956 list_matching_formats (matching
);
4962 display_any_bfd (bfd
*file
, int level
)
4964 /* Decompress sections unless dumping the section contents. */
4965 if (!dump_section_contents
)
4966 file
->flags
|= BFD_DECOMPRESS
;
4968 /* If the file is an archive, process all of its elements. */
4969 if (bfd_check_format (file
, bfd_archive
))
4972 bfd
*last_arfile
= NULL
;
4975 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4976 else if (level
> 100)
4978 /* Prevent corrupted files from spinning us into an
4979 infinite loop. 100 is an arbitrary heuristic. */
4980 fatal (_("Archive nesting is too deep"));
4984 printf (_("In nested archive %s:\n"),
4985 sanitize_string (bfd_get_filename (file
)));
4989 bfd_set_error (bfd_error_no_error
);
4991 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4994 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4995 nonfatal (bfd_get_filename (file
));
4999 display_any_bfd (arfile
, level
+ 1);
5001 if (last_arfile
!= NULL
)
5003 bfd_close (last_arfile
);
5004 /* PR 17512: file: ac585d01. */
5005 if (arfile
== last_arfile
)
5011 last_arfile
= arfile
;
5014 if (last_arfile
!= NULL
)
5015 bfd_close (last_arfile
);
5018 display_object_bfd (file
);
5022 display_file (char *filename
, char *target
, bfd_boolean last_file
)
5026 if (get_file_size (filename
) < 1)
5032 file
= bfd_openr (filename
, target
);
5035 nonfatal (filename
);
5039 display_any_bfd (file
, 0);
5041 /* This is an optimization to improve the speed of objdump, especially when
5042 dumping a file with lots of associated debug informatiom. Calling
5043 bfd_close on such a file can take a non-trivial amount of time as there
5044 are lots of lists to walk and buffers to free. This is only really
5045 necessary however if we are about to load another file and we need the
5046 memory back. Otherwise, if we are about to exit, then we can save (a lot
5047 of) time by only doing a quick close, and allowing the OS to reclaim the
5052 bfd_close_all_done (file
);
5056 main (int argc
, char **argv
)
5059 char *target
= default_target
;
5060 bfd_boolean seenflag
= FALSE
;
5062 #if defined (HAVE_SETLOCALE)
5063 #if defined (HAVE_LC_MESSAGES)
5064 setlocale (LC_MESSAGES
, "");
5066 setlocale (LC_CTYPE
, "");
5069 bindtextdomain (PACKAGE
, LOCALEDIR
);
5070 textdomain (PACKAGE
);
5072 program_name
= *argv
;
5073 xmalloc_set_program_name (program_name
);
5074 bfd_set_error_program_name (program_name
);
5076 START_PROGRESS (program_name
, 0);
5078 expandargv (&argc
, &argv
);
5080 if (bfd_init () != BFD_INIT_MAGIC
)
5081 fatal (_("fatal error: libbfd ABI mismatch"));
5082 set_default_bfd_target ();
5084 while ((c
= getopt_long (argc
, argv
,
5085 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5086 long_options
, (int *) 0))
5092 break; /* We've been given a long option. */
5099 if (disassembler_options
)
5100 /* Ignore potential memory leak for now. */
5101 options
= concat (disassembler_options
, ",",
5102 optarg
, (const char *) NULL
);
5105 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5112 display_file_offsets
= TRUE
;
5115 with_line_numbers
= TRUE
;
5124 enum demangling_styles style
;
5126 style
= cplus_demangle_name_to_style (optarg
);
5127 if (style
== unknown_demangling
)
5128 fatal (_("unknown demangling style `%s'"),
5131 cplus_demangle_set_style (style
);
5134 case OPTION_RECURSE_LIMIT
:
5135 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5137 case OPTION_NO_RECURSE_LIMIT
:
5138 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5141 do_wide
= wide_output
= TRUE
;
5143 case OPTION_ADJUST_VMA
:
5144 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5146 case OPTION_START_ADDRESS
:
5147 start_address
= parse_vma (optarg
, "--start-address");
5148 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5149 fatal (_("error: the start address should be before the end address"));
5151 case OPTION_STOP_ADDRESS
:
5152 stop_address
= parse_vma (optarg
, "--stop-address");
5153 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5154 fatal (_("error: the stop address should be after the start address"));
5158 prefix_length
= strlen (prefix
);
5159 /* Remove an unnecessary trailing '/' */
5160 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5163 case OPTION_PREFIX_STRIP
:
5164 prefix_strip
= atoi (optarg
);
5165 if (prefix_strip
< 0)
5166 fatal (_("error: prefix strip must be non-negative"));
5168 case OPTION_INSN_WIDTH
:
5169 insn_width
= strtoul (optarg
, NULL
, 0);
5170 if (insn_width
<= 0)
5171 fatal (_("error: instruction width must be positive"));
5173 case OPTION_INLINES
:
5174 unwind_inlines
= TRUE
;
5176 case OPTION_VISUALIZE_JUMPS
:
5177 visualize_jumps
= TRUE
;
5178 color_output
= FALSE
;
5179 extended_color_output
= FALSE
;
5182 if (streq (optarg
, "color"))
5183 color_output
= TRUE
;
5184 else if (streq (optarg
, "extended-color"))
5186 color_output
= TRUE
;
5187 extended_color_output
= TRUE
;
5189 else if (streq (optarg
, "off"))
5190 visualize_jumps
= FALSE
;
5192 nonfatal (_("unrecognized argument to --visualize-option"));
5196 if (strcmp (optarg
, "B") == 0)
5197 endian
= BFD_ENDIAN_BIG
;
5198 else if (strcmp (optarg
, "L") == 0)
5199 endian
= BFD_ENDIAN_LITTLE
;
5202 nonfatal (_("unrecognized -E option"));
5207 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5208 endian
= BFD_ENDIAN_BIG
;
5209 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5210 endian
= BFD_ENDIAN_LITTLE
;
5213 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5220 dump_file_header
= TRUE
;
5224 formats_info
= TRUE
;
5228 add_include_path (optarg
);
5231 dump_private_headers
= TRUE
;
5235 dump_private_options
= optarg
;
5239 dump_private_headers
= TRUE
;
5241 dump_reloc_info
= TRUE
;
5242 dump_file_header
= TRUE
;
5243 dump_ar_hdrs
= TRUE
;
5244 dump_section_headers
= TRUE
;
5252 dump_dynamic_symtab
= TRUE
;
5258 disasm_sym
= optarg
;
5261 disassemble_zeroes
= TRUE
;
5265 disassemble_all
= TRUE
;
5270 with_source_code
= TRUE
;
5273 case OPTION_SOURCE_COMMENT
:
5275 with_source_code
= TRUE
;
5278 source_comment
= xstrdup (sanitize_string (optarg
));
5280 source_comment
= xstrdup ("# ");
5288 dump_debugging_tags
= 1;
5293 dump_dwarf_section_info
= TRUE
;
5296 dwarf_select_sections_by_letters (optarg
);
5298 dwarf_select_sections_all ();
5301 dump_dwarf_section_info
= TRUE
;
5304 dwarf_select_sections_by_names (optarg
);
5306 dwarf_select_sections_all ();
5308 case OPTION_DWARF_DEPTH
:
5311 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5314 case OPTION_DWARF_START
:
5317 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5318 suppress_bfd_header
= 1;
5321 case OPTION_DWARF_CHECK
:
5325 dump_ctf_section_info
= TRUE
;
5326 dump_ctf_section_name
= xstrdup (optarg
);
5329 case OPTION_CTF_PARENT
:
5330 dump_ctf_parent_name
= xstrdup (optarg
);
5333 dump_stab_section_info
= TRUE
;
5337 dump_section_contents
= TRUE
;
5341 dump_reloc_info
= TRUE
;
5345 dump_dynamic_reloc_info
= TRUE
;
5349 dump_ar_hdrs
= TRUE
;
5353 dump_section_headers
= TRUE
;
5358 show_version
= TRUE
;
5364 /* No need to set seenflag or to break - usage() does not return. */
5371 print_version ("objdump");
5377 exit_status
= display_info ();
5381 display_file ("a.out", target
, TRUE
);
5383 for (; optind
< argc
;)
5385 display_file (argv
[optind
], target
, optind
== argc
- 1);
5391 free (dump_ctf_section_name
);
5392 free (dump_ctf_parent_name
);
5393 free ((void *) source_comment
);
5395 END_PROGRESS (program_name
);