1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
127 static bfd_boolean visualize_jumps
= FALSE
; /* --visualize-jumps. */
128 static bfd_boolean color_output
= FALSE
; /* --visualize-jumps=color. */
129 static bfd_boolean extended_color_output
= FALSE
; /* --visualize-jumps=extended-color. */
131 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
133 /* A structure to record the sections mentioned in -j switches. */
136 const char * name
; /* The name of the section. */
137 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
138 struct only
* next
; /* Pointer to the next structure in the list. */
140 /* Pointer to an array of 'only' structures.
141 This pointer is NULL if the -j switch has not been used. */
142 static struct only
* only_list
= NULL
;
144 /* Variables for handling include file path table. */
145 static const char **include_paths
;
146 static int include_path_count
;
148 /* Extra info to pass to the section disassembler and address printing
150 struct objdump_disasm_info
153 bfd_boolean require_sec
;
154 arelent
** dynrelbuf
;
156 disassembler_ftype disassemble_fn
;
161 /* Architecture to disassemble for, or default if NULL. */
162 static char *machine
= NULL
;
164 /* Target specific options to the disassembler. */
165 static char *disassembler_options
= NULL
;
167 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
168 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
170 /* The symbol table. */
171 static asymbol
**syms
;
173 /* Number of symbols in `syms'. */
174 static long symcount
= 0;
176 /* The sorted symbol table. */
177 static asymbol
**sorted_syms
;
179 /* Number of symbols in `sorted_syms'. */
180 static long sorted_symcount
= 0;
182 /* The dynamic symbol table. */
183 static asymbol
**dynsyms
;
185 /* The synthetic symbol table. */
186 static asymbol
*synthsyms
;
187 static long synthcount
= 0;
189 /* Number of symbols in `dynsyms'. */
190 static long dynsymcount
= 0;
192 static bfd_byte
*stabs
;
193 static bfd_size_type stab_size
;
195 static bfd_byte
*strtab
;
196 static bfd_size_type stabstr_size
;
198 /* Handlers for -P/--private. */
199 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
201 OBJDUMP_PRIVATE_VECTORS
205 /* The list of detected jumps inside a function. */
206 static struct jump_info
*detected_jumps
= NULL
;
208 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
210 usage (FILE *stream
, int status
)
212 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
213 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
214 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
215 fprintf (stream
, _("\
216 -a, --archive-headers Display archive header information\n\
217 -f, --file-headers Display the contents of the overall file header\n\
218 -p, --private-headers Display object format specific file header contents\n\
219 -P, --private=OPT,OPT... Display object format specific contents\n\
220 -h, --[section-]headers Display the contents of the section headers\n\
221 -x, --all-headers Display the contents of all headers\n\
222 -d, --disassemble Display assembler contents of executable sections\n\
223 -D, --disassemble-all Display assembler contents of all sections\n\
224 --disassemble=<sym> Display assembler contents from <sym>\n\
225 -S, --source Intermix source code with disassembly\n\
226 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
227 -s, --full-contents Display the full contents of all sections requested\n\
228 -g, --debugging Display debug information in object file\n\
229 -e, --debugging-tags Display debug information using ctags style\n\
230 -G, --stabs Display (in raw form) any STABS info in the file\n\
231 -W[lLiaprmfFsoRtUuTgAckK] or\n\
232 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
233 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
234 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
235 =addr,=cu_index,=links,=follow-links]\n\
236 Display DWARF info in the file\n\
237 --ctf=SECTION Display CTF info from SECTION\n\
238 -t, --syms Display the contents of the symbol table(s)\n\
239 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
240 -r, --reloc Display the relocation entries in the file\n\
241 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
242 @<file> Read options from <file>\n\
243 -v, --version Display this program's version number\n\
244 -i, --info List object formats and architectures supported\n\
245 -H, --help Display this information\n\
249 const struct objdump_private_desc
* const *desc
;
251 fprintf (stream
, _("\n The following switches are optional:\n"));
252 fprintf (stream
, _("\
253 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
254 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
255 -j, --section=NAME Only display information for section NAME\n\
256 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
257 -EB --endian=big Assume big endian format when disassembling\n\
258 -EL --endian=little Assume little endian format when disassembling\n\
259 --file-start-context Include context from start of file (with -S)\n\
260 -I, --include=DIR Add DIR to search list for source files\n\
261 -l, --line-numbers Include line numbers and filenames in output\n\
262 -F, --file-offsets Include file offsets when displaying information\n\
263 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
264 The STYLE, if specified, can be `auto', `gnu',\n\
265 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
267 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
268 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
269 -w, --wide Format output for more than 80 columns\n\
270 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
271 --start-address=ADDR Only process data whose address is >= ADDR\n\
272 --stop-address=ADDR Only process data whose address is < ADDR\n\
273 --prefix-addresses Print complete address alongside disassembly\n\
274 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
275 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
276 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
277 --special-syms Include special symbols in symbol dumps\n\
278 --inlines Print all inlines for source line (with -l)\n\
279 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
280 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
281 fprintf (stream
, _("\
282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
285 --dwarf-check Make additional dwarf internal consistency checks.\
287 --ctf-parent=SECTION Use SECTION as the CTF parent\n\
288 --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
289 --visualize-jumps=color Use colors in the ASCII art\n\
290 --visualize-jumps=extended-color Use extended 8-bit color codes\n\
291 --visualize-jumps=off Disable jump visualization\n\n"));
293 list_supported_targets (program_name
, stream
);
294 list_supported_architectures (program_name
, stream
);
296 disassembler_usage (stream
);
298 if (objdump_private_vectors
[0] != NULL
)
301 _("\nOptions supported for -P/--private switch:\n"));
302 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
303 (*desc
)->help (stream
);
306 if (REPORT_BUGS_TO
[0] && status
== 0)
307 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
311 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
315 OPTION_START_ADDRESS
,
325 OPTION_RECURSE_LIMIT
,
326 OPTION_NO_RECURSE_LIMIT
,
328 OPTION_SOURCE_COMMENT
,
331 OPTION_VISUALIZE_JUMPS
334 static struct option long_options
[]=
336 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
337 {"all-headers", no_argument
, NULL
, 'x'},
338 {"private-headers", no_argument
, NULL
, 'p'},
339 {"private", required_argument
, NULL
, 'P'},
340 {"architecture", required_argument
, NULL
, 'm'},
341 {"archive-headers", no_argument
, NULL
, 'a'},
342 {"debugging", no_argument
, NULL
, 'g'},
343 {"debugging-tags", no_argument
, NULL
, 'e'},
344 {"demangle", optional_argument
, NULL
, 'C'},
345 {"disassemble", optional_argument
, NULL
, 'd'},
346 {"disassemble-all", no_argument
, NULL
, 'D'},
347 {"disassembler-options", required_argument
, NULL
, 'M'},
348 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
349 {"dynamic-reloc", no_argument
, NULL
, 'R'},
350 {"dynamic-syms", no_argument
, NULL
, 'T'},
351 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
352 {"file-headers", no_argument
, NULL
, 'f'},
353 {"file-offsets", no_argument
, NULL
, 'F'},
354 {"file-start-context", no_argument
, &file_start_context
, 1},
355 {"full-contents", no_argument
, NULL
, 's'},
356 {"headers", no_argument
, NULL
, 'h'},
357 {"help", no_argument
, NULL
, 'H'},
358 {"info", no_argument
, NULL
, 'i'},
359 {"line-numbers", no_argument
, NULL
, 'l'},
360 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
361 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
362 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
363 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
364 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
365 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
366 {"reloc", no_argument
, NULL
, 'r'},
367 {"section", required_argument
, NULL
, 'j'},
368 {"section-headers", no_argument
, NULL
, 'h'},
369 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
370 {"source", no_argument
, NULL
, 'S'},
371 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
372 {"special-syms", no_argument
, &dump_special_syms
, 1},
373 {"include", required_argument
, NULL
, 'I'},
374 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
375 {"ctf", required_argument
, NULL
, OPTION_CTF
},
376 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
377 {"stabs", no_argument
, NULL
, 'G'},
378 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
379 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
380 {"syms", no_argument
, NULL
, 't'},
381 {"target", required_argument
, NULL
, 'b'},
382 {"version", no_argument
, NULL
, 'V'},
383 {"wide", no_argument
, NULL
, 'w'},
384 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
385 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
386 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
387 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
388 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
389 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
390 {"inlines", no_argument
, 0, OPTION_INLINES
},
391 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
392 {0, no_argument
, 0, 0}
396 nonfatal (const char *msg
)
402 /* Returns a version of IN with any control characters
403 replaced by escape sequences. Uses a static buffer
407 sanitize_string (const char * in
)
409 static char * buffer
= NULL
;
410 static size_t buffer_len
= 0;
411 const char * original
= in
;
418 /* See if any conversion is necessary. In the majority
419 of cases it will not be needed. */
432 /* Copy the input, translating as needed. */
434 if (buffer_len
< (strlen (in
) * 2))
436 free ((void *) buffer
);
437 buffer_len
= strlen (in
) * 2;
438 buffer
= xmalloc (buffer_len
+ 1);
464 /* Returns TRUE if the specified section should be dumped. */
467 process_section_p (asection
* section
)
471 if (only_list
== NULL
)
474 for (only
= only_list
; only
; only
= only
->next
)
475 if (strcmp (only
->name
, section
->name
) == 0)
484 /* Add an entry to the 'only' list. */
487 add_only (char * name
)
491 /* First check to make sure that we do not
492 already have an entry for this name. */
493 for (only
= only_list
; only
; only
= only
->next
)
494 if (strcmp (only
->name
, name
) == 0)
497 only
= xmalloc (sizeof * only
);
500 only
->next
= only_list
;
504 /* Release the memory used by the 'only' list.
505 PR 11225: Issue a warning message for unseen sections.
506 Only do this if none of the sections were seen. This is mainly to support
507 tools like the GAS testsuite where an object file is dumped with a list of
508 generic section names known to be present in a range of different file
512 free_only_list (void)
514 bfd_boolean at_least_one_seen
= FALSE
;
518 if (only_list
== NULL
)
521 for (only
= only_list
; only
; only
= only
->next
)
524 at_least_one_seen
= TRUE
;
528 for (only
= only_list
; only
; only
= next
)
530 if (! at_least_one_seen
)
532 non_fatal (_("section '%s' mentioned in a -j option, "
533 "but not found in any input file"),
544 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
547 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
548 int longest_section_name
= *((int *) data
);
550 /* Ignore linker created section. See elfNN_ia64_object_p in
552 if (section
->flags
& SEC_LINKER_CREATED
)
555 /* PR 10413: Skip sections that we are ignoring. */
556 if (! process_section_p (section
))
559 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
560 sanitize_string (bfd_section_name (section
)),
561 (unsigned long) bfd_section_size (section
) / opb
);
562 bfd_printf_vma (abfd
, bfd_section_vma (section
));
564 bfd_printf_vma (abfd
, section
->lma
);
565 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
566 bfd_section_alignment (section
));
572 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
574 PF (SEC_HAS_CONTENTS
, "CONTENTS");
575 PF (SEC_ALLOC
, "ALLOC");
576 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
577 PF (SEC_LOAD
, "LOAD");
578 PF (SEC_RELOC
, "RELOC");
579 PF (SEC_READONLY
, "READONLY");
580 PF (SEC_CODE
, "CODE");
581 PF (SEC_DATA
, "DATA");
583 PF (SEC_DEBUGGING
, "DEBUGGING");
584 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
585 PF (SEC_EXCLUDE
, "EXCLUDE");
586 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
587 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
589 PF (SEC_TIC54X_BLOCK
, "BLOCK");
590 PF (SEC_TIC54X_CLINK
, "CLINK");
592 PF (SEC_SMALL_DATA
, "SMALL_DATA");
593 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
595 PF (SEC_COFF_SHARED
, "SHARED");
596 PF (SEC_COFF_NOREAD
, "NOREAD");
598 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
600 PF (SEC_ELF_OCTETS
, "OCTETS");
601 PF (SEC_ELF_PURECODE
, "PURECODE");
603 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
604 PF (SEC_GROUP
, "GROUP");
605 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
607 PF (SEC_MEP_VLIW
, "VLIW");
610 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
613 struct coff_comdat_info
*comdat
;
615 switch (section
->flags
& SEC_LINK_DUPLICATES
)
619 case SEC_LINK_DUPLICATES_DISCARD
:
620 ls
= "LINK_ONCE_DISCARD";
622 case SEC_LINK_DUPLICATES_ONE_ONLY
:
623 ls
= "LINK_ONCE_ONE_ONLY";
625 case SEC_LINK_DUPLICATES_SAME_SIZE
:
626 ls
= "LINK_ONCE_SAME_SIZE";
628 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
629 ls
= "LINK_ONCE_SAME_CONTENTS";
632 printf ("%s%s", comma
, ls
);
634 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
636 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
645 /* Called on each SECTION in ABFD, update the int variable pointed to by
646 DATA which contains the string length of the longest section name. */
649 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
650 asection
*section
, void *data
)
652 int *longest_so_far
= (int *) data
;
656 /* Ignore linker created section. */
657 if (section
->flags
& SEC_LINKER_CREATED
)
660 /* Skip sections that we are ignoring. */
661 if (! process_section_p (section
))
664 name
= bfd_section_name (section
);
665 len
= (int) strlen (name
);
666 if (len
> *longest_so_far
)
667 *longest_so_far
= len
;
671 dump_headers (bfd
*abfd
)
673 /* The default width of 13 is just an arbitrary choice. */
674 int max_section_name_length
= 13;
680 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
681 if (bfd_get_arch_size (abfd
) == 32)
687 printf (_("Sections:\n"));
690 bfd_map_over_sections (abfd
, find_longest_section_name
,
691 &max_section_name_length
);
693 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
694 max_section_name_length
, "Name",
695 bfd_vma_width
, "VMA",
696 bfd_vma_width
, "LMA");
699 printf (_(" Flags"));
702 bfd_map_over_sections (abfd
, dump_section_header
,
703 &max_section_name_length
);
707 slurp_symtab (bfd
*abfd
)
712 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
718 storage
= bfd_get_symtab_upper_bound (abfd
);
721 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
722 bfd_fatal (_("error message was"));
726 off_t filesize
= bfd_get_file_size (abfd
);
730 && filesize
< storage
731 /* The MMO file format supports its own special compression
732 technique, so its sections can be larger than the file size. */
733 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
735 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
736 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
737 storage
, (long) filesize
);
743 sy
= (asymbol
**) xmalloc (storage
);
746 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
748 bfd_fatal (bfd_get_filename (abfd
));
752 /* Read in the dynamic symbols. */
755 slurp_dynamic_symtab (bfd
*abfd
)
760 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
763 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
765 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
771 bfd_fatal (bfd_get_filename (abfd
));
774 sy
= (asymbol
**) xmalloc (storage
);
776 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
778 bfd_fatal (bfd_get_filename (abfd
));
782 /* Some symbol names are significant and should be kept in the
783 table of sorted symbol names, even if they are marked as
784 debugging/section symbols. */
787 is_significant_symbol_name (const char * name
)
789 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
792 /* Filter out (in place) symbols that are useless for disassembly.
793 COUNT is the number of elements in SYMBOLS.
794 Return the number of useful symbols. */
797 remove_useless_symbols (asymbol
**symbols
, long count
)
799 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
803 asymbol
*sym
= *in_ptr
++;
805 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
807 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
808 && ! is_significant_symbol_name (sym
->name
))
810 if (bfd_is_und_section (sym
->section
)
811 || bfd_is_com_section (sym
->section
))
816 return out_ptr
- symbols
;
819 static const asection
*compare_section
;
821 /* Sort symbols into value order. */
824 compare_symbols (const void *ap
, const void *bp
)
826 const asymbol
*a
= * (const asymbol
**) ap
;
827 const asymbol
*b
= * (const asymbol
**) bp
;
832 bfd_boolean as
, af
, bs
, bf
;
836 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
838 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
841 /* Prefer symbols from the section currently being disassembled.
842 Don't sort symbols from other sections by section, since there
843 isn't much reason to prefer one section over another otherwise.
844 See sym_ok comment for why we compare by section name. */
845 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
846 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
852 an
= bfd_asymbol_name (a
);
853 bn
= bfd_asymbol_name (b
);
857 /* The symbols gnu_compiled and gcc2_compiled convey no real
858 information, so put them after other symbols with the same value. */
859 af
= (strstr (an
, "gnu_compiled") != NULL
860 || strstr (an
, "gcc2_compiled") != NULL
);
861 bf
= (strstr (bn
, "gnu_compiled") != NULL
862 || strstr (bn
, "gcc2_compiled") != NULL
);
869 /* We use a heuristic for the file name, to try to sort it after
870 more useful symbols. It may not work on non Unix systems, but it
871 doesn't really matter; the only difference is precisely which
872 symbol names get printed. */
874 #define file_symbol(s, sn, snl) \
875 (((s)->flags & BSF_FILE) != 0 \
877 && (sn)[(snl) - 2] == '.' \
878 && ((sn)[(snl) - 1] == 'o' \
879 || (sn)[(snl) - 1] == 'a')))
881 af
= file_symbol (a
, an
, anl
);
882 bf
= file_symbol (b
, bn
, bnl
);
889 /* Sort function and object symbols before global symbols before
890 local symbols before section symbols before debugging symbols. */
895 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
897 if ((aflags
& BSF_DEBUGGING
) != 0)
902 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
904 if ((aflags
& BSF_SECTION_SYM
) != 0)
909 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
911 if ((aflags
& BSF_FUNCTION
) != 0)
916 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
918 if ((aflags
& BSF_OBJECT
) != 0)
923 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
925 if ((aflags
& BSF_LOCAL
) != 0)
930 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
932 if ((aflags
& BSF_GLOBAL
) != 0)
938 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
939 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
944 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
945 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
947 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
948 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
950 return asz
> bsz
? -1 : 1;
953 /* Symbols that start with '.' might be section names, so sort them
954 after symbols that don't start with '.'. */
955 if (an
[0] == '.' && bn
[0] != '.')
957 if (an
[0] != '.' && bn
[0] == '.')
960 /* Finally, if we can't distinguish them in any other way, try to
961 get consistent results by sorting the symbols by name. */
962 return strcmp (an
, bn
);
965 /* Sort relocs into address order. */
968 compare_relocs (const void *ap
, const void *bp
)
970 const arelent
*a
= * (const arelent
**) ap
;
971 const arelent
*b
= * (const arelent
**) bp
;
973 if (a
->address
> b
->address
)
975 else if (a
->address
< b
->address
)
978 /* So that associated relocations tied to the same address show up
979 in the correct order, we don't do any further sorting. */
988 /* Print an address (VMA) to the output stream in INFO.
989 If SKIP_ZEROES is TRUE, omit leading zeroes. */
992 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
993 bfd_boolean skip_zeroes
)
997 struct objdump_disasm_info
*aux
;
999 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1000 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1005 for (p
= buf
; *p
== '0'; ++p
)
1010 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1013 /* Print the name of a symbol. */
1016 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1020 const char *name
, *version_string
= NULL
;
1021 bfd_boolean hidden
= FALSE
;
1024 name
= bfd_asymbol_name (sym
);
1025 if (do_demangle
&& name
[0] != '\0')
1027 /* Demangle the name. */
1028 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1033 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1034 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1036 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1039 name
= sanitize_string (name
);
1043 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1044 if (version_string
&& *version_string
!= '\0')
1045 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1050 printf ("%s", name
);
1051 if (version_string
&& *version_string
!= '\0')
1052 printf (hidden
? "@%s" : "@@%s", version_string
);
1059 static inline bfd_boolean
1060 sym_ok (bfd_boolean want_section
,
1061 bfd
* abfd ATTRIBUTE_UNUSED
,
1064 struct disassemble_info
* inf
)
1068 /* Note - we cannot just compare section pointers because they could
1069 be different, but the same... Ie the symbol that we are trying to
1070 find could have come from a separate debug info file. Under such
1071 circumstances the symbol will be associated with a section in the
1072 debug info file, whilst the section we want is in a normal file.
1073 So the section pointers will be different, but the section names
1074 will be the same. */
1075 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1076 bfd_section_name (sec
)) != 0)
1080 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1083 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1084 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1085 require the symbol to be in the section. Returns NULL if there is no
1086 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1087 of the symbol in sorted_syms. */
1090 find_symbol_for_address (bfd_vma vma
,
1091 struct disassemble_info
*inf
,
1094 /* @@ Would it speed things up to cache the last two symbols returned,
1095 and maybe their address ranges? For many processors, only one memory
1096 operand can be present at a time, so the 2-entry cache wouldn't be
1097 constantly churned by code doing heavy memory accesses. */
1099 /* Indices in `sorted_syms'. */
1101 long max_count
= sorted_symcount
;
1103 struct objdump_disasm_info
*aux
;
1107 bfd_boolean want_section
;
1110 if (sorted_symcount
< 1)
1113 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1116 opb
= inf
->octets_per_byte
;
1118 /* Perform a binary search looking for the closest symbol to the
1119 required value. We are searching the range (min, max_count]. */
1120 while (min
+ 1 < max_count
)
1124 thisplace
= (max_count
+ min
) / 2;
1125 sym
= sorted_syms
[thisplace
];
1127 if (bfd_asymbol_value (sym
) > vma
)
1128 max_count
= thisplace
;
1129 else if (bfd_asymbol_value (sym
) < vma
)
1138 /* The symbol we want is now in min, the low end of the range we
1139 were searching. If there are several symbols with the same
1140 value, we want the first one. */
1142 while (thisplace
> 0
1143 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1144 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1147 /* Prefer a symbol in the current section if we have multple symbols
1148 with the same value, as can occur with overlays or zero size
1151 while (min
< max_count
1152 && (bfd_asymbol_value (sorted_syms
[min
])
1153 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1155 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1162 return sorted_syms
[thisplace
];
1167 /* If the file is relocatable, and the symbol could be from this
1168 section, prefer a symbol from this section over symbols from
1169 others, even if the other symbol's value might be closer.
1171 Note that this may be wrong for some symbol references if the
1172 sections have overlapping memory ranges, but in that case there's
1173 no way to tell what's desired without looking at the relocation
1176 Also give the target a chance to reject symbols. */
1177 want_section
= (aux
->require_sec
1178 || ((abfd
->flags
& HAS_RELOC
) != 0
1179 && vma
>= bfd_section_vma (sec
)
1180 && vma
< (bfd_section_vma (sec
)
1181 + bfd_section_size (sec
) / opb
)));
1183 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1186 long newplace
= sorted_symcount
;
1188 for (i
= min
- 1; i
>= 0; i
--)
1190 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1192 if (newplace
== sorted_symcount
)
1195 if (bfd_asymbol_value (sorted_syms
[i
])
1196 != bfd_asymbol_value (sorted_syms
[newplace
]))
1199 /* Remember this symbol and keep searching until we reach
1200 an earlier address. */
1205 if (newplace
!= sorted_symcount
)
1206 thisplace
= newplace
;
1209 /* We didn't find a good symbol with a smaller value.
1210 Look for one with a larger value. */
1211 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1213 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1221 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1222 /* There is no suitable symbol. */
1226 /* If we have not found an exact match for the specified address
1227 and we have dynamic relocations available, then we can produce
1228 a better result by matching a relocation to the address and
1229 using the symbol associated with that relocation. */
1230 rel_count
= aux
->dynrelcount
;
1232 && sorted_syms
[thisplace
]->value
!= vma
1234 && aux
->dynrelbuf
!= NULL
1235 && aux
->dynrelbuf
[0]->address
<= vma
1236 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1237 /* If we have matched a synthetic symbol, then stick with that. */
1238 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1241 arelent
** rel_high
;
1243 rel_low
= aux
->dynrelbuf
;
1244 rel_high
= rel_low
+ rel_count
- 1;
1245 while (rel_low
<= rel_high
)
1247 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1248 arelent
* rel
= *rel_mid
;
1250 if (rel
->address
== vma
)
1252 /* Absolute relocations do not provide a more helpful
1253 symbolic address. Find a non-absolute relocation
1254 with the same address. */
1255 arelent
**rel_vma
= rel_mid
;
1257 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1261 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1265 if (rel
->sym_ptr_ptr
!= NULL
1266 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1269 * place
= thisplace
;
1270 return * rel
->sym_ptr_ptr
;
1276 if (vma
< rel
->address
)
1278 else if (vma
>= rel_mid
[1]->address
)
1279 rel_low
= rel_mid
+ 1;
1288 return sorted_syms
[thisplace
];
1291 /* Print an address and the offset to the nearest symbol. */
1294 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1295 bfd_vma vma
, struct disassemble_info
*inf
,
1296 bfd_boolean skip_zeroes
)
1298 objdump_print_value (vma
, inf
, skip_zeroes
);
1304 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1305 sanitize_string (bfd_section_name (sec
)));
1306 secaddr
= bfd_section_vma (sec
);
1309 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1310 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1312 else if (vma
> secaddr
)
1314 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1315 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1317 (*inf
->fprintf_func
) (inf
->stream
, ">");
1321 (*inf
->fprintf_func
) (inf
->stream
, " <");
1323 objdump_print_symname (abfd
, inf
, sym
);
1325 if (bfd_asymbol_value (sym
) == vma
)
1327 /* Undefined symbols in an executables and dynamic objects do not have
1328 a value associated with them, so it does not make sense to display
1329 an offset relative to them. Normally we would not be provided with
1330 this kind of symbol, but the target backend might choose to do so,
1331 and the code in find_symbol_for_address might return an as yet
1332 unresolved symbol associated with a dynamic reloc. */
1333 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1334 && bfd_is_und_section (sym
->section
))
1336 else if (bfd_asymbol_value (sym
) > vma
)
1338 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1339 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1341 else if (vma
> bfd_asymbol_value (sym
))
1343 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1344 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1347 (*inf
->fprintf_func
) (inf
->stream
, ">");
1350 if (display_file_offsets
)
1351 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1352 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1355 /* Print an address (VMA), symbolically if possible.
1356 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1359 objdump_print_addr (bfd_vma vma
,
1360 struct disassemble_info
*inf
,
1361 bfd_boolean skip_zeroes
)
1363 struct objdump_disasm_info
*aux
;
1364 asymbol
*sym
= NULL
;
1365 bfd_boolean skip_find
= FALSE
;
1367 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1369 if (sorted_symcount
< 1)
1371 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1372 objdump_print_value (vma
, inf
, skip_zeroes
);
1374 if (display_file_offsets
)
1375 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1376 (long int) (inf
->section
->filepos
1377 + (vma
- inf
->section
->vma
)));
1381 if (aux
->reloc
!= NULL
1382 && aux
->reloc
->sym_ptr_ptr
!= NULL
1383 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1385 sym
= * aux
->reloc
->sym_ptr_ptr
;
1387 /* Adjust the vma to the reloc. */
1388 vma
+= bfd_asymbol_value (sym
);
1390 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1395 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1397 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1401 /* Print VMA to INFO. This function is passed to the disassembler
1405 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1407 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1410 /* Determine if the given address has a symbol associated with it. */
1413 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1417 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1419 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1422 /* Hold the last function name and the last line number we displayed
1423 in a disassembly. */
1425 static char *prev_functionname
;
1426 static unsigned int prev_line
;
1427 static unsigned int prev_discriminator
;
1429 /* We keep a list of all files that we have seen when doing a
1430 disassembly with source, so that we know how much of the file to
1431 display. This can be important for inlined functions. */
1433 struct print_file_list
1435 struct print_file_list
*next
;
1436 const char *filename
;
1437 const char *modname
;
1440 const char **linemap
;
1443 unsigned max_printed
;
1447 static struct print_file_list
*print_files
;
1449 /* The number of preceding context lines to show when we start
1450 displaying a file for the first time. */
1452 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1454 /* Read a complete file into memory. */
1457 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1460 int ps
= getpagesize ();
1464 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1468 if (fstat (fd
, fst
) < 0)
1473 *size
= fst
->st_size
;
1475 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1476 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1477 if (map
!= (char *) -1L)
1483 map
= (const char *) malloc (*size
);
1484 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1486 free ((void *) map
);
1493 #define line_map_decrease 5
1495 /* Precompute array of lines for a mapped file. */
1497 static const char **
1498 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1500 const char *p
, *lstart
, *end
;
1501 int chars_per_line
= 45; /* First iteration will use 40. */
1502 unsigned int lineno
;
1503 const char **linemap
= NULL
;
1504 unsigned long line_map_size
= 0;
1510 for (p
= map
; p
< end
; p
++)
1514 if (p
+ 1 < end
&& p
[1] == '\r')
1517 else if (*p
== '\r')
1519 if (p
+ 1 < end
&& p
[1] == '\n')
1525 /* End of line found. */
1527 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1529 unsigned long newsize
;
1531 chars_per_line
-= line_map_decrease
;
1532 if (chars_per_line
<= 1)
1534 line_map_size
= size
/ chars_per_line
+ 1;
1535 if (line_map_size
< lineno
+ 1)
1536 line_map_size
= lineno
+ 1;
1537 newsize
= line_map_size
* sizeof (char *);
1538 linemap
= (const char **) xrealloc (linemap
, newsize
);
1541 linemap
[lineno
++] = lstart
;
1549 /* Tries to open MODNAME, and if successful adds a node to print_files
1550 linked list and returns that node. Returns NULL on failure. */
1552 static struct print_file_list
*
1553 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1555 struct print_file_list
*p
;
1557 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1559 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1566 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1569 p
->filename
= origname
;
1570 p
->modname
= modname
;
1571 p
->next
= print_files
;
1577 /* If the source file, as described in the symtab, is not found
1578 try to locate it in one of the paths specified with -I
1579 If found, add location to print_files linked list. */
1581 static struct print_file_list
*
1582 update_source_path (const char *filename
, bfd
*abfd
)
1584 struct print_file_list
*p
;
1589 p
= try_print_file_open (filename
, filename
, &fst
);
1592 if (include_path_count
== 0)
1595 /* Get the name of the file. */
1596 fname
= lbasename (filename
);
1598 /* If file exists under a new path, we need to add it to the list
1599 so that show_line knows about it. */
1600 for (i
= 0; i
< include_path_count
; i
++)
1602 char *modname
= concat (include_paths
[i
], "/", fname
,
1605 p
= try_print_file_open (filename
, modname
, &fst
);
1615 long mtime
= bfd_get_mtime (abfd
);
1617 if (fst
.st_mtime
> mtime
)
1618 warn (_("source file %s is more recent than object file\n"),
1625 /* Print a source file line. */
1628 print_line (struct print_file_list
*p
, unsigned int linenum
)
1634 if (linenum
>= p
->maxline
)
1636 l
= p
->linemap
[linenum
];
1637 if (source_comment
!= NULL
&& strlen (l
) > 0)
1638 printf ("%s", source_comment
);
1639 len
= strcspn (l
, "\n\r");
1640 /* Test fwrite return value to quiet glibc warning. */
1641 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1645 /* Print a range of source code lines. */
1648 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1652 while (start
<= end
)
1654 print_line (p
, start
);
1659 /* Show the line number, or the source line, in a disassembly
1663 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1665 const char *filename
;
1666 const char *functionname
;
1667 unsigned int linenumber
;
1668 unsigned int discriminator
;
1672 if (! with_line_numbers
&& ! with_source_code
)
1675 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1676 &filename
, &functionname
,
1677 &linenumber
, &discriminator
))
1680 if (filename
!= NULL
&& *filename
== '\0')
1682 if (functionname
!= NULL
&& *functionname
== '\0')
1683 functionname
= NULL
;
1686 && IS_ABSOLUTE_PATH (filename
)
1690 const char *fname
= filename
;
1692 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1695 memcpy (path
, prefix
, prefix_length
);
1696 path_up
= path
+ prefix_length
;
1698 /* Build relocated filename, stripping off leading directories
1699 from the initial filename if requested. */
1700 if (prefix_strip
> 0)
1705 /* Skip selected directory levels. */
1706 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1707 if (IS_DIR_SEPARATOR(*s
))
1714 /* Update complete filename. */
1715 strncpy (path_up
, fname
, PATH_MAX
);
1716 path_up
[PATH_MAX
] = '\0';
1724 if (with_line_numbers
)
1726 if (functionname
!= NULL
1727 && (prev_functionname
== NULL
1728 || strcmp (functionname
, prev_functionname
) != 0))
1730 printf ("%s():\n", sanitize_string (functionname
));
1734 && (linenumber
!= prev_line
1735 || discriminator
!= prev_discriminator
))
1737 if (discriminator
> 0)
1738 printf ("%s:%u (discriminator %u)\n",
1739 filename
== NULL
? "???" : sanitize_string (filename
),
1740 linenumber
, discriminator
);
1742 printf ("%s:%u\n", filename
== NULL
1743 ? "???" : sanitize_string (filename
),
1748 const char *filename2
;
1749 const char *functionname2
;
1752 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1755 printf ("inlined by %s:%u",
1756 sanitize_string (filename2
), line2
);
1757 printf (" (%s)\n", sanitize_string (functionname2
));
1762 if (with_source_code
1766 struct print_file_list
**pp
, *p
;
1769 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1770 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1777 filename
= xstrdup (filename
);
1778 p
= update_source_path (filename
, abfd
);
1781 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1783 if (file_start_context
&& p
->first
)
1787 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1788 if (l
>= linenumber
)
1790 if (p
->max_printed
>= l
)
1792 if (p
->max_printed
< linenumber
)
1793 l
= p
->max_printed
+ 1;
1798 dump_lines (p
, l
, linenumber
);
1799 if (p
->max_printed
< linenumber
)
1800 p
->max_printed
= linenumber
;
1801 p
->last_line
= linenumber
;
1806 if (functionname
!= NULL
1807 && (prev_functionname
== NULL
1808 || strcmp (functionname
, prev_functionname
) != 0))
1810 if (prev_functionname
!= NULL
)
1811 free (prev_functionname
);
1812 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1813 strcpy (prev_functionname
, functionname
);
1816 if (linenumber
> 0 && linenumber
!= prev_line
)
1817 prev_line
= linenumber
;
1819 if (discriminator
!= prev_discriminator
)
1820 prev_discriminator
= discriminator
;
1826 /* Pseudo FILE object for strings. */
1834 /* sprintf to a "stream". */
1836 static int ATTRIBUTE_PRINTF_2
1837 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1844 size_t space
= f
->alloc
- f
->pos
;
1846 va_start (args
, format
);
1847 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1853 f
->alloc
= (f
->alloc
+ n
) * 2;
1854 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1861 /* Code for generating (colored) diagrams of control flow start and end
1864 /* Structure used to store the properties of a jump. */
1868 /* The next jump, or NULL if this is the last object. */
1869 struct jump_info
*next
;
1870 /* The previous jump, or NULL if this is the first object. */
1871 struct jump_info
*prev
;
1872 /* The start addresses of the jump. */
1875 /* The list of start addresses. */
1877 /* The number of elements. */
1879 /* The maximum number of elements that fit into the array. */
1882 /* The end address of the jump. */
1884 /* The drawing level of the jump. */
1888 /* Construct a jump object for a jump from start
1889 to end with the corresponding level. */
1891 static struct jump_info
*
1892 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
1894 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
1896 result
->next
= NULL
;
1897 result
->prev
= NULL
;
1898 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
1899 result
->start
.addresses
[0] = start
;
1900 result
->start
.count
= 1;
1901 result
->start
.max_count
= 2;
1903 result
->level
= level
;
1908 /* Free a jump object and return the next object
1909 or NULL if this was the last one. */
1911 static struct jump_info
*
1912 jump_info_free (struct jump_info
*ji
)
1914 struct jump_info
*result
= NULL
;
1919 if (ji
->start
.addresses
)
1920 free (ji
->start
.addresses
);
1927 /* Get the smallest value of all start and end addresses. */
1930 jump_info_min_address (const struct jump_info
*ji
)
1932 bfd_vma min_address
= ji
->end
;
1935 for (i
= ji
->start
.count
; i
-- > 0;)
1936 if (ji
->start
.addresses
[i
] < min_address
)
1937 min_address
= ji
->start
.addresses
[i
];
1941 /* Get the largest value of all start and end addresses. */
1944 jump_info_max_address (const struct jump_info
*ji
)
1946 bfd_vma max_address
= ji
->end
;
1949 for (i
= ji
->start
.count
; i
-- > 0;)
1950 if (ji
->start
.addresses
[i
] > max_address
)
1951 max_address
= ji
->start
.addresses
[i
];
1955 /* Get the target address of a jump. */
1958 jump_info_end_address (const struct jump_info
*ji
)
1963 /* Test if an address is one of the start addresses of a jump. */
1966 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
1968 bfd_boolean result
= FALSE
;
1971 for (i
= ji
->start
.count
; i
-- > 0;)
1972 if (address
== ji
->start
.addresses
[i
])
1981 /* Test if an address is the target address of a jump. */
1984 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
1986 return (address
== ji
->end
);
1989 /* Get the difference between the smallest and largest address of a jump. */
1992 jump_info_size (const struct jump_info
*ji
)
1994 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
1997 /* Unlink a jump object from a list. */
2000 jump_info_unlink (struct jump_info
*node
,
2001 struct jump_info
**base
)
2004 node
->next
->prev
= node
->prev
;
2006 node
->prev
->next
= node
->next
;
2013 /* Insert unlinked jump info node into a list. */
2016 jump_info_insert (struct jump_info
*node
,
2017 struct jump_info
*target
,
2018 struct jump_info
**base
)
2020 node
->next
= target
;
2021 node
->prev
= target
->prev
;
2022 target
->prev
= node
;
2024 node
->prev
->next
= node
;
2029 /* Add unlinked node to the front of a list. */
2032 jump_info_add_front (struct jump_info
*node
,
2033 struct jump_info
**base
)
2037 node
->next
->prev
= node
;
2042 /* Move linked node to target position. */
2045 jump_info_move_linked (struct jump_info
*node
,
2046 struct jump_info
*target
,
2047 struct jump_info
**base
)
2050 jump_info_unlink (node
, base
);
2051 /* Insert node at target position. */
2052 jump_info_insert (node
, target
, base
);
2055 /* Test if two jumps intersect. */
2058 jump_info_intersect (const struct jump_info
*a
,
2059 const struct jump_info
*b
)
2061 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2062 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2065 /* Merge two compatible jump info objects. */
2068 jump_info_merge (struct jump_info
**base
)
2070 struct jump_info
*a
;
2072 for (a
= *base
; a
; a
= a
->next
)
2074 struct jump_info
*b
;
2076 for (b
= a
->next
; b
; b
= b
->next
)
2078 /* Merge both jumps into one. */
2079 if (a
->end
== b
->end
)
2081 /* Reallocate addresses. */
2082 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2085 if (needed_size
> a
->start
.max_count
)
2087 a
->start
.max_count
+= b
->start
.max_count
;
2088 a
->start
.addresses
=
2089 xrealloc (a
->start
.addresses
,
2090 a
->start
.max_count
* sizeof(bfd_vma
*));
2093 /* Append start addresses. */
2094 for (i
= 0; i
< b
->start
.count
; ++i
)
2095 a
->start
.addresses
[a
->start
.count
++] =
2096 b
->start
.addresses
[i
];
2098 /* Remove and delete jump. */
2099 struct jump_info
*tmp
= b
->prev
;
2100 jump_info_unlink (b
, base
);
2108 /* Sort jumps by their size and starting point using a stable
2109 minsort. This could be improved if sorting performance is
2110 an issue, for example by using mergesort. */
2113 jump_info_sort (struct jump_info
**base
)
2115 struct jump_info
*current_element
= *base
;
2117 while (current_element
)
2119 struct jump_info
*best_match
= current_element
;
2120 struct jump_info
*runner
= current_element
->next
;
2121 bfd_vma best_size
= jump_info_size (best_match
);
2125 bfd_vma runner_size
= jump_info_size (runner
);
2127 if ((runner_size
< best_size
)
2128 || ((runner_size
== best_size
)
2129 && (jump_info_min_address (runner
)
2130 < jump_info_min_address (best_match
))))
2132 best_match
= runner
;
2133 best_size
= runner_size
;
2136 runner
= runner
->next
;
2139 if (best_match
== current_element
)
2140 current_element
= current_element
->next
;
2142 jump_info_move_linked (best_match
, current_element
, base
);
2146 /* Visualize all jumps at a given address. */
2149 jump_info_visualize_address (const struct jump_info
*jumps
,
2153 uint8_t *color_buffer
)
2155 size_t len
= (max_level
+ 1) * 3;
2156 const struct jump_info
*ji
;
2158 /* Clear line buffer. */
2159 memset(line_buffer
, ' ', len
);
2160 memset(color_buffer
, 0, len
);
2162 /* Iterate over jumps and add their ASCII art. */
2163 for (ji
= jumps
; ji
; ji
= ji
->next
)
2165 if ((jump_info_min_address (ji
) <= address
)
2166 && (jump_info_max_address (ji
) >= address
))
2168 /* Hash target address to get an even
2169 distribution between all values. */
2170 bfd_vma hash_address
= jump_info_end_address (ji
);
2171 uint8_t color
= iterative_hash_object (hash_address
, 0);
2172 /* Fetch line offset. */
2173 int offset
= (max_level
- ji
->level
) * 3;
2175 /* Draw start line. */
2176 if (jump_info_is_start_address (ji
, address
))
2178 size_t i
= offset
+ 1;
2180 for (; i
< len
- 1; ++i
)
2181 if (line_buffer
[i
] == ' ')
2183 line_buffer
[i
] = '-';
2184 color_buffer
[i
] = color
;
2187 if (line_buffer
[i
] == ' ')
2189 line_buffer
[i
] = '-';
2190 color_buffer
[i
] = color
;
2192 else if (line_buffer
[i
] == '>')
2194 line_buffer
[i
] = 'X';
2195 color_buffer
[i
] = color
;
2198 if (line_buffer
[offset
] == ' ')
2200 if (address
<= ji
->end
)
2201 line_buffer
[offset
] =
2202 (jump_info_min_address (ji
) == address
) ? '/': '+';
2204 line_buffer
[offset
] =
2205 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2206 color_buffer
[offset
] = color
;
2209 /* Draw jump target. */
2210 else if (jump_info_is_end_address (ji
, address
))
2212 size_t i
= offset
+ 1;
2214 for (; i
< len
- 1; ++i
)
2215 if (line_buffer
[i
] == ' ')
2217 line_buffer
[i
] = '-';
2218 color_buffer
[i
] = color
;
2221 if (line_buffer
[i
] == ' ')
2223 line_buffer
[i
] = '>';
2224 color_buffer
[i
] = color
;
2226 else if (line_buffer
[i
] == '-')
2228 line_buffer
[i
] = 'X';
2229 color_buffer
[i
] = color
;
2232 if (line_buffer
[offset
] == ' ')
2234 if (jump_info_min_address (ji
) < address
)
2235 line_buffer
[offset
] =
2236 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2238 line_buffer
[offset
] = '/';
2239 color_buffer
[offset
] = color
;
2242 /* Draw intermediate line segment. */
2243 else if (line_buffer
[offset
] == ' ')
2245 line_buffer
[offset
] = '|';
2246 color_buffer
[offset
] = color
;
2252 /* Clone of disassemble_bytes to detect jumps inside a function. */
2253 /* FIXME: is this correct? Can we strip it down even further? */
2255 static struct jump_info
*
2256 disassemble_jumps (struct disassemble_info
* inf
,
2257 disassembler_ftype disassemble_fn
,
2258 bfd_vma start_offset
,
2259 bfd_vma stop_offset
,
2262 arelent
** relppend
)
2264 struct objdump_disasm_info
*aux
;
2265 struct jump_info
*jumps
= NULL
;
2267 bfd_vma addr_offset
;
2268 unsigned int opb
= inf
->octets_per_byte
;
2272 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2273 section
= inf
->section
;
2276 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2279 inf
->insn_info_valid
= 0;
2280 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2281 inf
->stream
= &sfile
;
2283 addr_offset
= start_offset
;
2284 while (addr_offset
< stop_offset
)
2286 int previous_octets
;
2288 /* Remember the length of the previous instruction. */
2289 previous_octets
= octets
;
2293 inf
->bytes_per_line
= 0;
2294 inf
->bytes_per_chunk
= 0;
2295 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2296 | (wide_output
? WIDE_OUTPUT
: 0));
2298 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2300 if (inf
->disassembler_needs_relocs
2301 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2302 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2303 && *relppp
< relppend
)
2305 bfd_signed_vma distance_to_rel
;
2307 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2309 /* Check to see if the current reloc is associated with
2310 the instruction that we are about to disassemble. */
2311 if (distance_to_rel
== 0
2312 /* FIXME: This is wrong. We are trying to catch
2313 relocs that are addressed part way through the
2314 current instruction, as might happen with a packed
2315 VLIW instruction. Unfortunately we do not know the
2316 length of the current instruction since we have not
2317 disassembled it yet. Instead we take a guess based
2318 upon the length of the previous instruction. The
2319 proper solution is to have a new target-specific
2320 disassembler function which just returns the length
2321 of an instruction at a given address without trying
2322 to display its disassembly. */
2323 || (distance_to_rel
> 0
2324 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2326 inf
->flags
|= INSN_HAS_RELOC
;
2330 if (! disassemble_all
2331 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2332 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2333 /* Set a stop_vma so that the disassembler will not read
2334 beyond the next symbol. We assume that symbols appear on
2335 the boundaries between instructions. We only do this when
2336 disassembling code of course, and when -D is in effect. */
2337 inf
->stop_vma
= section
->vma
+ stop_offset
;
2339 inf
->stop_offset
= stop_offset
;
2341 /* Extract jump information. */
2342 inf
->insn_info_valid
= 0;
2343 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2344 /* Test if a jump was detected. */
2345 if (inf
->insn_info_valid
2346 && ((inf
->insn_type
== dis_branch
)
2347 || (inf
->insn_type
== dis_condbranch
)
2348 || (inf
->insn_type
== dis_jsr
)
2349 || (inf
->insn_type
== dis_condjsr
))
2350 && (inf
->target
>= section
->vma
+ start_offset
)
2351 && (inf
->target
< section
->vma
+ stop_offset
))
2353 struct jump_info
*ji
=
2354 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2355 jump_info_add_front (ji
, &jumps
);
2360 addr_offset
+= octets
/ opb
;
2363 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2364 inf
->stream
= stdout
;
2366 free (sfile
.buffer
);
2369 jump_info_merge (&jumps
);
2370 /* Process jumps. */
2371 jump_info_sort (&jumps
);
2373 /* Group jumps by level. */
2374 struct jump_info
*last_jump
= jumps
;
2379 /* The last jump is part of the next group. */
2380 struct jump_info
*base
= last_jump
;
2381 /* Increment level. */
2382 base
->level
= ++max_level
;
2384 /* Find jumps that can be combined on the same
2385 level, with the largest jumps tested first.
2386 This has the advantage that large jumps are on
2387 lower levels and do not intersect with small
2388 jumps that get grouped on higher levels. */
2389 struct jump_info
*exchange_item
= last_jump
->next
;
2390 struct jump_info
*it
= exchange_item
;
2392 for (; it
; it
= it
->next
)
2394 /* Test if the jump intersects with any
2395 jump from current group. */
2396 bfd_boolean ok
= TRUE
;
2397 struct jump_info
*it_collision
;
2399 for (it_collision
= base
;
2400 it_collision
!= exchange_item
;
2401 it_collision
= it_collision
->next
)
2403 /* This jump intersects so we leave it out. */
2404 if (jump_info_intersect (it_collision
, it
))
2411 /* Add jump to group. */
2414 /* Move current element to the front. */
2415 if (it
!= exchange_item
)
2417 struct jump_info
*save
= it
->prev
;
2418 jump_info_move_linked (it
, exchange_item
, &jumps
);
2424 last_jump
= exchange_item
;
2425 exchange_item
= exchange_item
->next
;
2427 last_jump
->level
= max_level
;
2431 /* Move to next group. */
2432 last_jump
= exchange_item
;
2438 /* The number of zeroes we want to see before we start skipping them.
2439 The number is arbitrarily chosen. */
2441 #define DEFAULT_SKIP_ZEROES 8
2443 /* The number of zeroes to skip at the end of a section. If the
2444 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2445 SKIP_ZEROES, they will be disassembled. If there are fewer than
2446 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2447 attempt to avoid disassembling zeroes inserted by section
2450 #define DEFAULT_SKIP_ZEROES_AT_END 3
2453 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2458 /* Disassemble some data in memory between given values. */
2461 disassemble_bytes (struct disassemble_info
* inf
,
2462 disassembler_ftype disassemble_fn
,
2465 bfd_vma start_offset
,
2466 bfd_vma stop_offset
,
2469 arelent
** relppend
)
2471 struct objdump_disasm_info
*aux
;
2473 int octets_per_line
;
2474 int skip_addr_chars
;
2475 bfd_vma addr_offset
;
2476 unsigned int opb
= inf
->octets_per_byte
;
2477 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2478 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2482 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2483 section
= inf
->section
;
2486 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2490 octets_per_line
= insn_width
;
2492 octets_per_line
= 4;
2494 octets_per_line
= 16;
2496 /* Figure out how many characters to skip at the start of an
2497 address, to make the disassembly look nicer. We discard leading
2498 zeroes in chunks of 4, ensuring that there is always a leading
2500 skip_addr_chars
= 0;
2501 if (! prefix_addresses
)
2505 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2507 while (buf
[skip_addr_chars
] == '0')
2510 /* Don't discard zeros on overflow. */
2511 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2512 skip_addr_chars
= 0;
2514 if (skip_addr_chars
!= 0)
2515 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2518 inf
->insn_info_valid
= 0;
2520 /* Determine maximum level. */
2522 struct jump_info
*base
= detected_jumps
? detected_jumps
: NULL
;
2523 struct jump_info
*ji
;
2525 for (ji
= base
; ji
; ji
= ji
->next
)
2527 if (ji
->level
> max_level
)
2529 max_level
= ji
->level
;
2533 /* Allocate line buffer if there are any jumps. */
2534 size_t len
= (max_level
+ 1) * 3 + 1;
2535 char *line_buffer
= (max_level
>= 0) ? xmalloc(len
): NULL
;
2536 uint8_t *color_buffer
= (max_level
>= 0) ? xmalloc(len
): NULL
;
2540 line_buffer
[len
- 1] = 0;
2541 color_buffer
[len
- 1] = 0;
2544 addr_offset
= start_offset
;
2545 while (addr_offset
< stop_offset
)
2548 bfd_boolean need_nl
= FALSE
;
2552 /* Make sure we don't use relocs from previous instructions. */
2555 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2557 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
2560 if (! disassemble_zeroes
2561 && (inf
->insn_info_valid
== 0
2562 || inf
->branch_delay_insns
== 0)
2563 && (z
- addr_offset
* opb
>= skip_zeroes
2564 || (z
== stop_offset
* opb
&&
2565 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
2567 /* If there are more nonzero octets to follow, we only skip
2568 zeroes in multiples of 4, to try to avoid running over
2569 the start of an instruction which happens to start with
2571 if (z
!= stop_offset
* opb
)
2572 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
2574 octets
= z
- addr_offset
* opb
;
2576 /* If we are going to display more data, and we are displaying
2577 file offsets, then tell the user how many zeroes we skip
2578 and the file offset from where we resume dumping. */
2579 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
2580 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
2582 (unsigned long) (section
->filepos
2583 + (addr_offset
+ (octets
/ opb
))));
2593 if (with_line_numbers
|| with_source_code
)
2594 show_line (aux
->abfd
, section
, addr_offset
);
2596 if (! prefix_addresses
)
2600 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2601 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2605 printf ("%s:\t", buf
+ skip_addr_chars
);
2609 aux
->require_sec
= TRUE
;
2610 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2611 aux
->require_sec
= FALSE
;
2615 /* Visualize jumps. */
2618 jump_info_visualize_address (base
,
2619 section
->vma
+ addr_offset
,
2624 size_t line_buffer_size
= strlen (line_buffer
);
2625 char last_color
= 0;
2628 for (i
= 0; i
<= line_buffer_size
; ++i
)
2632 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2634 if (color
!= last_color
)
2637 if (extended_color_output
)
2638 /* Use extended 8bit color, but
2639 do not choose dark colors. */
2640 printf ("\033[38;5;%dm", 124 + (color
% 108));
2642 /* Use simple terminal colors. */
2643 printf ("\033[%dm", 31 + (color
% 7));
2650 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2657 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2658 inf
->stream
= &sfile
;
2659 inf
->bytes_per_line
= 0;
2660 inf
->bytes_per_chunk
= 0;
2661 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2662 | (wide_output
? WIDE_OUTPUT
: 0));
2664 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2666 if (inf
->disassembler_needs_relocs
2667 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2668 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2669 && *relppp
< relppend
)
2671 bfd_signed_vma distance_to_rel
;
2673 int max_reloc_offset
2674 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2676 distance_to_rel
= ((**relppp
)->address
- rel_offset
2679 if (distance_to_rel
> 0
2680 && (max_reloc_offset
< 0
2681 || distance_to_rel
<= max_reloc_offset
))
2683 /* This reloc *might* apply to the current insn,
2684 starting somewhere inside it. Discover the length
2685 of the current insn so that the check below will
2688 insn_size
= insn_width
;
2691 /* We find the length by calling the dissassembler
2692 function with a dummy print handler. This should
2693 work unless the disassembler is not expecting to
2694 be called multiple times for the same address.
2696 This does mean disassembling the instruction
2697 twice, but we only do this when there is a high
2698 probability that there is a reloc that will
2699 affect the instruction. */
2700 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2701 insn_size
= disassemble_fn (section
->vma
2702 + addr_offset
, inf
);
2703 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2707 /* Check to see if the current reloc is associated with
2708 the instruction that we are about to disassemble. */
2709 if (distance_to_rel
== 0
2710 || (distance_to_rel
> 0
2711 && distance_to_rel
< insn_size
/ (int) opb
))
2713 inf
->flags
|= INSN_HAS_RELOC
;
2714 aux
->reloc
= **relppp
;
2718 if (! disassemble_all
2719 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2720 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2721 /* Set a stop_vma so that the disassembler will not read
2722 beyond the next symbol. We assume that symbols appear on
2723 the boundaries between instructions. We only do this when
2724 disassembling code of course, and when -D is in effect. */
2725 inf
->stop_vma
= section
->vma
+ stop_offset
;
2727 inf
->stop_offset
= stop_offset
;
2728 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2731 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2732 inf
->stream
= stdout
;
2733 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2734 octets_per_line
= inf
->bytes_per_line
;
2735 if (octets
< (int) opb
)
2738 printf ("%s\n", sfile
.buffer
);
2741 non_fatal (_("disassemble_fn returned length %d"),
2752 octets
= octets_per_line
;
2753 if (addr_offset
+ octets
/ opb
> stop_offset
)
2754 octets
= (stop_offset
- addr_offset
) * opb
;
2756 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2758 if (ISPRINT (data
[j
]))
2759 buf
[j
- addr_offset
* opb
] = data
[j
];
2761 buf
[j
- addr_offset
* opb
] = '.';
2763 buf
[j
- addr_offset
* opb
] = '\0';
2766 if (prefix_addresses
2768 : show_raw_insn
>= 0)
2772 /* If ! prefix_addresses and ! wide_output, we print
2773 octets_per_line octets per line. */
2775 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2776 pb
= octets_per_line
;
2778 if (inf
->bytes_per_chunk
)
2779 bpc
= inf
->bytes_per_chunk
;
2783 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2785 /* PR 21580: Check for a buffer ending early. */
2786 if (j
+ bpc
<= stop_offset
* opb
)
2790 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2792 for (k
= bpc
- 1; k
>= 0; k
--)
2793 printf ("%02x", (unsigned) data
[j
+ k
]);
2797 for (k
= 0; k
< bpc
; k
++)
2798 printf ("%02x", (unsigned) data
[j
+ k
]);
2804 for (; pb
< octets_per_line
; pb
+= bpc
)
2808 for (k
= 0; k
< bpc
; k
++)
2813 /* Separate raw data from instruction by extra space. */
2823 printf ("%s", sfile
.buffer
);
2825 if (prefix_addresses
2827 : show_raw_insn
>= 0)
2835 j
= addr_offset
* opb
+ pb
;
2837 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2838 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2842 printf ("%s:\t", buf
+ skip_addr_chars
);
2844 pb
+= octets_per_line
;
2847 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2849 /* PR 21619: Check for a buffer ending early. */
2850 if (j
+ bpc
<= stop_offset
* opb
)
2854 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2856 for (k
= bpc
- 1; k
>= 0; k
--)
2857 printf ("%02x", (unsigned) data
[j
+ k
]);
2861 for (k
= 0; k
< bpc
; k
++)
2862 printf ("%02x", (unsigned) data
[j
+ k
]);
2876 while ((*relppp
) < relppend
2877 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2879 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2890 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2893 if (q
->howto
== NULL
)
2894 printf (": *unknown*\t");
2895 else if (q
->howto
->name
)
2896 printf (": %s\t", q
->howto
->name
);
2898 printf (": %d\t", q
->howto
->type
);
2900 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2901 printf ("*unknown*");
2904 const char *sym_name
;
2906 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2907 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2908 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2913 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2914 sym_name
= bfd_section_name (sym_sec
);
2915 if (sym_name
== NULL
|| *sym_name
== '\0')
2916 sym_name
= "*unknown*";
2917 printf ("%s", sanitize_string (sym_name
));
2923 bfd_signed_vma addend
= q
->addend
;
2931 objdump_print_value (addend
, inf
, TRUE
);
2943 addr_offset
+= octets
/ opb
;
2946 free (sfile
.buffer
);
2948 free (color_buffer
);
2952 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2954 const struct elf_backend_data
* bed
;
2955 bfd_vma sign_adjust
= 0;
2956 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2957 struct objdump_disasm_info
* paux
;
2958 unsigned int opb
= pinfo
->octets_per_byte
;
2959 bfd_byte
* data
= NULL
;
2960 bfd_size_type datasize
= 0;
2961 arelent
** rel_pp
= NULL
;
2962 arelent
** rel_ppstart
= NULL
;
2963 arelent
** rel_ppend
;
2964 bfd_vma stop_offset
;
2965 asymbol
* sym
= NULL
;
2969 unsigned long addr_offset
;
2970 bfd_boolean do_print
;
2973 stop_offset_reached
,
2978 /* Sections that do not contain machine
2979 code are not normally disassembled. */
2980 if (! disassemble_all
2981 && only_list
== NULL
2982 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2983 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2986 if (! process_section_p (section
))
2989 datasize
= bfd_section_size (section
);
2993 if (start_address
== (bfd_vma
) -1
2994 || start_address
< section
->vma
)
2997 addr_offset
= start_address
- section
->vma
;
2999 if (stop_address
== (bfd_vma
) -1)
3000 stop_offset
= datasize
/ opb
;
3003 if (stop_address
< section
->vma
)
3006 stop_offset
= stop_address
- section
->vma
;
3007 if (stop_offset
> datasize
/ opb
)
3008 stop_offset
= datasize
/ opb
;
3011 if (addr_offset
>= stop_offset
)
3014 /* Decide which set of relocs to use. Load them if necessary. */
3015 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3016 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
3018 rel_pp
= paux
->dynrelbuf
;
3019 rel_count
= paux
->dynrelcount
;
3020 /* Dynamic reloc addresses are absolute, non-dynamic are section
3021 relative. REL_OFFSET specifies the reloc address corresponding
3022 to the start of this section. */
3023 rel_offset
= section
->vma
;
3031 if ((section
->flags
& SEC_RELOC
) != 0
3032 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3036 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3038 bfd_fatal (bfd_get_filename (abfd
));
3042 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3043 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3045 bfd_fatal (bfd_get_filename (abfd
));
3047 /* Sort the relocs by address. */
3048 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3052 rel_ppend
= rel_pp
+ rel_count
;
3054 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3056 non_fatal (_("Reading section %s failed because: %s"),
3057 section
->name
, bfd_errmsg (bfd_get_error ()));
3061 pinfo
->buffer
= data
;
3062 pinfo
->buffer_vma
= section
->vma
;
3063 pinfo
->buffer_length
= datasize
;
3064 pinfo
->section
= section
;
3066 /* Sort the symbols into value and section order. */
3067 compare_section
= section
;
3068 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3070 /* Skip over the relocs belonging to addresses below the
3072 while (rel_pp
< rel_ppend
3073 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3076 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3078 /* Find the nearest symbol forwards from our current position. */
3079 paux
->require_sec
= TRUE
;
3080 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3081 (struct disassemble_info
*) inf
,
3083 paux
->require_sec
= FALSE
;
3085 /* PR 9774: If the target used signed addresses then we must make
3086 sure that we sign extend the value that we calculate for 'addr'
3087 in the loop below. */
3088 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3089 && (bed
= get_elf_backend_data (abfd
)) != NULL
3090 && bed
->sign_extend_vma
)
3091 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3093 /* Disassemble a block of instructions up to the address associated with
3094 the symbol we have just found. Then print the symbol and find the
3095 next symbol on. Repeat until we have disassembled the entire section
3096 or we have reached the end of the address range we are interested in. */
3097 do_print
= paux
->symbol
== NULL
;
3098 loop_until
= stop_offset_reached
;
3100 while (addr_offset
< stop_offset
)
3104 bfd_vma nextstop_offset
;
3107 addr
= section
->vma
+ addr_offset
;
3108 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3110 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3115 (x
< sorted_symcount
3116 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3120 pinfo
->symbols
= sorted_syms
+ place
;
3121 pinfo
->num_symbols
= x
- place
;
3122 pinfo
->symtab_pos
= place
;
3126 pinfo
->symbols
= NULL
;
3127 pinfo
->num_symbols
= 0;
3128 pinfo
->symtab_pos
= -1;
3131 /* If we are only disassembling from a specific symbol,
3132 check to see if we should start or stop displaying. */
3133 if (sym
&& paux
->symbol
)
3137 /* See if we should stop printing. */
3141 if (sym
->flags
& BSF_FUNCTION
)
3145 case stop_offset_reached
:
3146 /* Handled by the while loop. */
3150 /* FIXME: There is an implicit assumption here
3151 that the name of sym is different from
3153 if (! bfd_is_local_label (abfd
, sym
))
3160 const char * name
= bfd_asymbol_name (sym
);
3161 char * alloc
= NULL
;
3163 if (do_demangle
&& name
[0] != '\0')
3165 /* Demangle the name. */
3166 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3171 /* We are not currently printing. Check to see
3172 if the current symbol matches the requested symbol. */
3173 if (streq (name
, paux
->symbol
))
3177 if (sym
->flags
& BSF_FUNCTION
)
3179 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3180 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3182 /* Sym is a function symbol with a size associated
3183 with it. Turn on automatic disassembly for the
3184 next VALUE bytes. */
3185 stop_offset
= addr_offset
3186 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3187 loop_until
= stop_offset_reached
;
3191 /* Otherwise we need to tell the loop heuristic to
3192 loop until the next function symbol is encountered. */
3193 loop_until
= function_sym
;
3198 /* Otherwise loop until the next symbol is encountered. */
3199 loop_until
= next_sym
;
3207 if (! prefix_addresses
&& do_print
)
3209 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3210 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3212 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3215 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3217 else if (sym
== NULL
)
3221 #define is_valid_next_sym(SYM) \
3222 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3223 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3224 && pinfo->symbol_is_valid (SYM, pinfo))
3226 /* Search forward for the next appropriate symbol in
3227 SECTION. Note that all the symbols are sorted
3228 together into one big array, and that some sections
3229 may have overlapping addresses. */
3230 while (place
< sorted_symcount
3231 && ! is_valid_next_sym (sorted_syms
[place
]))
3234 if (place
>= sorted_symcount
)
3237 nextsym
= sorted_syms
[place
];
3240 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3241 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3242 else if (nextsym
== NULL
)
3243 nextstop_offset
= stop_offset
;
3245 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3247 if (nextstop_offset
> stop_offset
3248 || nextstop_offset
<= addr_offset
)
3249 nextstop_offset
= stop_offset
;
3251 /* If a symbol is explicitly marked as being an object
3252 rather than a function, just dump the bytes without
3253 disassembling them. */
3256 || sym
->section
!= section
3257 || bfd_asymbol_value (sym
) > addr
3258 || ((sym
->flags
& BSF_OBJECT
) == 0
3259 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3261 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3263 || (sym
->flags
& BSF_FUNCTION
) != 0)
3270 /* Resolve symbol name. */
3271 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3273 struct disassemble_info di
;
3276 sf
.alloc
= strlen (sym
->name
) + 40;
3277 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3279 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3282 objdump_print_symname (abfd
, &di
, sym
);
3284 /* Fetch jump information. */
3285 detected_jumps
= disassemble_jumps
3286 (pinfo
, paux
->disassemble_fn
,
3287 addr_offset
, nextstop_offset
,
3288 rel_offset
, &rel_pp
, rel_ppend
);
3290 /* Free symbol name. */
3294 /* Add jumps to output. */
3295 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3296 addr_offset
, nextstop_offset
,
3297 rel_offset
, &rel_pp
, rel_ppend
);
3300 while (detected_jumps
)
3302 detected_jumps
= jump_info_free (detected_jumps
);
3306 addr_offset
= nextstop_offset
;
3312 if (rel_ppstart
!= NULL
)
3316 /* Disassemble the contents of an object file. */
3319 disassemble_data (bfd
*abfd
)
3321 struct disassemble_info disasm_info
;
3322 struct objdump_disasm_info aux
;
3326 prev_functionname
= NULL
;
3328 prev_discriminator
= 0;
3330 /* We make a copy of syms to sort. We don't want to sort syms
3331 because that will screw up the relocs. */
3332 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3333 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3334 * sizeof (asymbol
*));
3335 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3336 sorted_symcount
* sizeof (asymbol
*));
3338 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3340 for (i
= 0; i
< synthcount
; ++i
)
3342 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3346 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3348 disasm_info
.application_data
= (void *) &aux
;
3350 aux
.require_sec
= FALSE
;
3351 aux
.dynrelbuf
= NULL
;
3352 aux
.dynrelcount
= 0;
3354 aux
.symbol
= disasm_sym
;
3356 disasm_info
.print_address_func
= objdump_print_address
;
3357 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3359 if (machine
!= NULL
)
3361 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3364 fatal (_("can't use supplied machine %s"), machine
);
3366 abfd
->arch_info
= inf
;
3369 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3371 struct bfd_target
*xvec
;
3373 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3374 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3375 xvec
->byteorder
= endian
;
3379 /* Use libopcodes to locate a suitable disassembler. */
3380 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3381 bfd_big_endian (abfd
),
3382 bfd_get_mach (abfd
), abfd
);
3383 if (!aux
.disassemble_fn
)
3385 non_fatal (_("can't disassemble for architecture %s\n"),
3386 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3391 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3392 disasm_info
.arch
= bfd_get_arch (abfd
);
3393 disasm_info
.mach
= bfd_get_mach (abfd
);
3394 disasm_info
.disassembler_options
= disassembler_options
;
3395 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3396 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3397 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3398 disasm_info
.disassembler_needs_relocs
= FALSE
;
3400 if (bfd_big_endian (abfd
))
3401 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3402 else if (bfd_little_endian (abfd
))
3403 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3405 /* ??? Aborting here seems too drastic. We could default to big or little
3407 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3409 /* Allow the target to customize the info structure. */
3410 disassemble_init_for_target (& disasm_info
);
3412 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3414 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3416 if (relsize
< 0 && dump_dynamic_reloc_info
)
3417 bfd_fatal (bfd_get_filename (abfd
));
3421 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3422 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
3425 if (aux
.dynrelcount
< 0)
3426 bfd_fatal (bfd_get_filename (abfd
));
3428 /* Sort the relocs by address. */
3429 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
3433 disasm_info
.symtab
= sorted_syms
;
3434 disasm_info
.symtab_size
= sorted_symcount
;
3436 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3438 if (aux
.dynrelbuf
!= NULL
)
3439 free (aux
.dynrelbuf
);
3441 disassemble_free_target (&disasm_info
);
3445 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3446 asection
*sec
, void *file
)
3448 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3449 bfd
*abfd
= (bfd
*) file
;
3454 if (section
->start
!= NULL
)
3456 /* If it is already loaded, do nothing. */
3457 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3459 free (section
->start
);
3462 section
->filename
= bfd_get_filename (abfd
);
3463 section
->reloc_info
= NULL
;
3464 section
->num_relocs
= 0;
3465 section
->address
= bfd_section_vma (sec
);
3466 section
->user_data
= sec
;
3467 section
->size
= bfd_section_size (sec
);
3468 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3469 alloced
= amt
= section
->size
+ 1;
3470 if (alloced
!= amt
|| alloced
== 0)
3472 section
->start
= NULL
;
3473 free_debug_section (debug
);
3474 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3475 sanitize_string (section
->name
),
3476 (unsigned long long) section
->size
);
3479 section
->start
= contents
= malloc (alloced
);
3480 if (section
->start
== NULL
3481 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
3483 free_debug_section (debug
);
3484 printf (_("\nCan't get contents for section '%s'.\n"),
3485 sanitize_string (section
->name
));
3488 /* Ensure any string section has a terminating NUL. */
3489 section
->start
[section
->size
] = 0;
3491 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3492 && debug_displays
[debug
].relocate
)
3497 bfd_cache_section_contents (sec
, section
->start
);
3499 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3506 free_debug_section (debug
);
3507 printf (_("\nCan't get contents for section '%s'.\n"),
3508 sanitize_string (section
->name
));
3512 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3515 unsigned long reloc_count
;
3518 relocs
= (arelent
**) xmalloc (reloc_size
);
3520 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3521 if (reloc_count
== 0)
3525 section
->reloc_info
= relocs
;
3526 section
->num_relocs
= reloc_count
;
3535 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3540 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3543 relocs
= (arelent
**) dsec
->reloc_info
;
3545 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3546 if (rp
->address
== offset
)
3553 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3555 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3556 bfd
*abfd
= (bfd
*) file
;
3559 /* If it is already loaded, do nothing. */
3560 if (section
->start
!= NULL
)
3562 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3566 /* Locate the debug section. */
3567 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
3569 section
->name
= section
->uncompressed_name
;
3572 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
3574 section
->name
= section
->compressed_name
;
3579 return load_specific_debug_section (debug
, sec
, file
);
3583 free_debug_section (enum dwarf_section_display_enum debug
)
3585 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3587 if (section
->start
== NULL
)
3590 /* PR 17512: file: 0f67f69d. */
3591 if (section
->user_data
!= NULL
)
3593 asection
* sec
= (asection
*) section
->user_data
;
3595 /* If we are freeing contents that are also pointed to by the BFD
3596 library's section structure then make sure to update those pointers
3597 too. Otherwise, the next time we try to load data for this section
3598 we can end up using a stale pointer. */
3599 if (section
->start
== sec
->contents
)
3601 sec
->contents
= NULL
;
3602 sec
->flags
&= ~ SEC_IN_MEMORY
;
3603 sec
->compress_status
= COMPRESS_SECTION_NONE
;
3607 free ((char *) section
->start
);
3608 section
->start
= NULL
;
3609 section
->address
= 0;
3614 close_debug_file (void * file
)
3616 bfd
* abfd
= (bfd
*) file
;
3622 open_debug_file (const char * pathname
)
3626 data
= bfd_openr (pathname
, NULL
);
3630 if (! bfd_check_format (data
, bfd_object
))
3636 #if HAVE_LIBDEBUGINFOD
3637 /* Return a hex string represention of the build-id. */
3640 get_build_id (void * data
)
3643 char * build_id_str
;
3644 bfd
* abfd
= (bfd
*) data
;
3645 const struct bfd_build_id
* build_id
;
3647 build_id
= abfd
->build_id
;
3648 if (build_id
== NULL
)
3651 build_id_str
= malloc (build_id
->size
* 2 + 1);
3652 if (build_id_str
== NULL
)
3655 for (i
= 0; i
< build_id
->size
; i
++)
3656 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3657 build_id_str
[build_id
->size
* 2] = '\0';
3659 return (unsigned char *)build_id_str
;
3661 #endif /* HAVE_LIBDEBUGINFOD */
3664 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3665 void *arg ATTRIBUTE_UNUSED
)
3667 const char *name
= bfd_section_name (section
);
3671 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
3672 match
= ".debug_info";
3676 for (i
= 0; i
< max
; i
++)
3677 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3678 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
3679 && debug_displays
[i
].enabled
!= NULL
3680 && *debug_displays
[i
].enabled
)
3682 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3684 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3685 sec
->name
= sec
->uncompressed_name
;
3687 sec
->name
= sec
->compressed_name
;
3688 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3691 debug_displays
[i
].display (sec
, abfd
);
3693 if (i
!= info
&& i
!= abbrev
)
3694 free_debug_section ((enum dwarf_section_display_enum
) i
);
3700 /* Dump the dwarf debugging information. */
3703 dump_dwarf (bfd
*abfd
)
3705 /* The byte_get pointer should have been set at the start of dump_bfd(). */
3706 if (byte_get
== NULL
)
3708 warn (_("File %s does not contain any dwarf debug information\n"),
3709 bfd_get_filename (abfd
));
3713 switch (bfd_get_arch (abfd
))
3716 /* S12Z has a 24 bit address space. But the only known
3717 producer of dwarf_info encodes addresses into 32 bits. */
3722 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
3726 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
3727 bfd_get_mach (abfd
));
3729 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3732 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3733 it. Return NULL on failure. */
3736 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3737 bfd_size_type
*entsize_ptr
)
3742 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3743 if (stabsect
== NULL
)
3745 printf (_("No %s section present\n\n"),
3746 sanitize_string (sect_name
));
3750 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3752 non_fatal (_("reading %s section of %s failed: %s"),
3753 sect_name
, bfd_get_filename (abfd
),
3754 bfd_errmsg (bfd_get_error ()));
3760 *size_ptr
= bfd_section_size (stabsect
);
3762 *entsize_ptr
= stabsect
->entsize
;
3767 /* Stabs entries use a 12 byte format:
3768 4 byte string table index
3770 1 byte stab other field
3771 2 byte stab desc field
3773 FIXME: This will have to change for a 64 bit object format. */
3775 #define STRDXOFF (0)
3777 #define OTHEROFF (5)
3780 #define STABSIZE (12)
3782 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3783 using string table section STRSECT_NAME (in `strtab'). */
3786 print_section_stabs (bfd
*abfd
,
3787 const char *stabsect_name
,
3788 unsigned *string_offset_ptr
)
3791 unsigned file_string_table_offset
= 0;
3792 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3793 bfd_byte
*stabp
, *stabs_end
;
3796 stabs_end
= stabp
+ stab_size
;
3798 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3799 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3801 /* Loop through all symbols and print them.
3803 We start the index at -1 because there is a dummy symbol on
3804 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3805 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3809 unsigned char type
, other
;
3810 unsigned short desc
;
3813 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3814 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3815 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3816 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3817 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3819 printf ("\n%-6d ", i
);
3820 /* Either print the stab name, or, if unnamed, print its number
3821 again (makes consistent formatting for tools like awk). */
3822 name
= bfd_get_stab_name (type
);
3824 printf ("%-6s", sanitize_string (name
));
3825 else if (type
== N_UNDF
)
3828 printf ("%-6d", type
);
3829 printf (" %-6d %-6d ", other
, desc
);
3830 bfd_printf_vma (abfd
, value
);
3831 printf (" %-6lu", strx
);
3833 /* Symbols with type == 0 (N_UNDF) specify the length of the
3834 string table associated with this file. We use that info
3835 to know how to relocate the *next* file's string table indices. */
3838 file_string_table_offset
= next_file_string_table_offset
;
3839 next_file_string_table_offset
+= value
;
3843 bfd_size_type amt
= strx
+ file_string_table_offset
;
3845 /* Using the (possibly updated) string table offset, print the
3846 string (if any) associated with this symbol. */
3847 if (amt
< stabstr_size
)
3848 /* PR 17512: file: 079-79389-0.001:0.1.
3849 FIXME: May need to sanitize this string before displaying. */
3850 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3856 *string_offset_ptr
= next_file_string_table_offset
;
3861 const char * section_name
;
3862 const char * string_section_name
;
3863 unsigned string_offset
;
3868 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3871 stab_section_names
* sought
= (stab_section_names
*) names
;
3873 /* Check for section names for which stabsect_name is a prefix, to
3874 handle .stab.N, etc. */
3875 len
= strlen (sought
->section_name
);
3877 /* If the prefix matches, and the files section name ends with a
3878 nul or a digit, then we match. I.e., we want either an exact
3879 match or a section followed by a number. */
3880 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3881 && (section
->name
[len
] == 0
3882 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3885 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3886 &stabstr_size
, NULL
);
3890 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3892 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3898 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3900 stab_section_names s
;
3902 s
.section_name
= stabsect_name
;
3903 s
.string_section_name
= strsect_name
;
3904 s
.string_offset
= 0;
3906 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3912 /* Dump the any sections containing stabs debugging information. */
3915 dump_stabs (bfd
*abfd
)
3917 dump_stabs_section (abfd
, ".stab", ".stabstr");
3918 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3919 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3922 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3924 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3928 dump_bfd_header (bfd
*abfd
)
3932 printf (_("architecture: %s, "),
3933 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3934 bfd_get_mach (abfd
)));
3935 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3937 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3938 PF (HAS_RELOC
, "HAS_RELOC");
3939 PF (EXEC_P
, "EXEC_P");
3940 PF (HAS_LINENO
, "HAS_LINENO");
3941 PF (HAS_DEBUG
, "HAS_DEBUG");
3942 PF (HAS_SYMS
, "HAS_SYMS");
3943 PF (HAS_LOCALS
, "HAS_LOCALS");
3944 PF (DYNAMIC
, "DYNAMIC");
3945 PF (WP_TEXT
, "WP_TEXT");
3946 PF (D_PAGED
, "D_PAGED");
3947 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3948 printf (_("\nstart address 0x"));
3949 bfd_printf_vma (abfd
, abfd
->start_address
);
3954 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3955 it is passed, or a pointer to newly-allocated storage, in which case
3956 dump_ctf() will free it when it no longer needs it. */
3959 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3962 const char *blanks
= arg
;
3965 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3970 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3972 make_ctfsect (const char *name
, bfd_byte
*data
,
3977 ctfsect
.cts_name
= name
;
3978 ctfsect
.cts_entsize
= 1;
3979 ctfsect
.cts_size
= size
;
3980 ctfsect
.cts_data
= data
;
3985 /* Dump one CTF archive member. */
3988 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3990 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3991 const char *things
[] = {"Header", "Labels", "Data objects",
3992 "Function objects", "Variables", "Types", "Strings",
3997 /* Only print out the name of non-default-named archive members.
3998 The name .ctf appears everywhere, even for things that aren't
3999 really archives, so printing it out is liable to be confusing.
4001 The parent, if there is one, is the default-owned archive member:
4002 avoid importing it into itself. (This does no harm, but looks
4005 if (strcmp (name
, ".ctf") != 0)
4007 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4008 ctf_import (ctf
, parent
);
4011 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4013 ctf_dump_state_t
*s
= NULL
;
4016 printf ("\n %s:\n", *thing
);
4017 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4018 (void *) " ")) != NULL
)
4020 printf ("%s\n", item
);
4024 if (ctf_errno (ctf
))
4026 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
4027 ctf_errmsg (ctf_errno (ctf
)));
4034 /* Dump the CTF debugging information. */
4037 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4039 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
4040 bfd_byte
*ctfdata
, *parentdata
= NULL
;
4041 bfd_size_type ctfsize
, parentsize
;
4043 ctf_file_t
*parent
= NULL
;
4046 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4047 bfd_fatal (bfd_get_filename (abfd
));
4050 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
4052 bfd_fatal (bfd_get_filename (abfd
));
4054 /* Load the CTF file and dump it. */
4056 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4057 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4059 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4060 bfd_fatal (bfd_get_filename (abfd
));
4065 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
4066 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4068 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4069 bfd_fatal (bfd_get_filename (abfd
));
4072 lookparent
= parenta
;
4077 /* Assume that the applicable parent archive member is the default one.
4078 (This is what all known implementations are expected to do, if they
4079 put CTFs and their parents in archives together.) */
4080 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
4082 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
4083 bfd_fatal (bfd_get_filename (abfd
));
4086 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4088 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
4089 ctf_file_close (parent
);
4091 ctf_close (parenta
);
4098 dump_bfd_private_header (bfd
*abfd
)
4100 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4101 non_fatal (_("warning: private headers incomplete: %s"),
4102 bfd_errmsg (bfd_get_error ()));
4106 dump_target_specific (bfd
*abfd
)
4108 const struct objdump_private_desc
* const *desc
;
4109 struct objdump_private_option
*opt
;
4112 /* Find the desc. */
4113 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4114 if ((*desc
)->filter (abfd
))
4119 non_fatal (_("option -P/--private not supported by this file"));
4123 /* Clear all options. */
4124 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4125 opt
->selected
= FALSE
;
4127 /* Decode options. */
4128 b
= dump_private_options
;
4131 e
= strchr (b
, ',');
4136 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4137 if (strcmp (opt
->name
, b
) == 0)
4139 opt
->selected
= TRUE
;
4142 if (opt
->name
== NULL
)
4143 non_fatal (_("target specific dump '%s' not supported"), b
);
4154 (*desc
)->dump (abfd
);
4157 /* Display a section in hexadecimal format with associated characters.
4158 Each line prefixed by the zero padded address. */
4161 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4163 bfd_byte
*data
= NULL
;
4164 bfd_size_type datasize
;
4165 bfd_vma addr_offset
;
4166 bfd_vma start_offset
;
4167 bfd_vma stop_offset
;
4168 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4169 /* Bytes per line. */
4170 const int onaline
= 16;
4175 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4178 if (! process_section_p (section
))
4181 if ((datasize
= bfd_section_size (section
)) == 0)
4184 /* Compute the address range to display. */
4185 if (start_address
== (bfd_vma
) -1
4186 || start_address
< section
->vma
)
4189 start_offset
= start_address
- section
->vma
;
4191 if (stop_address
== (bfd_vma
) -1)
4192 stop_offset
= datasize
/ opb
;
4195 if (stop_address
< section
->vma
)
4198 stop_offset
= stop_address
- section
->vma
;
4200 if (stop_offset
> datasize
/ opb
)
4201 stop_offset
= datasize
/ opb
;
4204 if (start_offset
>= stop_offset
)
4207 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4208 if (display_file_offsets
)
4209 printf (_(" (Starting at file offset: 0x%lx)"),
4210 (unsigned long) (section
->filepos
+ start_offset
));
4213 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4215 non_fatal (_("Reading section %s failed because: %s"),
4216 section
->name
, bfd_errmsg (bfd_get_error ()));
4222 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4223 if (strlen (buf
) >= sizeof (buf
))
4227 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4229 count
= strlen (buf
) - count
;
4233 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4234 if (strlen (buf
) >= sizeof (buf
))
4238 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4240 count
= strlen (buf
) - count
;
4244 for (addr_offset
= start_offset
;
4245 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4249 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4250 count
= strlen (buf
);
4251 if ((size_t) count
>= sizeof (buf
))
4255 while (count
< width
)
4260 fputs (buf
+ count
- width
, stdout
);
4263 for (j
= addr_offset
* opb
;
4264 j
< addr_offset
* opb
+ onaline
; j
++)
4266 if (j
< stop_offset
* opb
)
4267 printf ("%02x", (unsigned) (data
[j
]));
4275 for (j
= addr_offset
* opb
;
4276 j
< addr_offset
* opb
+ onaline
; j
++)
4278 if (j
>= stop_offset
* opb
)
4281 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4288 /* Actually display the various requested regions. */
4291 dump_data (bfd
*abfd
)
4293 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4296 /* Should perhaps share code and display with nm? */
4299 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
4308 max_count
= dynsymcount
;
4309 printf ("DYNAMIC SYMBOL TABLE:\n");
4314 max_count
= symcount
;
4315 printf ("SYMBOL TABLE:\n");
4319 printf (_("no symbols\n"));
4321 for (count
= 0; count
< max_count
; count
++)
4325 if (*current
== NULL
)
4326 printf (_("no information for symbol number %ld\n"), count
);
4328 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4329 printf (_("could not determine the type of symbol number %ld\n"),
4332 else if (process_section_p ((* current
)->section
)
4333 && (dump_special_syms
4334 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4336 const char *name
= (*current
)->name
;
4338 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4342 /* If we want to demangle the name, we demangle it
4343 here, and temporarily clobber it while calling
4344 bfd_print_symbol. FIXME: This is a gross hack. */
4345 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4347 (*current
)->name
= alloc
;
4348 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4349 bfd_print_symbol_all
);
4352 (*current
)->name
= name
;
4357 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4358 bfd_print_symbol_all
);
4368 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4371 char *last_filename
, *last_functionname
;
4372 unsigned int last_line
;
4373 unsigned int last_discriminator
;
4375 /* Get column headers lined up reasonably. */
4383 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4384 width
= strlen (buf
) - 7;
4386 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4389 last_filename
= NULL
;
4390 last_functionname
= NULL
;
4392 last_discriminator
= 0;
4394 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4397 const char *filename
, *functionname
;
4398 unsigned int linenumber
;
4399 unsigned int discriminator
;
4400 const char *sym_name
;
4401 const char *section_name
;
4402 bfd_vma addend2
= 0;
4404 if (start_address
!= (bfd_vma
) -1
4405 && q
->address
< start_address
)
4407 if (stop_address
!= (bfd_vma
) -1
4408 && q
->address
> stop_address
)
4411 if (with_line_numbers
4413 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4414 &filename
, &functionname
,
4415 &linenumber
, &discriminator
))
4417 if (functionname
!= NULL
4418 && (last_functionname
== NULL
4419 || strcmp (functionname
, last_functionname
) != 0))
4421 printf ("%s():\n", sanitize_string (functionname
));
4422 if (last_functionname
!= NULL
)
4423 free (last_functionname
);
4424 last_functionname
= xstrdup (functionname
);
4428 && (linenumber
!= last_line
4429 || (filename
!= NULL
4430 && last_filename
!= NULL
4431 && filename_cmp (filename
, last_filename
) != 0)
4432 || (discriminator
!= last_discriminator
)))
4434 if (discriminator
> 0)
4435 printf ("%s:%u\n", filename
== NULL
? "???" :
4436 sanitize_string (filename
), linenumber
);
4438 printf ("%s:%u (discriminator %u)\n",
4439 filename
== NULL
? "???" : sanitize_string (filename
),
4440 linenumber
, discriminator
);
4441 last_line
= linenumber
;
4442 last_discriminator
= discriminator
;
4443 if (last_filename
!= NULL
)
4444 free (last_filename
);
4445 if (filename
== NULL
)
4446 last_filename
= NULL
;
4448 last_filename
= xstrdup (filename
);
4452 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4454 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4455 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4460 section_name
= NULL
;
4463 bfd_printf_vma (abfd
, q
->address
);
4464 if (q
->howto
== NULL
)
4465 printf (" *unknown* ");
4466 else if (q
->howto
->name
)
4468 const char *name
= q
->howto
->name
;
4470 /* R_SPARC_OLO10 relocations contain two addends.
4471 But because 'arelent' lacks enough storage to
4472 store them both, the 64-bit ELF Sparc backend
4473 records this as two relocations. One R_SPARC_LO10
4474 and one R_SPARC_13, both pointing to the same
4475 address. This is merely so that we have some
4476 place to store both addend fields.
4478 Undo this transformation, otherwise the output
4479 will be confusing. */
4480 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4481 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
4483 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4485 arelent
*q2
= *(p
+ 1);
4488 && q
->address
== q2
->address
4489 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4491 name
= "R_SPARC_OLO10";
4492 addend2
= q2
->addend
;
4496 printf (" %-16s ", name
);
4499 printf (" %-16d ", q
->howto
->type
);
4503 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4507 if (section_name
== NULL
)
4508 section_name
= "*unknown*";
4509 printf ("[%s]", sanitize_string (section_name
));
4514 bfd_signed_vma addend
= q
->addend
;
4522 bfd_printf_vma (abfd
, addend
);
4527 bfd_printf_vma (abfd
, addend2
);
4533 if (last_filename
!= NULL
)
4534 free (last_filename
);
4535 if (last_functionname
!= NULL
)
4536 free (last_functionname
);
4540 dump_relocs_in_section (bfd
*abfd
,
4542 void *dummy ATTRIBUTE_UNUSED
)
4544 arelent
**relpp
= NULL
;
4548 if ( bfd_is_abs_section (section
)
4549 || bfd_is_und_section (section
)
4550 || bfd_is_com_section (section
)
4551 || (! process_section_p (section
))
4552 || ((section
->flags
& SEC_RELOC
) == 0))
4555 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4557 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4560 printf (" (none)\n\n");
4568 relpp
= (arelent
**) xmalloc (relsize
);
4569 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4575 non_fatal (_("failed to read relocs in: %s"),
4576 sanitize_string (bfd_get_filename (abfd
)));
4577 bfd_fatal (_("error message was"));
4579 else if (relcount
== 0)
4580 printf (" (none)\n\n");
4584 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4591 dump_relocs (bfd
*abfd
)
4593 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4597 dump_dynamic_relocs (bfd
*abfd
)
4603 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4605 bfd_fatal (bfd_get_filename (abfd
));
4607 printf ("DYNAMIC RELOCATION RECORDS");
4610 printf (" (none)\n\n");
4613 relpp
= (arelent
**) xmalloc (relsize
);
4614 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4617 bfd_fatal (bfd_get_filename (abfd
));
4618 else if (relcount
== 0)
4619 printf (" (none)\n\n");
4623 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4630 /* Creates a table of paths, to search for source files. */
4633 add_include_path (const char *path
)
4637 include_path_count
++;
4638 include_paths
= (const char **)
4639 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4640 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4641 if (path
[1] == ':' && path
[2] == 0)
4642 path
= concat (path
, ".", (const char *) 0);
4644 include_paths
[include_path_count
- 1] = path
;
4648 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4652 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4654 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
4655 section
->vma
+= adjust_section_vma
;
4657 section
->lma
+= adjust_section_vma
;
4661 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
4664 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
4669 mask
= (bfd_vma
) 1 << (arch_size
- 1);
4670 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
4673 /* Dump selected contents of ABFD. */
4676 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
4678 const struct elf_backend_data
* bed
;
4680 if (bfd_big_endian (abfd
))
4681 byte_get
= byte_get_big_endian
;
4682 else if (bfd_little_endian (abfd
))
4683 byte_get
= byte_get_little_endian
;
4687 /* Load any separate debug information files.
4688 We do this now and without checking do_follow_links because separate
4689 debug info files may contain symbol tables that we will need when
4690 displaying information about the main file. Any memory allocated by
4691 load_separate_debug_files will be released when we call
4692 free_debug_memory below.
4694 The test on is_mainfile is there because the chain of separate debug
4695 info files is a global variable shared by all invocations of dump_bfd. */
4698 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
4700 /* If asked to do so, recursively dump the separate files. */
4701 if (do_follow_links
)
4705 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4706 dump_bfd (i
->handle
, FALSE
);
4710 /* Adjust user-specified start and stop limits for targets that use
4711 signed addresses. */
4712 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4713 && (bed
= get_elf_backend_data (abfd
)) != NULL
4714 && bed
->sign_extend_vma
)
4716 start_address
= sign_extend_address (abfd
, start_address
,
4718 stop_address
= sign_extend_address (abfd
, stop_address
,
4722 /* If we are adjusting section VMA's, change them all now. Changing
4723 the BFD information is a hack. However, we must do it, or
4724 bfd_find_nearest_line will not do the right thing. */
4725 if (adjust_section_vma
!= 0)
4727 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4728 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4731 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4732 printf (_("\n%s: file format %s\n"),
4733 sanitize_string (bfd_get_filename (abfd
)),
4736 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4737 if (dump_file_header
)
4738 dump_bfd_header (abfd
);
4739 if (dump_private_headers
)
4740 dump_bfd_private_header (abfd
);
4741 if (dump_private_options
!= NULL
)
4742 dump_target_specific (abfd
);
4743 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4750 || dump_dwarf_section_info
)
4752 syms
= slurp_symtab (abfd
);
4754 /* If following links, load any symbol tables from the linked files as well. */
4755 if (do_follow_links
&& is_mainfile
)
4759 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4761 asymbol
** extra_syms
;
4762 long old_symcount
= symcount
;
4764 extra_syms
= slurp_symtab (i
->handle
);
4768 if (old_symcount
== 0)
4774 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4775 memcpy (syms
+ old_symcount
,
4777 symcount
* sizeof (asymbol
*));
4781 symcount
+= old_symcount
;
4786 if (dump_section_headers
)
4787 dump_headers (abfd
);
4789 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4790 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4791 dynsyms
= slurp_dynamic_symtab (abfd
);
4795 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4796 dynsymcount
, dynsyms
, &synthsyms
);
4802 dump_symbols (abfd
, FALSE
);
4803 if (dump_dynamic_symtab
)
4804 dump_symbols (abfd
, TRUE
);
4805 if (dump_dwarf_section_info
)
4807 if (dump_ctf_section_info
)
4808 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4809 if (dump_stab_section_info
)
4811 if (dump_reloc_info
&& ! disassemble
)
4813 if (dump_dynamic_reloc_info
&& ! disassemble
)
4814 dump_dynamic_relocs (abfd
);
4815 if (dump_section_contents
)
4818 disassemble_data (abfd
);
4824 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4825 if (dhandle
!= NULL
)
4827 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4829 dump_debugging_tags
? TRUE
: FALSE
))
4831 non_fatal (_("%s: printing debugging information failed"),
4832 bfd_get_filename (abfd
));
4838 /* PR 6483: If there was no STABS debug info in the file, try
4840 else if (! dump_dwarf_section_info
)
4842 dwarf_select_sections_all ();
4870 free_debug_memory ();
4874 display_object_bfd (bfd
*abfd
)
4878 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4880 dump_bfd (abfd
, TRUE
);
4884 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4886 nonfatal (bfd_get_filename (abfd
));
4887 list_matching_formats (matching
);
4892 if (bfd_get_error () != bfd_error_file_not_recognized
)
4894 nonfatal (bfd_get_filename (abfd
));
4898 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4900 dump_bfd (abfd
, TRUE
);
4904 nonfatal (bfd_get_filename (abfd
));
4906 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4908 list_matching_formats (matching
);
4914 display_any_bfd (bfd
*file
, int level
)
4916 /* Decompress sections unless dumping the section contents. */
4917 if (!dump_section_contents
)
4918 file
->flags
|= BFD_DECOMPRESS
;
4920 /* If the file is an archive, process all of its elements. */
4921 if (bfd_check_format (file
, bfd_archive
))
4924 bfd
*last_arfile
= NULL
;
4927 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4928 else if (level
> 100)
4930 /* Prevent corrupted files from spinning us into an
4931 infinite loop. 100 is an arbitrary heuristic. */
4932 fatal (_("Archive nesting is too deep"));
4936 printf (_("In nested archive %s:\n"),
4937 sanitize_string (bfd_get_filename (file
)));
4941 bfd_set_error (bfd_error_no_error
);
4943 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4946 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4947 nonfatal (bfd_get_filename (file
));
4951 display_any_bfd (arfile
, level
+ 1);
4953 if (last_arfile
!= NULL
)
4955 bfd_close (last_arfile
);
4956 /* PR 17512: file: ac585d01. */
4957 if (arfile
== last_arfile
)
4963 last_arfile
= arfile
;
4966 if (last_arfile
!= NULL
)
4967 bfd_close (last_arfile
);
4970 display_object_bfd (file
);
4974 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4978 if (get_file_size (filename
) < 1)
4984 file
= bfd_openr (filename
, target
);
4987 nonfatal (filename
);
4991 display_any_bfd (file
, 0);
4993 /* This is an optimization to improve the speed of objdump, especially when
4994 dumping a file with lots of associated debug informatiom. Calling
4995 bfd_close on such a file can take a non-trivial amount of time as there
4996 are lots of lists to walk and buffers to free. This is only really
4997 necessary however if we are about to load another file and we need the
4998 memory back. Otherwise, if we are about to exit, then we can save (a lot
4999 of) time by only doing a quick close, and allowing the OS to reclaim the
5004 bfd_close_all_done (file
);
5008 main (int argc
, char **argv
)
5011 char *target
= default_target
;
5012 bfd_boolean seenflag
= FALSE
;
5014 #if defined (HAVE_SETLOCALE)
5015 #if defined (HAVE_LC_MESSAGES)
5016 setlocale (LC_MESSAGES
, "");
5018 setlocale (LC_CTYPE
, "");
5021 bindtextdomain (PACKAGE
, LOCALEDIR
);
5022 textdomain (PACKAGE
);
5024 program_name
= *argv
;
5025 xmalloc_set_program_name (program_name
);
5026 bfd_set_error_program_name (program_name
);
5028 START_PROGRESS (program_name
, 0);
5030 expandargv (&argc
, &argv
);
5032 if (bfd_init () != BFD_INIT_MAGIC
)
5033 fatal (_("fatal error: libbfd ABI mismatch"));
5034 set_default_bfd_target ();
5036 while ((c
= getopt_long (argc
, argv
,
5037 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
5038 long_options
, (int *) 0))
5044 break; /* We've been given a long option. */
5051 if (disassembler_options
)
5052 /* Ignore potential memory leak for now. */
5053 options
= concat (disassembler_options
, ",",
5054 optarg
, (const char *) NULL
);
5057 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5064 display_file_offsets
= TRUE
;
5067 with_line_numbers
= TRUE
;
5076 enum demangling_styles style
;
5078 style
= cplus_demangle_name_to_style (optarg
);
5079 if (style
== unknown_demangling
)
5080 fatal (_("unknown demangling style `%s'"),
5083 cplus_demangle_set_style (style
);
5086 case OPTION_RECURSE_LIMIT
:
5087 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5089 case OPTION_NO_RECURSE_LIMIT
:
5090 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5093 do_wide
= wide_output
= TRUE
;
5095 case OPTION_ADJUST_VMA
:
5096 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5098 case OPTION_START_ADDRESS
:
5099 start_address
= parse_vma (optarg
, "--start-address");
5100 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5101 fatal (_("error: the start address should be before the end address"));
5103 case OPTION_STOP_ADDRESS
:
5104 stop_address
= parse_vma (optarg
, "--stop-address");
5105 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5106 fatal (_("error: the stop address should be after the start address"));
5110 prefix_length
= strlen (prefix
);
5111 /* Remove an unnecessary trailing '/' */
5112 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5115 case OPTION_PREFIX_STRIP
:
5116 prefix_strip
= atoi (optarg
);
5117 if (prefix_strip
< 0)
5118 fatal (_("error: prefix strip must be non-negative"));
5120 case OPTION_INSN_WIDTH
:
5121 insn_width
= strtoul (optarg
, NULL
, 0);
5122 if (insn_width
<= 0)
5123 fatal (_("error: instruction width must be positive"));
5125 case OPTION_INLINES
:
5126 unwind_inlines
= TRUE
;
5128 case OPTION_VISUALIZE_JUMPS
:
5129 visualize_jumps
= TRUE
;
5130 color_output
= FALSE
;
5131 extended_color_output
= FALSE
;
5134 if (streq (optarg
, "color"))
5135 color_output
= TRUE
;
5136 else if (streq (optarg
, "extended-color"))
5138 color_output
= TRUE
;
5139 extended_color_output
= TRUE
;
5141 else if (streq (optarg
, "off"))
5142 visualize_jumps
= FALSE
;
5144 nonfatal (_("unrecognized argument to --visualize-option"));
5148 if (strcmp (optarg
, "B") == 0)
5149 endian
= BFD_ENDIAN_BIG
;
5150 else if (strcmp (optarg
, "L") == 0)
5151 endian
= BFD_ENDIAN_LITTLE
;
5154 nonfatal (_("unrecognized -E option"));
5159 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5160 endian
= BFD_ENDIAN_BIG
;
5161 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5162 endian
= BFD_ENDIAN_LITTLE
;
5165 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5172 dump_file_header
= TRUE
;
5176 formats_info
= TRUE
;
5180 add_include_path (optarg
);
5183 dump_private_headers
= TRUE
;
5187 dump_private_options
= optarg
;
5191 dump_private_headers
= TRUE
;
5193 dump_reloc_info
= TRUE
;
5194 dump_file_header
= TRUE
;
5195 dump_ar_hdrs
= TRUE
;
5196 dump_section_headers
= TRUE
;
5204 dump_dynamic_symtab
= TRUE
;
5210 disasm_sym
= optarg
;
5213 disassemble_zeroes
= TRUE
;
5217 disassemble_all
= TRUE
;
5222 with_source_code
= TRUE
;
5225 case OPTION_SOURCE_COMMENT
:
5227 with_source_code
= TRUE
;
5230 source_comment
= xstrdup (sanitize_string (optarg
));
5232 source_comment
= xstrdup ("# ");
5240 dump_debugging_tags
= 1;
5245 dump_dwarf_section_info
= TRUE
;
5248 dwarf_select_sections_by_letters (optarg
);
5250 dwarf_select_sections_all ();
5253 dump_dwarf_section_info
= TRUE
;
5256 dwarf_select_sections_by_names (optarg
);
5258 dwarf_select_sections_all ();
5260 case OPTION_DWARF_DEPTH
:
5263 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5266 case OPTION_DWARF_START
:
5269 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5270 suppress_bfd_header
= 1;
5273 case OPTION_DWARF_CHECK
:
5277 dump_ctf_section_info
= TRUE
;
5278 dump_ctf_section_name
= xstrdup (optarg
);
5281 case OPTION_CTF_PARENT
:
5282 dump_ctf_parent_name
= xstrdup (optarg
);
5285 dump_stab_section_info
= TRUE
;
5289 dump_section_contents
= TRUE
;
5293 dump_reloc_info
= TRUE
;
5297 dump_dynamic_reloc_info
= TRUE
;
5301 dump_ar_hdrs
= TRUE
;
5305 dump_section_headers
= TRUE
;
5310 show_version
= TRUE
;
5316 /* No need to set seenflag or to break - usage() does not return. */
5323 print_version ("objdump");
5329 exit_status
= display_info ();
5333 display_file ("a.out", target
, TRUE
);
5335 for (; optind
< argc
;)
5337 display_file (argv
[optind
], target
, optind
== argc
- 1);
5343 free (dump_ctf_section_name
);
5344 free (dump_ctf_parent_name
);
5345 free ((void *) source_comment
);
5347 END_PROGRESS (program_name
);