1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2023 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. */
57 #include "demanguse.h"
60 #include "sframe-api.h"
62 #include "safe-ctype.h"
64 #include "libiberty.h"
66 #include "filenames.h"
75 #ifdef HAVE_LIBDEBUGINFOD
76 #include <elfutils/debuginfod.h>
79 /* Internal headers for the ELF .stab-dump code - sorry. */
80 #define BYTES_IN_WORD 32
81 #include "aout/aout64.h"
84 static int exit_status
= 0;
86 static char *default_target
= NULL
; /* Default at runtime. */
88 /* The following variables are set based on arguments passed on the
90 static int show_version
= 0; /* Show the version number. */
91 static int dump_section_contents
; /* -s */
92 static int dump_section_headers
; /* -h */
93 static bool dump_file_header
; /* -f */
94 static int dump_symtab
; /* -t */
95 static int dump_dynamic_symtab
; /* -T */
96 static int dump_reloc_info
; /* -r */
97 static int dump_dynamic_reloc_info
; /* -R */
98 static int dump_ar_hdrs
; /* -a */
99 static int dump_private_headers
; /* -p */
100 static char *dump_private_options
; /* -P */
101 static int no_addresses
; /* --no-addresses */
102 static int prefix_addresses
; /* --prefix-addresses */
103 static int with_line_numbers
; /* -l */
104 static bool with_source_code
; /* -S */
105 static int show_raw_insn
; /* --show-raw-insn */
106 static int dump_dwarf_section_info
; /* --dwarf */
107 static int dump_stab_section_info
; /* --stabs */
108 static int dump_ctf_section_info
; /* --ctf */
109 static char *dump_ctf_section_name
;
110 static char *dump_ctf_parent_name
; /* --ctf-parent */
111 static int dump_sframe_section_info
; /* --sframe */
112 static char *dump_sframe_section_name
;
113 static int do_demangle
; /* -C, --demangle */
114 static bool disassemble
; /* -d */
115 static bool disassemble_all
; /* -D */
116 static int disassemble_zeroes
; /* --disassemble-zeroes */
117 static bool formats_info
; /* -i */
118 static int wide_output
; /* -w */
119 static int insn_width
; /* --insn-width */
120 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
121 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
122 static int dump_debugging
; /* --debugging */
123 static int dump_debugging_tags
; /* --debugging-tags */
124 static int suppress_bfd_header
;
125 static int dump_special_syms
= 0; /* --special-syms */
126 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
127 static int file_start_context
= 0; /* --file-start-context */
128 static bool display_file_offsets
; /* -F */
129 static const char *prefix
; /* --prefix */
130 static int prefix_strip
; /* --prefix-strip */
131 static size_t prefix_length
;
132 static bool unwind_inlines
; /* --inlines. */
133 static const char * disasm_sym
; /* Disassembly start symbol. */
134 static const char * source_comment
; /* --source_comment. */
135 static bool visualize_jumps
= false; /* --visualize-jumps. */
136 static bool color_output
= false; /* --visualize-jumps=color. */
137 static bool extended_color_output
= false; /* --visualize-jumps=extended-color. */
138 static int process_links
= false; /* --process-links. */
139 static int show_all_symbols
; /* --show-all-symbols. */
141 static enum color_selection
143 on_if_terminal_output
,
144 on
, /* --disassembler-color=color. */
145 off
, /* --disassembler-color=off. */
146 extended
/* --disassembler-color=extended-color. */
147 } disassembler_color
=
148 #if DEFAULT_FOR_COLORED_DISASSEMBLY
149 on_if_terminal_output
;
154 static int dump_any_debugging
;
155 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
157 /* This is reset to false each time we enter the disassembler, and set true
158 when the disassembler emits something in the dis_style_comment_start
159 style. Once this is true, all further output on that line is done in
160 the comment style. This only has an effect when disassembler coloring
162 static bool disassembler_in_comment
= false;
164 /* A structure to record the sections mentioned in -j switches. */
167 const char *name
; /* The name of the section. */
168 bool seen
; /* A flag to indicate that the section has been found in one or more input files. */
169 struct only
*next
; /* Pointer to the next structure in the list. */
171 /* Pointer to an array of 'only' structures.
172 This pointer is NULL if the -j switch has not been used. */
173 static struct only
* only_list
= NULL
;
175 /* Variables for handling include file path table. */
176 static const char **include_paths
;
177 static int include_path_count
;
179 /* Extra info to pass to the section disassembler and address printing
181 struct objdump_disasm_info
185 disassembler_ftype disassemble_fn
;
190 /* Architecture to disassemble for, or default if NULL. */
191 static char *machine
= NULL
;
193 /* Target specific options to the disassembler. */
194 static char *disassembler_options
= NULL
;
196 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
197 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
199 /* The symbol table. */
200 static asymbol
**syms
;
202 /* Number of symbols in `syms'. */
203 static long symcount
= 0;
205 /* The sorted symbol table. */
206 static asymbol
**sorted_syms
;
208 /* Number of symbols in `sorted_syms'. */
209 static long sorted_symcount
= 0;
211 /* The dynamic symbol table. */
212 static asymbol
**dynsyms
;
214 /* The synthetic symbol table. */
215 static asymbol
*synthsyms
;
216 static long synthcount
= 0;
218 /* Number of symbols in `dynsyms'. */
219 static long dynsymcount
= 0;
221 static bfd_byte
*stabs
;
222 static bfd_size_type stab_size
;
224 static bfd_byte
*strtab
;
225 static bfd_size_type stabstr_size
;
227 /* Handlers for -P/--private. */
228 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
230 OBJDUMP_PRIVATE_VECTORS
234 /* The list of detected jumps inside a function. */
235 static struct jump_info
*detected_jumps
= NULL
;
237 typedef enum unicode_display_type
245 } unicode_display_type
;
247 static unicode_display_type unicode_display
= unicode_default
;
249 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
251 usage (FILE *stream
, int status
)
253 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
254 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
255 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
256 fprintf (stream
, _("\
257 -a, --archive-headers Display archive header information\n"));
258 fprintf (stream
, _("\
259 -f, --file-headers Display the contents of the overall file header\n"));
260 fprintf (stream
, _("\
261 -p, --private-headers Display object format specific file header contents\n"));
262 fprintf (stream
, _("\
263 -P, --private=OPT,OPT... Display object format specific contents\n"));
264 fprintf (stream
, _("\
265 -h, --[section-]headers Display the contents of the section headers\n"));
266 fprintf (stream
, _("\
267 -x, --all-headers Display the contents of all headers\n"));
268 fprintf (stream
, _("\
269 -d, --disassemble Display assembler contents of executable sections\n"));
270 fprintf (stream
, _("\
271 -D, --disassemble-all Display assembler contents of all sections\n"));
272 fprintf (stream
, _("\
273 --disassemble=<sym> Display assembler contents from <sym>\n"));
274 fprintf (stream
, _("\
275 -S, --source Intermix source code with disassembly\n"));
276 fprintf (stream
, _("\
277 --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
278 fprintf (stream
, _("\
279 -s, --full-contents Display the full contents of all sections requested\n"));
280 fprintf (stream
, _("\
281 -g, --debugging Display debug information in object file\n"));
282 fprintf (stream
, _("\
283 -e, --debugging-tags Display debug information using ctags style\n"));
284 fprintf (stream
, _("\
285 -G, --stabs Display (in raw form) any STABS info in the file\n"));
286 fprintf (stream
, _("\
287 -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
288 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
289 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
290 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
292 Display the contents of DWARF debug sections\n"));
293 fprintf (stream
, _("\
294 -Wk,--dwarf=links Display the contents of sections that link to\n\
295 separate debuginfo files\n"));
296 #if DEFAULT_FOR_FOLLOW_LINKS
297 fprintf (stream
, _("\
298 -WK,--dwarf=follow-links\n\
299 Follow links to separate debug info files (default)\n"));
300 fprintf (stream
, _("\
301 -WN,--dwarf=no-follow-links\n\
302 Do not follow links to separate debug info files\n"));
304 fprintf (stream
, _("\
305 -WK,--dwarf=follow-links\n\
306 Follow links to separate debug info files\n"));
307 fprintf (stream
, _("\
308 -WN,--dwarf=no-follow-links\n\
309 Do not follow links to separate debug info files\n\
312 #if HAVE_LIBDEBUGINFOD
313 fprintf (stream
, _("\
314 -WD --dwarf=use-debuginfod\n\
315 When following links, also query debuginfod servers (default)\n"));
316 fprintf (stream
, _("\
317 -WE --dwarf=do-not-use-debuginfod\n\
318 When following links, do not query debuginfod servers\n"));
320 fprintf (stream
, _("\
321 -L, --process-links Display the contents of non-debug sections in\n\
322 separate debuginfo files. (Implies -WK)\n"));
324 fprintf (stream
, _("\
325 --ctf[=SECTION] Display CTF info from SECTION, (default `.ctf')\n"));
327 fprintf (stream
, _("\
328 --sframe[=SECTION] Display SFrame info from SECTION, (default '.sframe')\n"));
329 fprintf (stream
, _("\
330 -t, --syms Display the contents of the symbol table(s)\n"));
331 fprintf (stream
, _("\
332 -T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
333 fprintf (stream
, _("\
334 -r, --reloc Display the relocation entries in the file\n"));
335 fprintf (stream
, _("\
336 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
337 fprintf (stream
, _("\
338 @<file> Read options from <file>\n"));
339 fprintf (stream
, _("\
340 -v, --version Display this program's version number\n"));
341 fprintf (stream
, _("\
342 -i, --info List object formats and architectures supported\n"));
343 fprintf (stream
, _("\
344 -H, --help Display this information\n"));
348 const struct objdump_private_desc
* const *desc
;
350 fprintf (stream
, _("\n The following switches are optional:\n"));
351 fprintf (stream
, _("\
352 -b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
353 fprintf (stream
, _("\
354 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
355 fprintf (stream
, _("\
356 -j, --section=NAME Only display information for section NAME\n"));
357 fprintf (stream
, _("\
358 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
359 fprintf (stream
, _("\
360 -EB --endian=big Assume big endian format when disassembling\n"));
361 fprintf (stream
, _("\
362 -EL --endian=little Assume little endian format when disassembling\n"));
363 fprintf (stream
, _("\
364 --file-start-context Include context from start of file (with -S)\n"));
365 fprintf (stream
, _("\
366 -I, --include=DIR Add DIR to search list for source files\n"));
367 fprintf (stream
, _("\
368 -l, --line-numbers Include line numbers and filenames in output\n"));
369 fprintf (stream
, _("\
370 -F, --file-offsets Include file offsets when displaying information\n"));
371 fprintf (stream
, _("\
372 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n"));
373 display_demangler_styles (stream
, _("\
375 fprintf (stream
, _("\
376 --recurse-limit Enable a limit on recursion whilst demangling\n\
378 fprintf (stream
, _("\
379 --no-recurse-limit Disable a limit on recursion whilst demangling\n"));
380 fprintf (stream
, _("\
381 -w, --wide Format output for more than 80 columns\n"));
382 fprintf (stream
, _("\
383 -U[d|l|i|x|e|h] Controls the display of UTF-8 unicode characters\n\
384 --unicode=[default|locale|invalid|hex|escape|highlight]\n"));
385 fprintf (stream
, _("\
386 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
387 fprintf (stream
, _("\
388 --start-address=ADDR Only process data whose address is >= ADDR\n"));
389 fprintf (stream
, _("\
390 --stop-address=ADDR Only process data whose address is < ADDR\n"));
391 fprintf (stream
, _("\
392 --no-addresses Do not print address alongside disassembly\n"));
393 fprintf (stream
, _("\
394 --prefix-addresses Print complete address alongside disassembly\n"));
395 fprintf (stream
, _("\
396 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
397 fprintf (stream
, _("\
398 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
399 fprintf (stream
, _("\
400 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
401 fprintf (stream
, _("\
402 --show-all-symbols When disassembling, display all symbols at a given address\n"));
403 fprintf (stream
, _("\
404 --special-syms Include special symbols in symbol dumps\n"));
405 fprintf (stream
, _("\
406 --inlines Print all inlines for source line (with -l)\n"));
407 fprintf (stream
, _("\
408 --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
409 fprintf (stream
, _("\
410 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
411 fprintf (stream
, _("\
412 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
413 fprintf (stream
, _("\
414 --dwarf-start=N Display DIEs starting at offset N\n"));
415 fprintf (stream
, _("\
416 --dwarf-check Make additional dwarf consistency checks.\n"));
418 fprintf (stream
, _("\
419 --ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
421 fprintf (stream
, _("\
422 --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
423 fprintf (stream
, _("\
424 --visualize-jumps=color Use colors in the ASCII art\n"));
425 fprintf (stream
, _("\
426 --visualize-jumps=extended-color\n\
427 Use extended 8-bit color codes\n"));
428 fprintf (stream
, _("\
429 --visualize-jumps=off Disable jump visualization\n"));
430 #if DEFAULT_FOR_COLORED_DISASSEMBLY
431 fprintf (stream
, _("\
432 --disassembler-color=off Disable disassembler color output.\n"));
433 fprintf (stream
, _("\
434 --disassembler-color=terminal Enable disassembler color output if displaying on a terminal. (default)\n"));
436 fprintf (stream
, _("\
437 --disassembler-color=off Disable disassembler color output. (default)\n"));
438 fprintf (stream
, _("\
439 --disassembler-color=terminal Enable disassembler color output if displaying on a terminal.\n"));
441 fprintf (stream
, _("\
442 --disassembler-color=on Enable disassembler color output.\n"));
443 fprintf (stream
, _("\
444 --disassembler-color=extended Use 8-bit colors in disassembler output.\n\n"));
446 list_supported_targets (program_name
, stream
);
447 list_supported_architectures (program_name
, stream
);
449 disassembler_usage (stream
);
451 if (objdump_private_vectors
[0] != NULL
)
454 _("\nOptions supported for -P/--private switch:\n"));
455 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
456 (*desc
)->help (stream
);
459 if (REPORT_BUGS_TO
[0] && status
== 0)
460 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
464 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
468 OPTION_START_ADDRESS
,
478 OPTION_RECURSE_LIMIT
,
479 OPTION_NO_RECURSE_LIMIT
,
481 OPTION_SOURCE_COMMENT
,
487 OPTION_VISUALIZE_JUMPS
,
488 OPTION_DISASSEMBLER_COLOR
491 static struct option long_options
[]=
493 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
494 {"all-headers", no_argument
, NULL
, 'x'},
495 {"architecture", required_argument
, NULL
, 'm'},
496 {"archive-headers", no_argument
, NULL
, 'a'},
498 {"ctf", optional_argument
, NULL
, OPTION_CTF
},
499 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
501 {"debugging", no_argument
, NULL
, 'g'},
502 {"debugging-tags", no_argument
, NULL
, 'e'},
503 {"demangle", optional_argument
, NULL
, 'C'},
504 {"disassemble", optional_argument
, NULL
, 'd'},
505 {"disassemble-all", no_argument
, NULL
, 'D'},
506 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
507 {"disassembler-options", required_argument
, NULL
, 'M'},
508 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
509 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
510 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
511 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
512 {"dynamic-reloc", no_argument
, NULL
, 'R'},
513 {"dynamic-syms", no_argument
, NULL
, 'T'},
514 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
515 {"file-headers", no_argument
, NULL
, 'f'},
516 {"file-offsets", no_argument
, NULL
, 'F'},
517 {"file-start-context", no_argument
, &file_start_context
, 1},
518 {"full-contents", no_argument
, NULL
, 's'},
519 {"headers", no_argument
, NULL
, 'h'},
520 {"help", no_argument
, NULL
, 'H'},
521 {"include", required_argument
, NULL
, 'I'},
522 {"info", no_argument
, NULL
, 'i'},
523 {"inlines", no_argument
, 0, OPTION_INLINES
},
524 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
525 {"line-numbers", no_argument
, NULL
, 'l'},
526 {"no-addresses", no_argument
, &no_addresses
, 1},
527 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
528 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
529 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
530 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
531 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
532 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
533 {"private", required_argument
, NULL
, 'P'},
534 {"private-headers", no_argument
, NULL
, 'p'},
535 {"process-links", no_argument
, &process_links
, true},
536 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
537 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
538 {"reloc", no_argument
, NULL
, 'r'},
539 {"section", required_argument
, NULL
, 'j'},
540 {"section-headers", no_argument
, NULL
, 'h'},
541 {"sframe", optional_argument
, NULL
, OPTION_SFRAME
},
542 {"show-all-symbols", no_argument
, &show_all_symbols
, 1},
543 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
544 {"source", no_argument
, NULL
, 'S'},
545 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
546 {"special-syms", no_argument
, &dump_special_syms
, 1},
547 {"stabs", no_argument
, NULL
, 'G'},
548 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
549 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
550 {"syms", no_argument
, NULL
, 't'},
551 {"target", required_argument
, NULL
, 'b'},
552 {"unicode", required_argument
, NULL
, 'U'},
553 {"version", no_argument
, NULL
, 'V'},
554 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
555 {"wide", no_argument
, NULL
, 'w'},
556 {"disassembler-color", required_argument
, NULL
, OPTION_DISASSEMBLER_COLOR
},
557 {NULL
, no_argument
, NULL
, 0}
561 my_bfd_nonfatal (const char *msg
)
567 /* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
568 The conversion format is controlled by the unicode_display variable.
569 Returns the number of characters added to OUT.
570 Returns the number of bytes consumed from IN in CONSUMED.
571 Always consumes at least one byte and displays at least one character. */
574 display_utf8 (const unsigned char * in
, char * out
, unsigned int * consumed
)
576 char * orig_out
= out
;
577 unsigned int nchars
= 0;
580 if (unicode_display
== unicode_default
)
586 if ((in
[1] & 0xc0) != 0x80)
589 if ((in
[0] & 0x20) == 0)
595 if ((in
[2] & 0xc0) != 0x80)
598 if ((in
[0] & 0x10) == 0)
604 if ((in
[3] & 0xc0) != 0x80)
610 switch (unicode_display
)
613 /* Copy the bytes into the output buffer as is. */
614 memcpy (out
, in
, nchars
);
618 case unicode_invalid
:
620 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '<' : '{');
621 out
+= sprintf (out
, "0x");
622 for (j
= 0; j
< nchars
; j
++)
623 out
+= sprintf (out
, "%02x", in
[j
]);
624 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '>' : '}');
627 case unicode_highlight
:
629 out
+= sprintf (out
, "\x1B[31;47m"); /* Red. */
635 out
+= sprintf (out
, "\\u%02x%02x",
636 ((in
[0] & 0x1c) >> 2),
637 ((in
[0] & 0x03) << 6) | (in
[1] & 0x3f));
641 out
+= sprintf (out
, "\\u%02x%02x",
642 ((in
[0] & 0x0f) << 4) | ((in
[1] & 0x3c) >> 2),
643 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3f)));
647 out
+= sprintf (out
, "\\u%02x%02x%02x",
648 ((in
[0] & 0x07) << 6) | ((in
[1] & 0x3c) >> 2),
649 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3c) >> 2),
650 ((in
[2] & 0x03) << 6) | ((in
[3] & 0x3f)));
657 if (unicode_display
== unicode_highlight
&& isatty (1))
658 out
+= sprintf (out
, "\033[0m"); /* Default colour. */
667 return out
- orig_out
;
670 /* Not a valid UTF-8 sequence. */
676 /* Returns a version of IN with any control characters
677 replaced by escape sequences. Uses a static buffer
680 If unicode display is enabled, then also handles the
681 conversion of unicode characters. */
684 sanitize_string (const char * in
)
686 static char * buffer
= NULL
;
687 static size_t buffer_len
= 0;
688 const char * original
= in
;
695 /* See if any conversion is necessary. In the majority
696 of cases it will not be needed. */
699 unsigned char c
= *in
++;
707 if (unicode_display
!= unicode_default
&& c
>= 0xc0)
712 /* Copy the input, translating as needed. */
714 if (buffer_len
< (strlen (in
) * 9))
716 free ((void *) buffer
);
717 buffer_len
= strlen (in
) * 9;
718 buffer
= xmalloc (buffer_len
+ 1);
724 unsigned char c
= *in
++;
734 else if (unicode_display
!= unicode_default
&& c
>= 0xc0)
736 unsigned int num_consumed
;
738 out
+= display_utf8 ((const unsigned char *)(in
- 1), out
, & num_consumed
);
739 in
+= num_consumed
- 1;
751 /* Returns TRUE if the specified section should be dumped. */
754 process_section_p (asection
* section
)
758 if (only_list
== NULL
)
761 for (only
= only_list
; only
; only
= only
->next
)
762 if (strcmp (only
->name
, section
->name
) == 0)
771 /* Add an entry to the 'only' list. */
774 add_only (char * name
)
778 /* First check to make sure that we do not
779 already have an entry for this name. */
780 for (only
= only_list
; only
; only
= only
->next
)
781 if (strcmp (only
->name
, name
) == 0)
784 only
= xmalloc (sizeof * only
);
787 only
->next
= only_list
;
791 /* Release the memory used by the 'only' list.
792 PR 11225: Issue a warning message for unseen sections.
793 Only do this if none of the sections were seen. This is mainly to support
794 tools like the GAS testsuite where an object file is dumped with a list of
795 generic section names known to be present in a range of different file
799 free_only_list (void)
801 bool at_least_one_seen
= false;
805 if (only_list
== NULL
)
808 for (only
= only_list
; only
; only
= only
->next
)
811 at_least_one_seen
= true;
815 for (only
= only_list
; only
; only
= next
)
817 if (! at_least_one_seen
)
819 non_fatal (_("section '%s' mentioned in a -j option, "
820 "but not found in any input file"),
831 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
834 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
835 int longest_section_name
= *((int *) data
);
837 /* Ignore linker created section. See elfNN_ia64_object_p in
839 if (section
->flags
& SEC_LINKER_CREATED
)
842 /* PR 10413: Skip sections that we are ignoring. */
843 if (! process_section_p (section
))
846 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
847 sanitize_string (bfd_section_name (section
)),
848 (unsigned long) bfd_section_size (section
) / opb
);
849 bfd_printf_vma (abfd
, bfd_section_vma (section
));
851 bfd_printf_vma (abfd
, section
->lma
);
852 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
853 bfd_section_alignment (section
));
859 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
861 PF (SEC_HAS_CONTENTS
, "CONTENTS");
862 PF (SEC_ALLOC
, "ALLOC");
863 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
864 PF (SEC_LOAD
, "LOAD");
865 PF (SEC_RELOC
, "RELOC");
866 PF (SEC_READONLY
, "READONLY");
867 PF (SEC_CODE
, "CODE");
868 PF (SEC_DATA
, "DATA");
870 PF (SEC_DEBUGGING
, "DEBUGGING");
871 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
872 PF (SEC_EXCLUDE
, "EXCLUDE");
873 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
874 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
876 PF (SEC_TIC54X_BLOCK
, "BLOCK");
877 PF (SEC_TIC54X_CLINK
, "CLINK");
879 PF (SEC_SMALL_DATA
, "SMALL_DATA");
880 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
882 PF (SEC_COFF_SHARED
, "SHARED");
883 PF (SEC_COFF_NOREAD
, "NOREAD");
885 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
887 PF (SEC_ELF_OCTETS
, "OCTETS");
888 PF (SEC_ELF_PURECODE
, "PURECODE");
890 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
891 PF (SEC_GROUP
, "GROUP");
892 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
894 PF (SEC_MEP_VLIW
, "VLIW");
897 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
900 struct coff_comdat_info
*comdat
;
902 switch (section
->flags
& SEC_LINK_DUPLICATES
)
906 case SEC_LINK_DUPLICATES_DISCARD
:
907 ls
= "LINK_ONCE_DISCARD";
909 case SEC_LINK_DUPLICATES_ONE_ONLY
:
910 ls
= "LINK_ONCE_ONE_ONLY";
912 case SEC_LINK_DUPLICATES_SAME_SIZE
:
913 ls
= "LINK_ONCE_SAME_SIZE";
915 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
916 ls
= "LINK_ONCE_SAME_CONTENTS";
919 printf ("%s%s", comma
, ls
);
921 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
923 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
932 /* Called on each SECTION in ABFD, update the int variable pointed to by
933 DATA which contains the string length of the longest section name. */
936 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
937 asection
*section
, void *data
)
939 int *longest_so_far
= (int *) data
;
943 /* Ignore linker created section. */
944 if (section
->flags
& SEC_LINKER_CREATED
)
947 /* Skip sections that we are ignoring. */
948 if (! process_section_p (section
))
951 name
= bfd_section_name (section
);
952 len
= (int) strlen (name
);
953 if (len
> *longest_so_far
)
954 *longest_so_far
= len
;
958 dump_headers (bfd
*abfd
)
960 /* The default width of 13 is just an arbitrary choice. */
961 int max_section_name_length
= 13;
967 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
968 if (bfd_get_arch_size (abfd
) == 32)
974 printf (_("Sections:\n"));
977 bfd_map_over_sections (abfd
, find_longest_section_name
,
978 &max_section_name_length
);
980 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
981 max_section_name_length
, "Name",
982 bfd_vma_width
, "VMA",
983 bfd_vma_width
, "LMA");
986 printf (_(" Flags"));
989 bfd_map_over_sections (abfd
, dump_section_header
,
990 &max_section_name_length
);
994 slurp_symtab (bfd
*abfd
)
997 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1000 long storage
= bfd_get_symtab_upper_bound (abfd
);
1003 non_fatal (_("failed to read symbol table from: %s"),
1004 bfd_get_filename (abfd
));
1005 my_bfd_nonfatal (_("error message was"));
1011 asymbol
**sy
= (asymbol
**) xmalloc (storage
);
1012 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1015 my_bfd_nonfatal (bfd_get_filename (abfd
));
1023 /* Read in the dynamic symbols. */
1026 slurp_dynamic_symtab (bfd
*abfd
)
1029 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1032 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
1034 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
1039 my_bfd_nonfatal (bfd_get_filename (abfd
));
1045 asymbol
**sy
= (asymbol
**) xmalloc (storage
);
1046 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
1047 if (dynsymcount
< 0)
1049 my_bfd_nonfatal (bfd_get_filename (abfd
));
1057 /* Some symbol names are significant and should be kept in the
1058 table of sorted symbol names, even if they are marked as
1059 debugging/section symbols. */
1062 is_significant_symbol_name (const char * name
)
1064 return startswith (name
, ".plt") || startswith (name
, ".got");
1067 /* Filter out (in place) symbols that are useless for disassembly.
1068 COUNT is the number of elements in SYMBOLS.
1069 Return the number of useful symbols. */
1072 remove_useless_symbols (asymbol
**symbols
, long count
)
1074 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
1076 while (--count
>= 0)
1078 asymbol
*sym
= *in_ptr
++;
1080 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
1082 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
1083 && ! is_significant_symbol_name (sym
->name
))
1085 if (bfd_is_und_section (sym
->section
)
1086 || bfd_is_com_section (sym
->section
))
1091 return out_ptr
- symbols
;
1094 static const asection
*compare_section
;
1096 /* Sort symbols into value order. */
1099 compare_symbols (const void *ap
, const void *bp
)
1101 const asymbol
*a
= * (const asymbol
**) ap
;
1102 const asymbol
*b
= * (const asymbol
**) bp
;
1107 bool as
, af
, bs
, bf
;
1111 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
1113 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
1116 /* Prefer symbols from the section currently being disassembled.
1117 Don't sort symbols from other sections by section, since there
1118 isn't much reason to prefer one section over another otherwise.
1119 See sym_ok comment for why we compare by section name. */
1120 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
1121 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
1127 an
= bfd_asymbol_name (a
);
1128 bn
= bfd_asymbol_name (b
);
1132 /* The symbols gnu_compiled and gcc2_compiled convey no real
1133 information, so put them after other symbols with the same value. */
1134 af
= (strstr (an
, "gnu_compiled") != NULL
1135 || strstr (an
, "gcc2_compiled") != NULL
);
1136 bf
= (strstr (bn
, "gnu_compiled") != NULL
1137 || strstr (bn
, "gcc2_compiled") != NULL
);
1144 /* We use a heuristic for the file name, to try to sort it after
1145 more useful symbols. It may not work on non Unix systems, but it
1146 doesn't really matter; the only difference is precisely which
1147 symbol names get printed. */
1149 #define file_symbol(s, sn, snl) \
1150 (((s)->flags & BSF_FILE) != 0 \
1152 && (sn)[(snl) - 2] == '.' \
1153 && ((sn)[(snl) - 1] == 'o' \
1154 || (sn)[(snl) - 1] == 'a')))
1156 af
= file_symbol (a
, an
, anl
);
1157 bf
= file_symbol (b
, bn
, bnl
);
1164 /* Sort function and object symbols before global symbols before
1165 local symbols before section symbols before debugging symbols. */
1170 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
1172 if ((aflags
& BSF_DEBUGGING
) != 0)
1177 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
1179 if ((aflags
& BSF_SECTION_SYM
) != 0)
1184 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
1186 if ((aflags
& BSF_FUNCTION
) != 0)
1191 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
1193 if ((aflags
& BSF_OBJECT
) != 0)
1198 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
1200 if ((aflags
& BSF_LOCAL
) != 0)
1205 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
1207 if ((aflags
& BSF_GLOBAL
) != 0)
1213 /* Sort larger size ELF symbols before smaller. See PR20337. */
1215 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
1216 && bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
)
1217 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1219 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
1220 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1221 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1223 return asz
> bsz
? -1 : 1;
1225 /* Symbols that start with '.' might be section names, so sort them
1226 after symbols that don't start with '.'. */
1227 if (an
[0] == '.' && bn
[0] != '.')
1229 if (an
[0] != '.' && bn
[0] == '.')
1232 /* Finally, if we can't distinguish them in any other way, try to
1233 get consistent results by sorting the symbols by name. */
1234 return strcmp (an
, bn
);
1237 /* Sort relocs into address order. */
1240 compare_relocs (const void *ap
, const void *bp
)
1242 const arelent
*a
= * (const arelent
**) ap
;
1243 const arelent
*b
= * (const arelent
**) bp
;
1245 if (a
->address
> b
->address
)
1247 else if (a
->address
< b
->address
)
1250 /* So that associated relocations tied to the same address show up
1251 in the correct order, we don't do any further sorting. */
1260 /* Print an address (VMA) to the output stream in INFO.
1261 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1264 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1269 struct objdump_disasm_info
*aux
;
1271 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1272 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1277 for (p
= buf
; *p
== '0'; ++p
)
1282 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "%s", p
);
1285 /* Print the name of a symbol. */
1288 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1292 const char *name
, *version_string
= NULL
;
1293 bool hidden
= false;
1296 name
= bfd_asymbol_name (sym
);
1297 if (do_demangle
&& name
[0] != '\0')
1299 /* Demangle the name. */
1300 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1305 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1306 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1309 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1312 name
= sanitize_string (name
);
1316 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s", name
);
1317 if (version_string
&& *version_string
!= '\0')
1318 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
,
1319 hidden
? "@%s" : "@@%s",
1324 printf ("%s", name
);
1325 if (version_string
&& *version_string
!= '\0')
1326 printf (hidden
? "@%s" : "@@%s", version_string
);
1334 sym_ok (bool want_section
,
1335 bfd
*abfd ATTRIBUTE_UNUSED
,
1338 struct disassemble_info
*inf
)
1342 /* NB: An object file can have different sections with the same
1343 section name. Compare compare section pointers if they have
1345 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1346 && sorted_syms
[place
]->section
!= sec
)
1349 /* Note - we cannot just compare section pointers because they could
1350 be different, but the same... Ie the symbol that we are trying to
1351 find could have come from a separate debug info file. Under such
1352 circumstances the symbol will be associated with a section in the
1353 debug info file, whilst the section we want is in a normal file.
1354 So the section pointers will be different, but the section names
1355 will be the same. */
1356 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1357 bfd_section_name (sec
)) != 0)
1361 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1364 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1365 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1366 require the symbol to be in the section. Returns NULL if there is no
1367 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1368 of the symbol in sorted_syms. */
1371 find_symbol_for_address (bfd_vma vma
,
1372 struct disassemble_info
*inf
,
1375 /* @@ Would it speed things up to cache the last two symbols returned,
1376 and maybe their address ranges? For many processors, only one memory
1377 operand can be present at a time, so the 2-entry cache wouldn't be
1378 constantly churned by code doing heavy memory accesses. */
1380 /* Indices in `sorted_syms'. */
1382 long max_count
= sorted_symcount
;
1384 struct objdump_disasm_info
*aux
;
1391 if (sorted_symcount
< 1)
1394 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1397 opb
= inf
->octets_per_byte
;
1399 /* Perform a binary search looking for the closest symbol to the
1400 required value. We are searching the range (min, max_count]. */
1401 while (min
+ 1 < max_count
)
1405 thisplace
= (max_count
+ min
) / 2;
1406 sym
= sorted_syms
[thisplace
];
1408 if (bfd_asymbol_value (sym
) > vma
)
1409 max_count
= thisplace
;
1410 else if (bfd_asymbol_value (sym
) < vma
)
1419 /* The symbol we want is now in min, the low end of the range we
1420 were searching. If there are several symbols with the same
1421 value, we want the first one. */
1423 while (thisplace
> 0
1424 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1425 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1428 /* Prefer a symbol in the current section if we have multple symbols
1429 with the same value, as can occur with overlays or zero size
1432 while (min
< max_count
1433 && (bfd_asymbol_value (sorted_syms
[min
])
1434 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1436 if (sym_ok (true, abfd
, min
, sec
, inf
))
1443 return sorted_syms
[thisplace
];
1448 /* If the file is relocatable, and the symbol could be from this
1449 section, prefer a symbol from this section over symbols from
1450 others, even if the other symbol's value might be closer.
1452 Note that this may be wrong for some symbol references if the
1453 sections have overlapping memory ranges, but in that case there's
1454 no way to tell what's desired without looking at the relocation
1457 Also give the target a chance to reject symbols. */
1458 want_section
= (aux
->require_sec
1459 || ((abfd
->flags
& HAS_RELOC
) != 0
1460 && vma
>= bfd_section_vma (sec
)
1461 && vma
< (bfd_section_vma (sec
)
1462 + bfd_section_size (sec
) / opb
)));
1464 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1467 long newplace
= sorted_symcount
;
1469 for (i
= min
- 1; i
>= 0; i
--)
1471 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1473 if (newplace
== sorted_symcount
)
1476 if (bfd_asymbol_value (sorted_syms
[i
])
1477 != bfd_asymbol_value (sorted_syms
[newplace
]))
1480 /* Remember this symbol and keep searching until we reach
1481 an earlier address. */
1486 if (newplace
!= sorted_symcount
)
1487 thisplace
= newplace
;
1490 /* We didn't find a good symbol with a smaller value.
1491 Look for one with a larger value. */
1492 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1494 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1502 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1503 /* There is no suitable symbol. */
1507 /* If we have not found an exact match for the specified address
1508 and we have dynamic relocations available, then we can produce
1509 a better result by matching a relocation to the address and
1510 using the symbol associated with that relocation. */
1511 rel_count
= inf
->dynrelcount
;
1513 && sorted_syms
[thisplace
]->value
!= vma
1515 && inf
->dynrelbuf
!= NULL
1516 && inf
->dynrelbuf
[0]->address
<= vma
1517 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1518 /* If we have matched a synthetic symbol, then stick with that. */
1519 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1522 arelent
** rel_high
;
1524 rel_low
= inf
->dynrelbuf
;
1525 rel_high
= rel_low
+ rel_count
- 1;
1526 while (rel_low
<= rel_high
)
1528 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1529 arelent
* rel
= *rel_mid
;
1531 if (rel
->address
== vma
)
1533 /* Absolute relocations do not provide a more helpful
1534 symbolic address. Find a non-absolute relocation
1535 with the same address. */
1536 arelent
**rel_vma
= rel_mid
;
1538 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1542 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1546 if (rel
->sym_ptr_ptr
!= NULL
1547 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1550 * place
= thisplace
;
1551 return * rel
->sym_ptr_ptr
;
1557 if (vma
< rel
->address
)
1559 else if (vma
>= rel_mid
[1]->address
)
1560 rel_low
= rel_mid
+ 1;
1569 return sorted_syms
[thisplace
];
1572 /* Print an address and the offset to the nearest symbol. */
1575 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1576 bfd_vma vma
, struct disassemble_info
*inf
,
1581 objdump_print_value (vma
, inf
, skip_zeroes
);
1582 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, " ");
1589 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
,"<");
1590 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s",
1591 sanitize_string (bfd_section_name (sec
)));
1592 secaddr
= bfd_section_vma (sec
);
1595 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,
1597 objdump_print_value (secaddr
- vma
, inf
, true);
1599 else if (vma
> secaddr
)
1601 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1602 objdump_print_value (vma
- secaddr
, inf
, true);
1604 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1608 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, "<");
1610 objdump_print_symname (abfd
, inf
, sym
);
1612 if (bfd_asymbol_value (sym
) == vma
)
1614 /* Undefined symbols in an executables and dynamic objects do not have
1615 a value associated with them, so it does not make sense to display
1616 an offset relative to them. Normally we would not be provided with
1617 this kind of symbol, but the target backend might choose to do so,
1618 and the code in find_symbol_for_address might return an as yet
1619 unresolved symbol associated with a dynamic reloc. */
1620 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1621 && bfd_is_und_section (sym
->section
))
1623 else if (bfd_asymbol_value (sym
) > vma
)
1625 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,"-0x");
1626 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1628 else if (vma
> bfd_asymbol_value (sym
))
1630 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1631 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1634 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1637 if (display_file_offsets
)
1638 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1639 _(" (File Offset: 0x%lx)"),
1640 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1643 /* Print an address (VMA), symbolically if possible.
1644 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1647 objdump_print_addr (bfd_vma vma
,
1648 struct disassemble_info
*inf
,
1651 struct objdump_disasm_info
*aux
;
1652 asymbol
*sym
= NULL
;
1653 bool skip_find
= false;
1655 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1657 if (sorted_symcount
< 1)
1661 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "0x");
1662 objdump_print_value (vma
, inf
, skip_zeroes
);
1665 if (display_file_offsets
)
1666 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1667 _(" (File Offset: 0x%lx)"),
1668 (long int) (inf
->section
->filepos
1669 + (vma
- inf
->section
->vma
)));
1673 if (aux
->reloc
!= NULL
1674 && aux
->reloc
->sym_ptr_ptr
!= NULL
1675 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1677 sym
= * aux
->reloc
->sym_ptr_ptr
;
1679 /* Adjust the vma to the reloc. */
1680 vma
+= bfd_asymbol_value (sym
);
1682 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1687 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1689 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1693 /* Print VMA to INFO. This function is passed to the disassembler
1697 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1699 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1702 /* Determine if the given address has a symbol associated with it. */
1705 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1709 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1710 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1716 /* Hold the last function name and the last line number we displayed
1717 in a disassembly. */
1719 static char *prev_functionname
;
1720 static unsigned int prev_line
;
1721 static unsigned int prev_discriminator
;
1723 /* We keep a list of all files that we have seen when doing a
1724 disassembly with source, so that we know how much of the file to
1725 display. This can be important for inlined functions. */
1727 struct print_file_list
1729 struct print_file_list
*next
;
1730 const char *filename
;
1731 const char *modname
;
1734 const char **linemap
;
1737 unsigned max_printed
;
1741 static struct print_file_list
*print_files
;
1743 /* The number of preceding context lines to show when we start
1744 displaying a file for the first time. */
1746 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1748 #if HAVE_LIBDEBUGINFOD
1749 /* Return a hex string represention of the build-id. */
1752 get_build_id (void * data
)
1755 char * build_id_str
;
1756 bfd
* abfd
= (bfd
*) data
;
1757 const struct bfd_build_id
* build_id
;
1759 build_id
= abfd
->build_id
;
1760 if (build_id
== NULL
)
1763 build_id_str
= malloc (build_id
->size
* 2 + 1);
1764 if (build_id_str
== NULL
)
1767 for (i
= 0; i
< build_id
->size
; i
++)
1768 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
1769 build_id_str
[build_id
->size
* 2] = '\0';
1771 return (unsigned char *) build_id_str
;
1774 /* Search for a separate debug file matching ABFD's build-id. */
1777 find_separate_debug (const bfd
* abfd
)
1779 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1780 separate_info
* i
= first_separate_info
;
1782 if (build_id
== NULL
|| i
== NULL
)
1787 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1789 if (abfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1791 const unsigned char * data
= i_bfd
->build_id
->data
;
1792 size_t size
= i_bfd
->build_id
->size
;
1794 if (size
== build_id
->size
1795 && memcmp (data
, build_id
->data
, size
) == 0)
1796 return (bfd
*) i
->handle
;
1805 /* Search for a separate debug file matching ABFD's .gnu_debugaltlink
1809 find_alt_debug (const bfd
* abfd
)
1814 struct dwarf_section
* section
;
1815 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1816 separate_info
* i
= first_separate_info
;
1820 || !load_debug_section (gnu_debugaltlink
, (void *) abfd
))
1823 section
= &debug_displays
[gnu_debugaltlink
].section
;
1824 if (section
== NULL
)
1827 name
= (const char *) section
->start
;
1828 namelen
= strnlen (name
, section
->size
) + 1;
1831 if (namelen
>= section
->size
)
1834 id_len
= section
->size
- namelen
;
1838 /* Compare the .gnu_debugaltlink build-id with the build-ids of the
1839 known separate_info files. */
1842 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1844 if (i_bfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1846 const unsigned char * data
= i_bfd
->build_id
->data
;
1847 size_t size
= i_bfd
->build_id
->size
;
1850 && memcmp (section
->start
+ namelen
, data
, size
) == 0)
1851 return (bfd
*) i
->handle
;
1860 #endif /* HAVE_LIBDEBUGINFOD */
1862 /* Reads the contents of file FN into memory. Returns a pointer to the buffer.
1863 Also returns the size of the buffer in SIZE_RETURN and a filled out
1864 stat structure in FST_RETURN. Returns NULL upon failure. */
1867 slurp_file (const char * fn
,
1868 size_t * size_return
,
1869 struct stat
* fst_return
,
1870 bfd
* abfd ATTRIBUTE_UNUSED
)
1880 if (fn
== NULL
|| * fn
== 0 || size_return
== NULL
|| fst_return
== NULL
)
1883 fd
= open (fn
, O_RDONLY
| O_BINARY
);
1885 #if HAVE_LIBDEBUGINFOD
1886 if (fd
< 0 && use_debuginfod
&& fn
[0] == '/' && abfd
!= NULL
)
1888 unsigned char *build_id
= get_build_id (abfd
);
1892 debuginfod_client
*client
= debuginfod_begin ();
1896 fd
= debuginfod_find_source (client
, build_id
, 0, fn
, NULL
);
1897 debuginfod_end (client
);
1907 if (fstat (fd
, fst_return
) < 0)
1913 *size_return
= fst_return
->st_size
;
1916 ps
= getpagesize ();
1917 msize
= (*size_return
+ ps
- 1) & ~(ps
- 1);
1918 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1919 if (map
!= (char *) -1L)
1926 map
= (const char *) malloc (*size_return
);
1927 if (!map
|| (size_t) read (fd
, (char *) map
, *size_return
) != *size_return
)
1929 free ((void *) map
);
1936 #define line_map_decrease 5
1938 /* Precompute array of lines for a mapped file. */
1940 static const char **
1941 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1943 const char *p
, *lstart
, *end
;
1944 int chars_per_line
= 45; /* First iteration will use 40. */
1945 unsigned int lineno
;
1946 const char **linemap
= NULL
;
1947 unsigned long line_map_size
= 0;
1953 for (p
= map
; p
< end
; p
++)
1957 if (p
+ 1 < end
&& p
[1] == '\r')
1960 else if (*p
== '\r')
1962 if (p
+ 1 < end
&& p
[1] == '\n')
1968 /* End of line found. */
1970 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1972 unsigned long newsize
;
1974 chars_per_line
-= line_map_decrease
;
1975 if (chars_per_line
<= 1)
1977 line_map_size
= size
/ chars_per_line
+ 1;
1978 if (line_map_size
< lineno
+ 1)
1979 line_map_size
= lineno
+ 1;
1980 newsize
= line_map_size
* sizeof (char *);
1981 linemap
= (const char **) xrealloc (linemap
, newsize
);
1984 linemap
[lineno
++] = lstart
;
1992 /* Tries to open MODNAME, and if successful adds a node to print_files
1993 linked list and returns that node. Also fills in the stat structure
1994 pointed to by FST_RETURN. Returns NULL on failure. */
1996 static struct print_file_list
*
1997 try_print_file_open (const char * origname
,
1998 const char * modname
,
1999 struct stat
* fst_return
,
2002 struct print_file_list
*p
;
2004 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
2006 p
->map
= slurp_file (modname
, &p
->mapsize
, fst_return
, abfd
);
2013 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
2016 p
->filename
= origname
;
2017 p
->modname
= modname
;
2018 p
->next
= print_files
;
2024 /* If the source file, as described in the symtab, is not found
2025 try to locate it in one of the paths specified with -I
2026 If found, add location to print_files linked list. */
2028 static struct print_file_list
*
2029 update_source_path (const char *filename
, bfd
*abfd
)
2031 struct print_file_list
*p
;
2036 p
= try_print_file_open (filename
, filename
, &fst
, abfd
);
2039 if (include_path_count
== 0)
2042 /* Get the name of the file. */
2043 fname
= lbasename (filename
);
2045 /* If file exists under a new path, we need to add it to the list
2046 so that show_line knows about it. */
2047 for (i
= 0; i
< include_path_count
; i
++)
2049 char *modname
= concat (include_paths
[i
], "/", fname
,
2052 p
= try_print_file_open (filename
, modname
, &fst
, abfd
);
2062 long mtime
= bfd_get_mtime (abfd
);
2064 if (fst
.st_mtime
> mtime
)
2065 warn (_("source file %s is more recent than object file\n"),
2072 /* Print a source file line. */
2075 print_line (struct print_file_list
*p
, unsigned int linenum
)
2080 if (linenum
>= p
->maxline
)
2082 l
= p
->linemap
[linenum
];
2083 if (source_comment
!= NULL
&& strlen (l
) > 0)
2084 printf ("%s", source_comment
);
2085 len
= strcspn (l
, "\n\r");
2086 /* Test fwrite return value to quiet glibc warning. */
2087 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
2091 /* Print a range of source code lines. */
2094 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
2102 print_line (p
, start
);
2107 /* Show the line number, or the source line, in a disassembly
2111 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
2113 const char *filename
;
2114 const char *functionname
;
2115 unsigned int linenumber
;
2116 unsigned int discriminator
;
2120 if (! with_line_numbers
&& ! with_source_code
)
2123 #ifdef HAVE_LIBDEBUGINFOD
2126 const char *alt_filename
= NULL
;
2132 /* PR 29075: Check for separate debuginfo and .gnu_debugaltlink files.
2133 They need to be passed to bfd_find_nearest_line_with_alt in case they
2134 were downloaded from debuginfod. Otherwise libbfd will attempt to
2135 search for them and fail to locate them. */
2136 debug_bfd
= find_separate_debug (abfd
);
2137 if (debug_bfd
== NULL
)
2140 alt_bfd
= find_alt_debug (debug_bfd
);
2141 if (alt_bfd
!= NULL
)
2142 alt_filename
= bfd_get_filename (alt_bfd
);
2147 bfd_set_error (bfd_error_no_error
);
2148 if (! bfd_find_nearest_line_with_alt (debug_bfd
, alt_filename
,
2150 addr_offset
, &filename
,
2151 &functionname
, &linenumber
,
2154 if (bfd_get_error () == bfd_error_no_error
)
2156 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
,
2157 addr_offset
, &filename
,
2158 &functionname
, &linenumber
,
2164 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
2165 &filename
, &functionname
,
2166 &linenumber
, &discriminator
))
2170 if (filename
!= NULL
&& *filename
== '\0')
2172 if (functionname
!= NULL
&& *functionname
== '\0')
2173 functionname
= NULL
;
2176 && IS_ABSOLUTE_PATH (filename
)
2180 const char *fname
= filename
;
2182 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
2185 memcpy (path
, prefix
, prefix_length
);
2186 path_up
= path
+ prefix_length
;
2188 /* Build relocated filename, stripping off leading directories
2189 from the initial filename if requested. */
2190 if (prefix_strip
> 0)
2195 /* Skip selected directory levels. */
2196 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
2197 if (IS_DIR_SEPARATOR (*s
))
2204 /* Update complete filename. */
2205 strcpy (path_up
, fname
);
2213 if (with_line_numbers
)
2215 if (functionname
!= NULL
2216 && (prev_functionname
== NULL
2217 || strcmp (functionname
, prev_functionname
) != 0))
2219 char *demangle_alloc
= NULL
;
2220 if (do_demangle
&& functionname
[0] != '\0')
2222 /* Demangle the name. */
2223 demangle_alloc
= bfd_demangle (abfd
, functionname
,
2227 /* Demangling adds trailing parens, so don't print those. */
2228 if (demangle_alloc
!= NULL
)
2229 printf ("%s:\n", sanitize_string (demangle_alloc
));
2231 printf ("%s():\n", sanitize_string (functionname
));
2234 free (demangle_alloc
);
2237 && (linenumber
!= prev_line
2238 || discriminator
!= prev_discriminator
))
2240 if (discriminator
> 0)
2241 printf ("%s:%u (discriminator %u)\n",
2242 filename
== NULL
? "???" : sanitize_string (filename
),
2243 linenumber
, discriminator
);
2245 printf ("%s:%u\n", filename
== NULL
2246 ? "???" : sanitize_string (filename
),
2251 const char *filename2
;
2252 const char *functionname2
;
2255 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2258 printf ("inlined by %s:%u",
2259 sanitize_string (filename2
), line2
);
2260 printf (" (%s)\n", sanitize_string (functionname2
));
2265 if (with_source_code
2269 struct print_file_list
**pp
, *p
;
2272 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2273 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2280 filename
= xstrdup (filename
);
2281 p
= update_source_path (filename
, abfd
);
2284 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2286 if (file_start_context
&& p
->first
)
2290 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2291 if (l
>= linenumber
)
2293 if (p
->max_printed
>= l
)
2295 if (p
->max_printed
< linenumber
)
2296 l
= p
->max_printed
+ 1;
2301 dump_lines (p
, l
, linenumber
);
2302 if (p
->max_printed
< linenumber
)
2303 p
->max_printed
= linenumber
;
2304 p
->last_line
= linenumber
;
2309 if (functionname
!= NULL
2310 && (prev_functionname
== NULL
2311 || strcmp (functionname
, prev_functionname
) != 0))
2313 if (prev_functionname
!= NULL
)
2314 free (prev_functionname
);
2315 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2316 strcpy (prev_functionname
, functionname
);
2319 if (linenumber
> 0 && linenumber
!= prev_line
)
2320 prev_line
= linenumber
;
2322 if (discriminator
!= prev_discriminator
)
2323 prev_discriminator
= discriminator
;
2329 /* Pseudo FILE object for strings. */
2337 /* sprintf to a "stream". */
2339 static int ATTRIBUTE_PRINTF_2
2340 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2347 size_t space
= f
->alloc
- f
->pos
;
2349 va_start (args
, format
);
2350 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2356 f
->alloc
= (f
->alloc
+ n
) * 2;
2357 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2364 /* Return an integer greater than, or equal to zero, representing the color
2365 for STYLE, or -1 if no color should be used. */
2368 objdump_color_for_disassembler_style (enum disassembler_style style
)
2372 if (style
== dis_style_comment_start
)
2373 disassembler_in_comment
= true;
2375 if (disassembler_color
== on
)
2377 if (disassembler_in_comment
)
2382 case dis_style_symbol
:
2385 case dis_style_assembler_directive
:
2386 case dis_style_sub_mnemonic
:
2387 case dis_style_mnemonic
:
2390 case dis_style_register
:
2393 case dis_style_address
:
2394 case dis_style_address_offset
:
2395 case dis_style_immediate
:
2399 case dis_style_text
:
2404 else if (disassembler_color
== extended
)
2406 if (disassembler_in_comment
)
2411 case dis_style_symbol
:
2414 case dis_style_assembler_directive
:
2415 case dis_style_sub_mnemonic
:
2416 case dis_style_mnemonic
:
2419 case dis_style_register
:
2422 case dis_style_address
:
2423 case dis_style_address_offset
:
2424 case dis_style_immediate
:
2428 case dis_style_text
:
2433 else if (disassembler_color
!= off
)
2434 bfd_fatal (_("disassembly color not correctly selected"));
2439 /* Like objdump_sprintf, but add in escape sequences to highlight the
2440 content according to STYLE. */
2442 static int ATTRIBUTE_PRINTF_3
2443 objdump_styled_sprintf (SFILE
*f
, enum disassembler_style style
,
2444 const char *format
, ...)
2448 int color
= objdump_color_for_disassembler_style (style
);
2454 size_t space
= f
->alloc
- f
->pos
;
2456 if (disassembler_color
== on
)
2457 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[%dm", color
);
2459 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[38;5;%dm", color
);
2463 f
->alloc
= (f
->alloc
+ n
) * 2;
2464 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2471 size_t space
= f
->alloc
- f
->pos
;
2473 va_start (args
, format
);
2474 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2480 f
->alloc
= (f
->alloc
+ n
) * 2;
2481 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2489 size_t space
= f
->alloc
- f
->pos
;
2491 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[0m");
2496 f
->alloc
= (f
->alloc
+ n
) * 2;
2497 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2505 /* We discard the styling information here. This function is only used
2506 when objdump is printing auxiliary information, the symbol headers, and
2507 disassembly address, or the bytes of the disassembled instruction. We
2508 don't (currently) apply styling to any of this stuff, so, for now, just
2509 print the content with no additional style added. */
2511 static int ATTRIBUTE_PRINTF_3
2512 fprintf_styled (FILE *f
, enum disassembler_style style ATTRIBUTE_UNUSED
,
2513 const char *fmt
, ...)
2519 res
= vfprintf (f
, fmt
, ap
);
2525 /* Code for generating (colored) diagrams of control flow start and end
2528 /* Structure used to store the properties of a jump. */
2532 /* The next jump, or NULL if this is the last object. */
2533 struct jump_info
*next
;
2534 /* The previous jump, or NULL if this is the first object. */
2535 struct jump_info
*prev
;
2536 /* The start addresses of the jump. */
2539 /* The list of start addresses. */
2541 /* The number of elements. */
2543 /* The maximum number of elements that fit into the array. */
2546 /* The end address of the jump. */
2548 /* The drawing level of the jump. */
2552 /* Construct a jump object for a jump from start
2553 to end with the corresponding level. */
2555 static struct jump_info
*
2556 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2558 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2560 result
->next
= NULL
;
2561 result
->prev
= NULL
;
2562 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2563 result
->start
.addresses
[0] = start
;
2564 result
->start
.count
= 1;
2565 result
->start
.max_count
= 2;
2567 result
->level
= level
;
2572 /* Free a jump object and return the next object
2573 or NULL if this was the last one. */
2575 static struct jump_info
*
2576 jump_info_free (struct jump_info
*ji
)
2578 struct jump_info
*result
= NULL
;
2583 if (ji
->start
.addresses
)
2584 free (ji
->start
.addresses
);
2591 /* Get the smallest value of all start and end addresses. */
2594 jump_info_min_address (const struct jump_info
*ji
)
2596 bfd_vma min_address
= ji
->end
;
2599 for (i
= ji
->start
.count
; i
-- > 0;)
2600 if (ji
->start
.addresses
[i
] < min_address
)
2601 min_address
= ji
->start
.addresses
[i
];
2605 /* Get the largest value of all start and end addresses. */
2608 jump_info_max_address (const struct jump_info
*ji
)
2610 bfd_vma max_address
= ji
->end
;
2613 for (i
= ji
->start
.count
; i
-- > 0;)
2614 if (ji
->start
.addresses
[i
] > max_address
)
2615 max_address
= ji
->start
.addresses
[i
];
2619 /* Get the target address of a jump. */
2622 jump_info_end_address (const struct jump_info
*ji
)
2627 /* Test if an address is one of the start addresses of a jump. */
2630 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2632 bool result
= false;
2635 for (i
= ji
->start
.count
; i
-- > 0;)
2636 if (address
== ji
->start
.addresses
[i
])
2645 /* Test if an address is the target address of a jump. */
2648 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2650 return (address
== ji
->end
);
2653 /* Get the difference between the smallest and largest address of a jump. */
2656 jump_info_size (const struct jump_info
*ji
)
2658 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2661 /* Unlink a jump object from a list. */
2664 jump_info_unlink (struct jump_info
*node
,
2665 struct jump_info
**base
)
2668 node
->next
->prev
= node
->prev
;
2670 node
->prev
->next
= node
->next
;
2677 /* Insert unlinked jump info node into a list. */
2680 jump_info_insert (struct jump_info
*node
,
2681 struct jump_info
*target
,
2682 struct jump_info
**base
)
2684 node
->next
= target
;
2685 node
->prev
= target
->prev
;
2686 target
->prev
= node
;
2688 node
->prev
->next
= node
;
2693 /* Add unlinked node to the front of a list. */
2696 jump_info_add_front (struct jump_info
*node
,
2697 struct jump_info
**base
)
2701 node
->next
->prev
= node
;
2706 /* Move linked node to target position. */
2709 jump_info_move_linked (struct jump_info
*node
,
2710 struct jump_info
*target
,
2711 struct jump_info
**base
)
2714 jump_info_unlink (node
, base
);
2715 /* Insert node at target position. */
2716 jump_info_insert (node
, target
, base
);
2719 /* Test if two jumps intersect. */
2722 jump_info_intersect (const struct jump_info
*a
,
2723 const struct jump_info
*b
)
2725 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2726 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2729 /* Merge two compatible jump info objects. */
2732 jump_info_merge (struct jump_info
**base
)
2734 struct jump_info
*a
;
2736 for (a
= *base
; a
; a
= a
->next
)
2738 struct jump_info
*b
;
2740 for (b
= a
->next
; b
; b
= b
->next
)
2742 /* Merge both jumps into one. */
2743 if (a
->end
== b
->end
)
2745 /* Reallocate addresses. */
2746 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2749 if (needed_size
> a
->start
.max_count
)
2751 a
->start
.max_count
+= b
->start
.max_count
;
2752 a
->start
.addresses
=
2753 xrealloc (a
->start
.addresses
,
2754 a
->start
.max_count
* sizeof (bfd_vma
*));
2757 /* Append start addresses. */
2758 for (i
= 0; i
< b
->start
.count
; ++i
)
2759 a
->start
.addresses
[a
->start
.count
++] =
2760 b
->start
.addresses
[i
];
2762 /* Remove and delete jump. */
2763 struct jump_info
*tmp
= b
->prev
;
2764 jump_info_unlink (b
, base
);
2772 /* Sort jumps by their size and starting point using a stable
2773 minsort. This could be improved if sorting performance is
2774 an issue, for example by using mergesort. */
2777 jump_info_sort (struct jump_info
**base
)
2779 struct jump_info
*current_element
= *base
;
2781 while (current_element
)
2783 struct jump_info
*best_match
= current_element
;
2784 struct jump_info
*runner
= current_element
->next
;
2785 bfd_vma best_size
= jump_info_size (best_match
);
2789 bfd_vma runner_size
= jump_info_size (runner
);
2791 if ((runner_size
< best_size
)
2792 || ((runner_size
== best_size
)
2793 && (jump_info_min_address (runner
)
2794 < jump_info_min_address (best_match
))))
2796 best_match
= runner
;
2797 best_size
= runner_size
;
2800 runner
= runner
->next
;
2803 if (best_match
== current_element
)
2804 current_element
= current_element
->next
;
2806 jump_info_move_linked (best_match
, current_element
, base
);
2810 /* Visualize all jumps at a given address. */
2813 jump_info_visualize_address (bfd_vma address
,
2816 uint8_t *color_buffer
)
2818 struct jump_info
*ji
= detected_jumps
;
2819 size_t len
= (max_level
+ 1) * 3;
2821 /* Clear line buffer. */
2822 memset (line_buffer
, ' ', len
);
2823 memset (color_buffer
, 0, len
);
2825 /* Iterate over jumps and add their ASCII art. */
2828 /* Discard jumps that are never needed again. */
2829 if (jump_info_max_address (ji
) < address
)
2831 struct jump_info
*tmp
= ji
;
2834 jump_info_unlink (tmp
, &detected_jumps
);
2835 jump_info_free (tmp
);
2839 /* This jump intersects with the current address. */
2840 if (jump_info_min_address (ji
) <= address
)
2842 /* Hash target address to get an even
2843 distribution between all values. */
2844 bfd_vma hash_address
= jump_info_end_address (ji
);
2845 uint8_t color
= iterative_hash_object (hash_address
, 0);
2846 /* Fetch line offset. */
2847 int offset
= (max_level
- ji
->level
) * 3;
2849 /* Draw start line. */
2850 if (jump_info_is_start_address (ji
, address
))
2852 size_t i
= offset
+ 1;
2854 for (; i
< len
- 1; ++i
)
2855 if (line_buffer
[i
] == ' ')
2857 line_buffer
[i
] = '-';
2858 color_buffer
[i
] = color
;
2861 if (line_buffer
[i
] == ' ')
2863 line_buffer
[i
] = '-';
2864 color_buffer
[i
] = color
;
2866 else if (line_buffer
[i
] == '>')
2868 line_buffer
[i
] = 'X';
2869 color_buffer
[i
] = color
;
2872 if (line_buffer
[offset
] == ' ')
2874 if (address
<= ji
->end
)
2875 line_buffer
[offset
] =
2876 (jump_info_min_address (ji
) == address
) ? '/': '+';
2878 line_buffer
[offset
] =
2879 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2880 color_buffer
[offset
] = color
;
2883 /* Draw jump target. */
2884 else if (jump_info_is_end_address (ji
, address
))
2886 size_t i
= offset
+ 1;
2888 for (; i
< len
- 1; ++i
)
2889 if (line_buffer
[i
] == ' ')
2891 line_buffer
[i
] = '-';
2892 color_buffer
[i
] = color
;
2895 if (line_buffer
[i
] == ' ')
2897 line_buffer
[i
] = '>';
2898 color_buffer
[i
] = color
;
2900 else if (line_buffer
[i
] == '-')
2902 line_buffer
[i
] = 'X';
2903 color_buffer
[i
] = color
;
2906 if (line_buffer
[offset
] == ' ')
2908 if (jump_info_min_address (ji
) < address
)
2909 line_buffer
[offset
] =
2910 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2912 line_buffer
[offset
] = '/';
2913 color_buffer
[offset
] = color
;
2916 /* Draw intermediate line segment. */
2917 else if (line_buffer
[offset
] == ' ')
2919 line_buffer
[offset
] = '|';
2920 color_buffer
[offset
] = color
;
2928 /* Clone of disassemble_bytes to detect jumps inside a function. */
2929 /* FIXME: is this correct? Can we strip it down even further? */
2931 static struct jump_info
*
2932 disassemble_jumps (struct disassemble_info
* inf
,
2933 disassembler_ftype disassemble_fn
,
2934 bfd_vma start_offset
,
2935 bfd_vma stop_offset
,
2938 arelent
** relppend
)
2940 struct objdump_disasm_info
*aux
;
2941 struct jump_info
*jumps
= NULL
;
2943 bfd_vma addr_offset
;
2944 unsigned int opb
= inf
->octets_per_byte
;
2948 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2949 section
= inf
->section
;
2952 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2955 inf
->insn_info_valid
= 0;
2956 disassemble_set_printf (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
2957 (fprintf_styled_ftype
) objdump_styled_sprintf
);
2959 addr_offset
= start_offset
;
2960 while (addr_offset
< stop_offset
)
2962 int previous_octets
;
2964 /* Remember the length of the previous instruction. */
2965 previous_octets
= octets
;
2969 inf
->bytes_per_line
= 0;
2970 inf
->bytes_per_chunk
= 0;
2971 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2972 | (wide_output
? WIDE_OUTPUT
: 0));
2974 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2976 if (inf
->disassembler_needs_relocs
2977 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2978 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2979 && *relppp
< relppend
)
2981 bfd_signed_vma distance_to_rel
;
2983 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2985 /* Check to see if the current reloc is associated with
2986 the instruction that we are about to disassemble. */
2987 if (distance_to_rel
== 0
2988 /* FIXME: This is wrong. We are trying to catch
2989 relocs that are addressed part way through the
2990 current instruction, as might happen with a packed
2991 VLIW instruction. Unfortunately we do not know the
2992 length of the current instruction since we have not
2993 disassembled it yet. Instead we take a guess based
2994 upon the length of the previous instruction. The
2995 proper solution is to have a new target-specific
2996 disassembler function which just returns the length
2997 of an instruction at a given address without trying
2998 to display its disassembly. */
2999 || (distance_to_rel
> 0
3000 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
3002 inf
->flags
|= INSN_HAS_RELOC
;
3006 if (! disassemble_all
3007 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3008 == (SEC_CODE
| SEC_HAS_CONTENTS
))
3009 /* Set a stop_vma so that the disassembler will not read
3010 beyond the next symbol. We assume that symbols appear on
3011 the boundaries between instructions. We only do this when
3012 disassembling code of course, and when -D is in effect. */
3013 inf
->stop_vma
= section
->vma
+ stop_offset
;
3015 inf
->stop_offset
= stop_offset
;
3017 /* Extract jump information. */
3018 inf
->insn_info_valid
= 0;
3019 disassembler_in_comment
= false;
3020 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3021 /* Test if a jump was detected. */
3022 if (inf
->insn_info_valid
3023 && ((inf
->insn_type
== dis_branch
)
3024 || (inf
->insn_type
== dis_condbranch
)
3025 || (inf
->insn_type
== dis_jsr
)
3026 || (inf
->insn_type
== dis_condjsr
))
3027 && (inf
->target
>= section
->vma
+ start_offset
)
3028 && (inf
->target
< section
->vma
+ stop_offset
))
3030 struct jump_info
*ji
=
3031 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
3032 jump_info_add_front (ji
, &jumps
);
3037 addr_offset
+= octets
/ opb
;
3040 disassemble_set_printf (inf
, (void *) stdout
, (fprintf_ftype
) fprintf
,
3041 (fprintf_styled_ftype
) fprintf_styled
);
3042 free (sfile
.buffer
);
3045 jump_info_merge (&jumps
);
3046 /* Process jumps. */
3047 jump_info_sort (&jumps
);
3049 /* Group jumps by level. */
3050 struct jump_info
*last_jump
= jumps
;
3055 /* The last jump is part of the next group. */
3056 struct jump_info
*base
= last_jump
;
3057 /* Increment level. */
3058 base
->level
= ++max_level
;
3060 /* Find jumps that can be combined on the same
3061 level, with the largest jumps tested first.
3062 This has the advantage that large jumps are on
3063 lower levels and do not intersect with small
3064 jumps that get grouped on higher levels. */
3065 struct jump_info
*exchange_item
= last_jump
->next
;
3066 struct jump_info
*it
= exchange_item
;
3068 for (; it
; it
= it
->next
)
3070 /* Test if the jump intersects with any
3071 jump from current group. */
3073 struct jump_info
*it_collision
;
3075 for (it_collision
= base
;
3076 it_collision
!= exchange_item
;
3077 it_collision
= it_collision
->next
)
3079 /* This jump intersects so we leave it out. */
3080 if (jump_info_intersect (it_collision
, it
))
3087 /* Add jump to group. */
3090 /* Move current element to the front. */
3091 if (it
!= exchange_item
)
3093 struct jump_info
*save
= it
->prev
;
3094 jump_info_move_linked (it
, exchange_item
, &jumps
);
3100 last_jump
= exchange_item
;
3101 exchange_item
= exchange_item
->next
;
3103 last_jump
->level
= max_level
;
3107 /* Move to next group. */
3108 last_jump
= exchange_item
;
3114 /* The number of zeroes we want to see before we start skipping them.
3115 The number is arbitrarily chosen. */
3117 #define DEFAULT_SKIP_ZEROES 8
3119 /* The number of zeroes to skip at the end of a section. If the
3120 number of zeroes at the end is between SKIP_ZEROES_AT_END and
3121 SKIP_ZEROES, they will be disassembled. If there are fewer than
3122 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
3123 attempt to avoid disassembling zeroes inserted by section
3126 #define DEFAULT_SKIP_ZEROES_AT_END 3
3129 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
3134 /* Like null_print, but takes the extra STYLE argument. As this is not
3135 going to print anything, the extra argument is just ignored. */
3138 null_styled_print (const void * stream ATTRIBUTE_UNUSED
,
3139 enum disassembler_style style ATTRIBUTE_UNUSED
,
3140 const char * format ATTRIBUTE_UNUSED
, ...)
3145 /* Print out jump visualization. */
3148 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
3149 uint8_t *color_buffer
)
3154 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
3156 size_t line_buffer_size
= strlen (line_buffer
);
3157 char last_color
= 0;
3160 for (i
= 0; i
<= line_buffer_size
; ++i
)
3164 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
3166 if (color
!= last_color
)
3169 if (extended_color_output
)
3170 /* Use extended 8bit color, but
3171 do not choose dark colors. */
3172 printf ("\033[38;5;%dm", 124 + (color
% 108));
3174 /* Use simple terminal colors. */
3175 printf ("\033[%dm", 31 + (color
% 7));
3182 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
3186 /* Disassemble some data in memory between given values. */
3189 disassemble_bytes (struct disassemble_info
*inf
,
3190 disassembler_ftype disassemble_fn
,
3193 bfd_vma start_offset
,
3194 bfd_vma stop_offset
,
3199 struct objdump_disasm_info
*aux
;
3201 unsigned int octets_per_line
;
3202 unsigned int skip_addr_chars
;
3203 bfd_vma addr_offset
;
3204 unsigned int opb
= inf
->octets_per_byte
;
3205 unsigned int skip_zeroes
= inf
->skip_zeroes
;
3206 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
3210 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
3211 section
= inf
->section
;
3214 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
3218 octets_per_line
= insn_width
;
3220 octets_per_line
= 4;
3222 octets_per_line
= 16;
3224 /* Figure out how many characters to skip at the start of an
3225 address, to make the disassembly look nicer. We discard leading
3226 zeroes in chunks of 4, ensuring that there is always a leading
3228 skip_addr_chars
= 0;
3229 if (!no_addresses
&& !prefix_addresses
)
3233 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
3235 while (buf
[skip_addr_chars
] == '0')
3238 /* Don't discard zeros on overflow. */
3239 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
3240 skip_addr_chars
= 0;
3242 if (skip_addr_chars
!= 0)
3243 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
3246 inf
->insn_info_valid
= 0;
3248 /* Determine maximum level. */
3249 uint8_t *color_buffer
= NULL
;
3250 char *line_buffer
= NULL
;
3253 /* Some jumps were detected. */
3256 struct jump_info
*ji
;
3258 /* Find maximum jump level. */
3259 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
3261 if (ji
->level
> max_level
)
3262 max_level
= ji
->level
;
3265 /* Allocate buffers. */
3266 size_t len
= (max_level
+ 1) * 3 + 1;
3267 line_buffer
= xmalloc (len
);
3268 line_buffer
[len
- 1] = 0;
3269 color_buffer
= xmalloc (len
);
3270 color_buffer
[len
- 1] = 0;
3273 addr_offset
= start_offset
;
3274 while (addr_offset
< stop_offset
)
3276 bool need_nl
= false;
3280 /* Make sure we don't use relocs from previous instructions. */
3283 /* If we see more than SKIP_ZEROES octets of zeroes, we just
3285 if (! disassemble_zeroes
)
3286 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
3287 if (data
[addr_offset
* opb
+ octets
] != 0)
3289 if (! disassemble_zeroes
3290 && (inf
->insn_info_valid
== 0
3291 || inf
->branch_delay_insns
== 0)
3292 && (octets
>= skip_zeroes
3293 || (addr_offset
* opb
+ octets
== stop_offset
* opb
3294 && octets
< skip_zeroes_at_end
)))
3296 /* If there are more nonzero octets to follow, we only skip
3297 zeroes in multiples of 4, to try to avoid running over
3298 the start of an instruction which happens to start with
3300 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
3303 /* If we are going to display more data, and we are displaying
3304 file offsets, then tell the user how many zeroes we skip
3305 and the file offset from where we resume dumping. */
3306 if (display_file_offsets
3307 && addr_offset
+ octets
/ opb
< stop_offset
)
3308 printf (_("\t... (skipping %lu zeroes, "
3309 "resuming at file offset: 0x%lx)\n"),
3310 (unsigned long) (octets
/ opb
),
3311 (unsigned long) (section
->filepos
3312 + addr_offset
+ octets
/ opb
));
3319 unsigned int bpc
= 0;
3320 unsigned int pb
= 0;
3322 if (with_line_numbers
|| with_source_code
)
3323 show_line (aux
->abfd
, section
, addr_offset
);
3327 else if (!prefix_addresses
)
3331 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
3332 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3336 printf ("%s:\t", buf
+ skip_addr_chars
);
3340 aux
->require_sec
= true;
3341 objdump_print_address (section
->vma
+ addr_offset
, inf
);
3342 aux
->require_sec
= false;
3346 print_jump_visualisation (section
->vma
+ addr_offset
,
3347 max_level
, line_buffer
,
3355 disassemble_set_printf
3356 (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
3357 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3358 inf
->bytes_per_line
= 0;
3359 inf
->bytes_per_chunk
= 0;
3360 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
3361 | (wide_output
? WIDE_OUTPUT
: 0));
3363 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
3365 if (inf
->disassembler_needs_relocs
3366 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
3367 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
3368 && *relppp
< relppend
)
3370 bfd_signed_vma distance_to_rel
;
3371 int max_reloc_offset
3372 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
3374 distance_to_rel
= ((**relppp
)->address
- rel_offset
3378 if (distance_to_rel
> 0
3379 && (max_reloc_offset
< 0
3380 || distance_to_rel
<= max_reloc_offset
))
3382 /* This reloc *might* apply to the current insn,
3383 starting somewhere inside it. Discover the length
3384 of the current insn so that the check below will
3387 insn_size
= insn_width
;
3390 /* We find the length by calling the dissassembler
3391 function with a dummy print handler. This should
3392 work unless the disassembler is not expecting to
3393 be called multiple times for the same address.
3395 This does mean disassembling the instruction
3396 twice, but we only do this when there is a high
3397 probability that there is a reloc that will
3398 affect the instruction. */
3399 disassemble_set_printf
3400 (inf
, inf
->stream
, (fprintf_ftype
) null_print
,
3401 (fprintf_styled_ftype
) null_styled_print
);
3402 insn_size
= disassemble_fn (section
->vma
3403 + addr_offset
, inf
);
3404 disassemble_set_printf
3406 (fprintf_ftype
) objdump_sprintf
,
3407 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3411 /* Check to see if the current reloc is associated with
3412 the instruction that we are about to disassemble. */
3413 if (distance_to_rel
== 0
3414 || (distance_to_rel
> 0
3415 && distance_to_rel
< insn_size
/ (int) opb
))
3417 inf
->flags
|= INSN_HAS_RELOC
;
3418 aux
->reloc
= **relppp
;
3422 if (! disassemble_all
3423 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3424 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3425 /* Set a stop_vma so that the disassembler will not read
3426 beyond the next symbol. We assume that symbols appear on
3427 the boundaries between instructions. We only do this when
3428 disassembling code of course, and when -D is in effect. */
3429 inf
->stop_vma
= section
->vma
+ stop_offset
;
3431 inf
->stop_offset
= stop_offset
;
3432 disassembler_in_comment
= false;
3433 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3437 disassemble_set_printf (inf
, stdout
, (fprintf_ftype
) fprintf
,
3438 (fprintf_styled_ftype
) fprintf_styled
);
3439 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3440 octets_per_line
= inf
->bytes_per_line
;
3441 if (insn_size
< (int) opb
)
3444 printf ("%s\n", sfile
.buffer
);
3447 non_fatal (_("disassemble_fn returned length %d"),
3458 octets
= octets_per_line
;
3459 if (addr_offset
+ octets
/ opb
> stop_offset
)
3460 octets
= (stop_offset
- addr_offset
) * opb
;
3462 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3464 if (ISPRINT (data
[j
]))
3465 buf
[j
- addr_offset
* opb
] = data
[j
];
3467 buf
[j
- addr_offset
* opb
] = '.';
3469 buf
[j
- addr_offset
* opb
] = '\0';
3472 if (prefix_addresses
3474 : show_raw_insn
>= 0)
3478 /* If ! prefix_addresses and ! wide_output, we print
3479 octets_per_line octets per line. */
3481 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3482 pb
= octets_per_line
;
3484 if (inf
->bytes_per_chunk
)
3485 bpc
= inf
->bytes_per_chunk
;
3489 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3491 /* PR 21580: Check for a buffer ending early. */
3492 if (j
+ bpc
<= stop_offset
* opb
)
3496 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3498 for (k
= bpc
; k
-- != 0; )
3499 printf ("%02x", (unsigned) data
[j
+ k
]);
3503 for (k
= 0; k
< bpc
; k
++)
3504 printf ("%02x", (unsigned) data
[j
+ k
]);
3510 for (; pb
< octets_per_line
; pb
+= bpc
)
3514 for (k
= 0; k
< bpc
; k
++)
3519 /* Separate raw data from instruction by extra space. */
3529 printf ("%s", sfile
.buffer
);
3531 if (prefix_addresses
3533 : show_raw_insn
>= 0)
3541 j
= addr_offset
* opb
+ pb
;
3547 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3548 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3552 printf ("%s:\t", buf
+ skip_addr_chars
);
3555 print_jump_visualisation (section
->vma
+ j
/ opb
,
3556 max_level
, line_buffer
,
3559 pb
+= octets_per_line
;
3562 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3564 /* PR 21619: Check for a buffer ending early. */
3565 if (j
+ bpc
<= stop_offset
* opb
)
3569 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3571 for (k
= bpc
; k
-- != 0; )
3572 printf ("%02x", (unsigned) data
[j
+ k
]);
3576 for (k
= 0; k
< bpc
; k
++)
3577 printf ("%02x", (unsigned) data
[j
+ k
]);
3591 while ((*relppp
) < relppend
3592 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3594 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3607 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3612 if (q
->howto
== NULL
)
3613 printf ("*unknown*\t");
3614 else if (q
->howto
->name
)
3615 printf ("%s\t", q
->howto
->name
);
3617 printf ("%d\t", q
->howto
->type
);
3619 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3620 printf ("*unknown*");
3623 const char *sym_name
;
3625 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3626 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3627 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3632 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3633 sym_name
= bfd_section_name (sym_sec
);
3634 if (sym_name
== NULL
|| *sym_name
== '\0')
3635 sym_name
= "*unknown*";
3636 printf ("%s", sanitize_string (sym_name
));
3642 bfd_vma addend
= q
->addend
;
3643 if ((bfd_signed_vma
) addend
< 0)
3650 objdump_print_value (addend
, inf
, true);
3662 addr_offset
+= octets
/ opb
;
3665 free (sfile
.buffer
);
3667 free (color_buffer
);
3671 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3673 const struct elf_backend_data
*bed
;
3674 bfd_vma sign_adjust
= 0;
3675 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3676 struct objdump_disasm_info
*paux
;
3677 unsigned int opb
= pinfo
->octets_per_byte
;
3678 bfd_byte
*data
= NULL
;
3679 bfd_size_type datasize
= 0;
3680 arelent
**rel_pp
= NULL
;
3681 arelent
**rel_ppstart
= NULL
;
3682 arelent
**rel_ppend
;
3683 bfd_vma stop_offset
;
3684 asymbol
*sym
= NULL
;
3688 unsigned long addr_offset
;
3692 stop_offset_reached
,
3697 if (only_list
== NULL
)
3699 /* Sections that do not contain machine
3700 code are not normally disassembled. */
3701 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3704 if (! disassemble_all
3705 && (section
->flags
& SEC_CODE
) == 0)
3708 else if (!process_section_p (section
))
3711 datasize
= bfd_section_size (section
);
3715 if (start_address
== (bfd_vma
) -1
3716 || start_address
< section
->vma
)
3719 addr_offset
= start_address
- section
->vma
;
3721 if (stop_address
== (bfd_vma
) -1)
3722 stop_offset
= datasize
/ opb
;
3725 if (stop_address
< section
->vma
)
3728 stop_offset
= stop_address
- section
->vma
;
3729 if (stop_offset
> datasize
/ opb
)
3730 stop_offset
= datasize
/ opb
;
3733 if (addr_offset
>= stop_offset
)
3736 /* Decide which set of relocs to use. Load them if necessary. */
3737 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3738 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3740 rel_pp
= pinfo
->dynrelbuf
;
3741 rel_count
= pinfo
->dynrelcount
;
3742 /* Dynamic reloc addresses are absolute, non-dynamic are section
3743 relative. REL_OFFSET specifies the reloc address corresponding
3744 to the start of this section. */
3745 rel_offset
= section
->vma
;
3753 if ((section
->flags
& SEC_RELOC
) != 0
3754 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3758 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3760 my_bfd_nonfatal (bfd_get_filename (abfd
));
3764 rel_pp
= (arelent
**) xmalloc (relsize
);
3765 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3768 my_bfd_nonfatal (bfd_get_filename (abfd
));
3773 else if (rel_count
> 1)
3774 /* Sort the relocs by address. */
3775 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3776 rel_ppstart
= rel_pp
;
3780 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3782 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3784 non_fatal (_("Reading section %s failed because: %s"),
3785 section
->name
, bfd_errmsg (bfd_get_error ()));
3789 pinfo
->buffer
= data
;
3790 pinfo
->buffer_vma
= section
->vma
;
3791 pinfo
->buffer_length
= datasize
;
3792 pinfo
->section
= section
;
3794 /* Sort the symbols into value and section order. */
3795 compare_section
= section
;
3796 if (sorted_symcount
> 1)
3797 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3799 /* Skip over the relocs belonging to addresses below the
3801 while (rel_pp
< rel_ppend
3802 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3805 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3807 /* Find the nearest symbol forwards from our current position. */
3808 paux
->require_sec
= true;
3809 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3810 (struct disassemble_info
*) inf
,
3812 paux
->require_sec
= false;
3814 /* PR 9774: If the target used signed addresses then we must make
3815 sure that we sign extend the value that we calculate for 'addr'
3816 in the loop below. */
3817 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3818 && (bed
= get_elf_backend_data (abfd
)) != NULL
3819 && bed
->sign_extend_vma
)
3820 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3822 /* Disassemble a block of instructions up to the address associated with
3823 the symbol we have just found. Then print the symbol and find the
3824 next symbol on. Repeat until we have disassembled the entire section
3825 or we have reached the end of the address range we are interested in. */
3826 do_print
= paux
->symbol
== NULL
;
3827 loop_until
= stop_offset_reached
;
3829 while (addr_offset
< stop_offset
)
3833 bfd_vma nextstop_offset
;
3836 addr
= section
->vma
+ addr_offset
;
3837 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3839 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3844 (x
< sorted_symcount
3845 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3849 pinfo
->symbols
= sorted_syms
+ place
;
3850 pinfo
->num_symbols
= x
- place
;
3851 pinfo
->symtab_pos
= place
;
3855 pinfo
->symbols
= NULL
;
3856 pinfo
->num_symbols
= 0;
3857 pinfo
->symtab_pos
= -1;
3860 /* If we are only disassembling from a specific symbol,
3861 check to see if we should start or stop displaying. */
3862 if (sym
&& paux
->symbol
)
3866 /* See if we should stop printing. */
3870 if (sym
->flags
& BSF_FUNCTION
)
3874 case stop_offset_reached
:
3875 /* Handled by the while loop. */
3879 /* FIXME: There is an implicit assumption here
3880 that the name of sym is different from
3882 if (! bfd_is_local_label (abfd
, sym
))
3889 const char * name
= bfd_asymbol_name (sym
);
3890 char * alloc
= NULL
;
3892 if (do_demangle
&& name
[0] != '\0')
3894 /* Demangle the name. */
3895 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3900 /* We are not currently printing. Check to see
3901 if the current symbol matches the requested symbol. */
3902 if (streq (name
, paux
->symbol
))
3906 /* Skip over the relocs belonging to addresses below the
3908 const bfd_vma sym_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3909 while (rel_pp
< rel_ppend
&&
3910 (*rel_pp
)->address
- rel_offset
< sym_offset
)
3913 if (sym
->flags
& BSF_FUNCTION
)
3915 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3916 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3918 /* Sym is a function symbol with a size associated
3919 with it. Turn on automatic disassembly for the
3920 next VALUE bytes. */
3921 stop_offset
= addr_offset
3922 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3923 loop_until
= stop_offset_reached
;
3927 /* Otherwise we need to tell the loop heuristic to
3928 loop until the next function symbol is encountered. */
3929 loop_until
= function_sym
;
3934 /* Otherwise loop until the next symbol is encountered. */
3935 loop_until
= next_sym
;
3943 if (! prefix_addresses
&& do_print
)
3945 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3946 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3948 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3950 if (sym
!= NULL
&& show_all_symbols
)
3952 for (++place
; place
< sorted_symcount
; place
++)
3954 sym
= sorted_syms
[place
];
3956 if (bfd_asymbol_value (sym
) != addr
)
3958 if (! pinfo
->symbol_is_valid (sym
, pinfo
))
3960 if (strcmp (bfd_section_name (sym
->section
), bfd_section_name (section
)) != 0)
3963 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
, pinfo
, false);
3964 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3969 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3971 else if (sym
== NULL
)
3975 #define is_valid_next_sym(SYM) \
3976 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3977 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3978 && pinfo->symbol_is_valid (SYM, pinfo))
3980 /* Search forward for the next appropriate symbol in
3981 SECTION. Note that all the symbols are sorted
3982 together into one big array, and that some sections
3983 may have overlapping addresses. */
3984 while (place
< sorted_symcount
3985 && ! is_valid_next_sym (sorted_syms
[place
]))
3988 if (place
>= sorted_symcount
)
3991 nextsym
= sorted_syms
[place
];
3994 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3995 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3996 else if (nextsym
== NULL
)
3997 nextstop_offset
= stop_offset
;
3999 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
4001 if (nextstop_offset
> stop_offset
4002 || nextstop_offset
<= addr_offset
)
4003 nextstop_offset
= stop_offset
;
4005 /* If a symbol is explicitly marked as being an object
4006 rather than a function, just dump the bytes without
4007 disassembling them. */
4010 || sym
->section
!= section
4011 || bfd_asymbol_value (sym
) > addr
4012 || ((sym
->flags
& BSF_OBJECT
) == 0
4013 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
4015 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
4017 || (sym
->flags
& BSF_FUNCTION
) != 0)
4024 /* Resolve symbol name. */
4025 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
4027 struct disassemble_info di
;
4030 sf
.alloc
= strlen (sym
->name
) + 40;
4031 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
4033 disassemble_set_printf
4034 (&di
, &sf
, (fprintf_ftype
) objdump_sprintf
,
4035 (fprintf_styled_ftype
) objdump_styled_sprintf
);
4037 objdump_print_symname (abfd
, &di
, sym
);
4039 /* Fetch jump information. */
4040 detected_jumps
= disassemble_jumps
4041 (pinfo
, paux
->disassemble_fn
,
4042 addr_offset
, nextstop_offset
,
4043 rel_offset
, &rel_pp
, rel_ppend
);
4045 /* Free symbol name. */
4049 /* Add jumps to output. */
4050 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
4051 addr_offset
, nextstop_offset
,
4052 rel_offset
, &rel_pp
, rel_ppend
);
4055 while (detected_jumps
)
4057 detected_jumps
= jump_info_free (detected_jumps
);
4061 addr_offset
= nextstop_offset
;
4067 if (rel_ppstart
!= NULL
)
4071 /* Disassemble the contents of an object file. */
4074 disassemble_data (bfd
*abfd
)
4076 struct disassemble_info disasm_info
;
4077 struct objdump_disasm_info aux
;
4081 prev_functionname
= NULL
;
4083 prev_discriminator
= 0;
4085 /* We make a copy of syms to sort. We don't want to sort syms
4086 because that will screw up the relocs. */
4087 sorted_symcount
= symcount
? symcount
: dynsymcount
;
4088 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
4089 * sizeof (asymbol
*));
4090 if (sorted_symcount
!= 0)
4092 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
4093 sorted_symcount
* sizeof (asymbol
*));
4095 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
4098 for (i
= 0; i
< synthcount
; ++i
)
4100 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
4104 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
,
4105 (fprintf_styled_ftype
) fprintf_styled
);
4106 disasm_info
.application_data
= (void *) &aux
;
4108 aux
.require_sec
= false;
4109 disasm_info
.dynrelbuf
= NULL
;
4110 disasm_info
.dynrelcount
= 0;
4112 aux
.symbol
= disasm_sym
;
4114 disasm_info
.print_address_func
= objdump_print_address
;
4115 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
4117 if (machine
!= NULL
)
4119 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
4123 non_fatal (_("can't use supplied machine %s"), machine
);
4127 abfd
->arch_info
= inf
;
4130 if (endian
!= BFD_ENDIAN_UNKNOWN
)
4132 struct bfd_target
*xvec
;
4134 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
4135 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
4136 xvec
->byteorder
= endian
;
4140 /* Use libopcodes to locate a suitable disassembler. */
4141 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
4142 bfd_big_endian (abfd
),
4143 bfd_get_mach (abfd
), abfd
);
4144 if (!aux
.disassemble_fn
)
4146 non_fatal (_("can't disassemble for architecture %s\n"),
4147 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
4152 disasm_info
.flavour
= bfd_get_flavour (abfd
);
4153 disasm_info
.arch
= bfd_get_arch (abfd
);
4154 disasm_info
.mach
= bfd_get_mach (abfd
);
4155 disasm_info
.disassembler_options
= disassembler_options
;
4156 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
4157 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
4158 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
4159 disasm_info
.disassembler_needs_relocs
= false;
4161 if (bfd_big_endian (abfd
))
4162 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
4163 else if (bfd_little_endian (abfd
))
4164 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
4166 /* ??? Aborting here seems too drastic. We could default to big or little
4168 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
4170 disasm_info
.endian_code
= disasm_info
.endian
;
4172 /* Allow the target to customize the info structure. */
4173 disassemble_init_for_target (& disasm_info
);
4175 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
4176 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4180 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
4181 disasm_info
.dynrelcount
4182 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
4183 if (disasm_info
.dynrelcount
< 0)
4185 my_bfd_nonfatal (bfd_get_filename (abfd
));
4186 free (disasm_info
.dynrelbuf
);
4187 disasm_info
.dynrelbuf
= NULL
;
4188 disasm_info
.dynrelcount
= 0;
4190 else if (disasm_info
.dynrelcount
> 1)
4191 /* Sort the relocs by address. */
4192 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
,
4193 sizeof (arelent
*), compare_relocs
);
4196 disasm_info
.symtab
= sorted_syms
;
4197 disasm_info
.symtab_size
= sorted_symcount
;
4199 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
4201 free (disasm_info
.dynrelbuf
);
4202 disasm_info
.dynrelbuf
= NULL
;
4204 disassemble_free_target (&disasm_info
);
4208 load_specific_debug_section (enum dwarf_section_display_enum debug
,
4209 asection
*sec
, void *file
)
4211 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4212 bfd
*abfd
= (bfd
*) file
;
4218 if (section
->start
!= NULL
)
4220 /* If it is already loaded, do nothing. */
4221 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4223 free (section
->start
);
4226 section
->filename
= bfd_get_filename (abfd
);
4227 section
->reloc_info
= NULL
;
4228 section
->num_relocs
= 0;
4229 section
->address
= bfd_section_vma (sec
);
4230 section
->size
= bfd_section_size (sec
);
4231 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
4232 alloced
= amt
= section
->size
+ 1;
4235 || (bfd_get_size (abfd
) != 0 && alloced
>= bfd_get_size (abfd
)))
4237 section
->start
= NULL
;
4238 free_debug_section (debug
);
4239 printf (_("\nSection '%s' has an invalid size: %#" PRIx64
".\n"),
4240 sanitize_string (section
->name
),
4245 section
->start
= contents
= xmalloc (alloced
);
4246 /* Ensure any string section has a terminating NUL. */
4247 section
->start
[section
->size
] = 0;
4249 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4250 && debug_displays
[debug
].relocate
)
4252 ret
= bfd_simple_get_relocated_section_contents (abfd
,
4258 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
4265 relocs
= (arelent
**) xmalloc (reloc_size
);
4267 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, syms
);
4268 if (reloc_count
<= 0)
4272 section
->reloc_info
= relocs
;
4273 section
->num_relocs
= reloc_count
;
4279 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
4283 free_debug_section (debug
);
4284 printf (_("\nCan't get contents for section '%s'.\n"),
4285 sanitize_string (section
->name
));
4293 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
4298 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
4301 relocs
= (arelent
**) dsec
->reloc_info
;
4303 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
4304 if (rp
->address
== offset
)
4311 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
4313 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4314 bfd
*abfd
= (bfd
*) file
;
4318 if (!dump_any_debugging
)
4321 /* If it is already loaded, do nothing. */
4322 if (section
->start
!= NULL
)
4324 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4327 /* Locate the debug section. */
4328 name
= section
->uncompressed_name
;
4329 sec
= bfd_get_section_by_name (abfd
, name
);
4332 name
= section
->compressed_name
;
4334 sec
= bfd_get_section_by_name (abfd
, name
);
4338 name
= section
->xcoff_name
;
4340 sec
= bfd_get_section_by_name (abfd
, name
);
4345 section
->name
= name
;
4346 return load_specific_debug_section (debug
, sec
, file
);
4350 free_debug_section (enum dwarf_section_display_enum debug
)
4352 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4354 free ((char *) section
->start
);
4355 section
->start
= NULL
;
4356 section
->address
= 0;
4358 free ((char*) section
->reloc_info
);
4359 section
->reloc_info
= NULL
;
4360 section
->num_relocs
= 0;
4364 close_debug_file (void * file
)
4366 bfd
* abfd
= (bfd
*) file
;
4372 open_debug_file (const char * pathname
)
4376 data
= bfd_openr (pathname
, NULL
);
4380 if (! bfd_check_format (data
, bfd_object
))
4387 dump_dwarf_section (bfd
*abfd
, asection
*section
,
4390 const char *name
= bfd_section_name (section
);
4393 bool is_mainfile
= *(bool *) arg
;
4398 if (!is_mainfile
&& !process_links
4399 && (section
->flags
& SEC_DEBUGGING
) == 0)
4402 if (startswith (name
, ".gnu.linkonce.wi."))
4403 match
= ".debug_info";
4407 for (i
= 0; i
< max
; i
++)
4408 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
4409 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
4410 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
4411 && debug_displays
[i
].enabled
!= NULL
4412 && *debug_displays
[i
].enabled
)
4414 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
4416 if (strcmp (sec
->uncompressed_name
, match
) == 0)
4417 sec
->name
= sec
->uncompressed_name
;
4418 else if (strcmp (sec
->compressed_name
, match
) == 0)
4419 sec
->name
= sec
->compressed_name
;
4421 sec
->name
= sec
->xcoff_name
;
4422 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
4425 debug_displays
[i
].display (sec
, abfd
);
4427 if (i
!= info
&& i
!= abbrev
)
4428 free_debug_section ((enum dwarf_section_display_enum
) i
);
4434 /* Dump the dwarf debugging information. */
4437 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4439 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4440 if (byte_get
== NULL
)
4442 warn (_("File %s does not contain any dwarf debug information\n"),
4443 bfd_get_filename (abfd
));
4447 switch (bfd_get_arch (abfd
))
4450 /* S12Z has a 24 bit address space. But the only known
4451 producer of dwarf_info encodes addresses into 32 bits. */
4456 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4460 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4461 bfd_get_mach (abfd
));
4463 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4466 /* Read ABFD's section SECT_NAME into *CONTENTS, and return a pointer to
4467 the section. Return NULL on failure. */
4470 read_section (bfd
*abfd
, const char *sect_name
, bfd_byte
**contents
)
4475 sec
= bfd_get_section_by_name (abfd
, sect_name
);
4478 printf (_("No %s section present\n\n"), sanitize_string (sect_name
));
4482 if ((bfd_section_flags (sec
) & SEC_HAS_CONTENTS
) == 0)
4483 bfd_set_error (bfd_error_no_contents
);
4484 else if (bfd_malloc_and_get_section (abfd
, sec
, contents
))
4487 non_fatal (_("reading %s section of %s failed: %s"),
4488 sect_name
, bfd_get_filename (abfd
),
4489 bfd_errmsg (bfd_get_error ()));
4494 /* Stabs entries use a 12 byte format:
4495 4 byte string table index
4497 1 byte stab other field
4498 2 byte stab desc field
4500 FIXME: This will have to change for a 64 bit object format. */
4502 #define STRDXOFF (0)
4504 #define OTHEROFF (5)
4507 #define STABSIZE (12)
4509 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4510 using string table section STRSECT_NAME (in `strtab'). */
4513 print_section_stabs (bfd
*abfd
,
4514 const char *stabsect_name
,
4515 unsigned *string_offset_ptr
)
4518 unsigned file_string_table_offset
= 0;
4519 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4520 bfd_byte
*stabp
, *stabs_end
;
4523 stabs_end
= PTR_ADD (stabp
, stab_size
);
4525 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4526 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4528 /* Loop through all symbols and print them.
4530 We start the index at -1 because there is a dummy symbol on
4531 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4532 for (i
= -1; (size_t) (stabs_end
- stabp
) >= STABSIZE
; stabp
+= STABSIZE
, i
++)
4536 unsigned char type
, other
;
4537 unsigned short desc
;
4540 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4541 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4542 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4543 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4544 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4546 printf ("\n%-6d ", i
);
4547 /* Either print the stab name, or, if unnamed, print its number
4548 again (makes consistent formatting for tools like awk). */
4549 name
= bfd_get_stab_name (type
);
4551 printf ("%-6s", sanitize_string (name
));
4552 else if (type
== N_UNDF
)
4555 printf ("%-6d", type
);
4556 printf (" %-6d %-6d ", other
, desc
);
4557 bfd_printf_vma (abfd
, value
);
4558 printf (" %-6lu", strx
);
4560 /* Symbols with type == 0 (N_UNDF) specify the length of the
4561 string table associated with this file. We use that info
4562 to know how to relocate the *next* file's string table indices. */
4565 file_string_table_offset
= next_file_string_table_offset
;
4566 next_file_string_table_offset
+= value
;
4570 bfd_size_type amt
= strx
+ file_string_table_offset
;
4572 /* Using the (possibly updated) string table offset, print the
4573 string (if any) associated with this symbol. */
4574 if (amt
< stabstr_size
)
4575 /* PR 17512: file: 079-79389-0.001:0.1.
4576 FIXME: May need to sanitize this string before displaying. */
4577 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4583 *string_offset_ptr
= next_file_string_table_offset
;
4588 const char * section_name
;
4589 const char * string_section_name
;
4590 unsigned string_offset
;
4595 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4598 stab_section_names
* sought
= (stab_section_names
*) names
;
4600 /* Check for section names for which stabsect_name is a prefix, to
4601 handle .stab.N, etc. */
4602 len
= strlen (sought
->section_name
);
4604 /* If the prefix matches, and the files section name ends with a
4605 nul or a digit, then we match. I.e., we want either an exact
4606 match or a section followed by a number. */
4607 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4608 && (section
->name
[len
] == 0
4609 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4614 s
= read_section (abfd
, sought
->string_section_name
, &strtab
);
4616 stabstr_size
= bfd_section_size (s
);
4621 s
= read_section (abfd
, section
->name
, &stabs
);
4624 stab_size
= bfd_section_size (s
);
4625 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4633 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4635 stab_section_names s
;
4637 s
.section_name
= stabsect_name
;
4638 s
.string_section_name
= strsect_name
;
4639 s
.string_offset
= 0;
4641 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4647 /* Dump the any sections containing stabs debugging information. */
4650 dump_stabs (bfd
*abfd
)
4652 dump_stabs_section (abfd
, ".stab", ".stabstr");
4653 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4654 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4657 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4659 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4663 dump_bfd_header (bfd
*abfd
)
4667 printf (_("architecture: %s, "),
4668 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4669 bfd_get_mach (abfd
)));
4670 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4672 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4673 PF (HAS_RELOC
, "HAS_RELOC");
4674 PF (EXEC_P
, "EXEC_P");
4675 PF (HAS_LINENO
, "HAS_LINENO");
4676 PF (HAS_DEBUG
, "HAS_DEBUG");
4677 PF (HAS_SYMS
, "HAS_SYMS");
4678 PF (HAS_LOCALS
, "HAS_LOCALS");
4679 PF (DYNAMIC
, "DYNAMIC");
4680 PF (WP_TEXT
, "WP_TEXT");
4681 PF (D_PAGED
, "D_PAGED");
4682 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4683 printf (_("\nstart address 0x"));
4684 bfd_printf_vma (abfd
, abfd
->start_address
);
4689 #ifdef ENABLE_LIBCTF
4690 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4691 it is passed, or a pointer to newly-allocated storage, in which case
4692 dump_ctf() will free it when it no longer needs it. */
4695 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4698 const char *blanks
= arg
;
4701 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4706 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4708 make_ctfsect (const char *name
, bfd_byte
*data
,
4713 ctfsect
.cts_name
= name
;
4714 ctfsect
.cts_entsize
= 1;
4715 ctfsect
.cts_size
= size
;
4716 ctfsect
.cts_data
= data
;
4721 /* Dump CTF errors/warnings. */
4723 dump_ctf_errs (ctf_dict_t
*fp
)
4725 ctf_next_t
*it
= NULL
;
4730 /* Dump accumulated errors and warnings. */
4731 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4733 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4737 if (err
!= ECTF_NEXT_END
)
4739 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4744 /* Dump one CTF archive member. */
4747 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4750 const char *things
[] = {"Header", "Labels", "Data objects",
4751 "Function objects", "Variables", "Types", "Strings",
4756 /* Don't print out the name of the default-named archive member if it appears
4757 first in the list. The name .ctf appears everywhere, even for things that
4758 aren't really archives, so printing it out is liable to be confusing; also,
4759 the common case by far is for only one archive member to exist, and hiding
4760 it in that case seems worthwhile. */
4762 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4763 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4765 if (ctf_parent_name (ctf
) != NULL
)
4766 ctf_import (ctf
, parent
);
4768 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4770 ctf_dump_state_t
*s
= NULL
;
4773 printf ("\n %s:\n", *thing
);
4774 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4775 (void *) " ")) != NULL
)
4777 printf ("%s\n", item
);
4781 if (ctf_errno (ctf
))
4783 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4784 ctf_errmsg (ctf_errno (ctf
)));
4789 dump_ctf_errs (ctf
);
4792 /* Dump the CTF debugging information. */
4795 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4798 ctf_archive_t
*ctfa
= NULL
;
4803 ctf_next_t
*i
= NULL
;
4808 if (sect_name
== NULL
)
4811 sec
= read_section (abfd
, sect_name
, &ctfdata
);
4814 my_bfd_nonfatal (bfd_get_filename (abfd
));
4818 /* Load the CTF file and dump it. Preload the parent dict, since it will
4819 need to be imported into every child in turn. */
4821 ctfsect
= make_ctfsect (sect_name
, ctfdata
, bfd_section_size (sec
));
4822 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4824 dump_ctf_errs (NULL
);
4825 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4826 my_bfd_nonfatal (bfd_get_filename (abfd
));
4831 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4833 dump_ctf_errs (NULL
);
4834 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4835 my_bfd_nonfatal (bfd_get_filename (abfd
));
4841 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4843 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4844 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4845 if (err
!= ECTF_NEXT_END
)
4847 dump_ctf_errs (NULL
);
4848 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4849 my_bfd_nonfatal (bfd_get_filename (abfd
));
4851 ctf_dict_close (parent
);
4857 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4858 const char *parent_name ATTRIBUTE_UNUSED
) {}
4862 dump_section_sframe (bfd
*abfd ATTRIBUTE_UNUSED
,
4863 const char * sect_name
)
4866 sframe_decoder_ctx
*sfd_ctx
= NULL
;
4867 bfd_size_type sf_size
;
4868 bfd_byte
*sframe_data
;
4872 if (sect_name
== NULL
)
4873 sect_name
= ".sframe";
4875 sec
= read_section (abfd
, sect_name
, &sframe_data
);
4878 my_bfd_nonfatal (bfd_get_filename (abfd
));
4881 sf_size
= bfd_section_size (sec
);
4882 sf_vma
= bfd_section_vma (sec
);
4884 /* Decode the contents of the section. */
4885 sfd_ctx
= sframe_decode ((const char*)sframe_data
, sf_size
, &err
);
4888 my_bfd_nonfatal (bfd_get_filename (abfd
));
4893 printf (_("Contents of the SFrame section %s:"),
4894 sanitize_string (sect_name
));
4895 /* Dump the contents as text. */
4896 dump_sframe (sfd_ctx
, sf_vma
);
4898 sframe_decoder_free (&sfd_ctx
);
4904 dump_bfd_private_header (bfd
*abfd
)
4906 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4907 non_fatal (_("warning: private headers incomplete: %s"),
4908 bfd_errmsg (bfd_get_error ()));
4912 dump_target_specific (bfd
*abfd
)
4914 const struct objdump_private_desc
* const *desc
;
4915 struct objdump_private_option
*opt
;
4918 /* Find the desc. */
4919 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4920 if ((*desc
)->filter (abfd
))
4925 non_fatal (_("option -P/--private not supported by this file"));
4929 /* Clear all options. */
4930 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4931 opt
->selected
= false;
4933 /* Decode options. */
4934 b
= dump_private_options
;
4937 e
= strchr (b
, ',');
4942 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4943 if (strcmp (opt
->name
, b
) == 0)
4945 opt
->selected
= true;
4948 if (opt
->name
== NULL
)
4949 non_fatal (_("target specific dump '%s' not supported"), b
);
4960 (*desc
)->dump (abfd
);
4963 /* Display a section in hexadecimal format with associated characters.
4964 Each line prefixed by the zero padded address. */
4967 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4969 bfd_byte
*data
= NULL
;
4970 bfd_size_type datasize
;
4971 bfd_vma addr_offset
;
4972 bfd_vma start_offset
;
4973 bfd_vma stop_offset
;
4974 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4975 /* Bytes per line. */
4976 const int onaline
= 16;
4981 if (only_list
== NULL
)
4983 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4986 else if (!process_section_p (section
))
4989 if ((datasize
= bfd_section_size (section
)) == 0)
4992 /* Compute the address range to display. */
4993 if (start_address
== (bfd_vma
) -1
4994 || start_address
< section
->vma
)
4997 start_offset
= start_address
- section
->vma
;
4999 if (stop_address
== (bfd_vma
) -1)
5000 stop_offset
= datasize
/ opb
;
5003 if (stop_address
< section
->vma
)
5006 stop_offset
= stop_address
- section
->vma
;
5008 if (stop_offset
> datasize
/ opb
)
5009 stop_offset
= datasize
/ opb
;
5012 if (start_offset
>= stop_offset
)
5015 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
5016 if (display_file_offsets
)
5017 printf (_(" (Starting at file offset: 0x%lx)"),
5018 (unsigned long) (section
->filepos
+ start_offset
));
5021 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
5023 non_fatal (_("Reading section %s failed because: %s"),
5024 section
->name
, bfd_errmsg (bfd_get_error ()));
5030 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
5031 if (strlen (buf
) >= sizeof (buf
))
5035 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5037 count
= strlen (buf
) - count
;
5041 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
5042 if (strlen (buf
) >= sizeof (buf
))
5046 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5048 count
= strlen (buf
) - count
;
5052 for (addr_offset
= start_offset
;
5053 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
5057 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
5058 count
= strlen (buf
);
5059 if ((size_t) count
>= sizeof (buf
))
5063 while (count
< width
)
5068 fputs (buf
+ count
- width
, stdout
);
5071 for (j
= addr_offset
* opb
;
5072 j
< addr_offset
* opb
+ onaline
; j
++)
5074 if (j
< stop_offset
* opb
)
5075 printf ("%02x", (unsigned) (data
[j
]));
5083 for (j
= addr_offset
* opb
;
5084 j
< addr_offset
* opb
+ onaline
; j
++)
5086 if (j
>= stop_offset
* opb
)
5089 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
5096 /* Actually display the various requested regions. */
5099 dump_data (bfd
*abfd
)
5101 bfd_map_over_sections (abfd
, dump_section
, NULL
);
5104 /* Should perhaps share code and display with nm? */
5107 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
5116 max_count
= dynsymcount
;
5117 printf ("DYNAMIC SYMBOL TABLE:\n");
5122 max_count
= symcount
;
5123 printf ("SYMBOL TABLE:\n");
5127 printf (_("no symbols\n"));
5129 for (count
= 0; count
< max_count
; count
++)
5133 if (*current
== NULL
)
5134 printf (_("no information for symbol number %ld\n"), count
);
5136 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
5137 printf (_("could not determine the type of symbol number %ld\n"),
5140 else if (process_section_p ((* current
)->section
)
5141 && (dump_special_syms
5142 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
5144 const char *name
= (*current
)->name
;
5146 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
5150 /* If we want to demangle the name, we demangle it
5151 here, and temporarily clobber it while calling
5152 bfd_print_symbol. FIXME: This is a gross hack. */
5153 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
5155 (*current
)->name
= alloc
;
5156 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5157 bfd_print_symbol_all
);
5160 (*current
)->name
= name
;
5164 else if (unicode_display
!= unicode_default
5165 && name
!= NULL
&& *name
!= '\0')
5167 const char * sanitized_name
;
5169 /* If we want to sanitize the name, we do it here, and
5170 temporarily clobber it while calling bfd_print_symbol.
5171 FIXME: This is a gross hack. */
5172 sanitized_name
= sanitize_string (name
);
5173 if (sanitized_name
!= name
)
5174 (*current
)->name
= sanitized_name
;
5176 sanitized_name
= NULL
;
5177 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5178 bfd_print_symbol_all
);
5179 if (sanitized_name
!= NULL
)
5180 (*current
)->name
= name
;
5183 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5184 bfd_print_symbol_all
);
5194 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
5197 char *last_filename
, *last_functionname
;
5198 unsigned int last_line
;
5199 unsigned int last_discriminator
;
5201 /* Get column headers lined up reasonably. */
5209 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
5210 width
= strlen (buf
) - 7;
5212 printf ("OFFSET %*s TYPE %*s VALUE\n", width
, "", 12, "");
5215 last_filename
= NULL
;
5216 last_functionname
= NULL
;
5218 last_discriminator
= 0;
5220 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
5223 const char *filename
, *functionname
;
5224 unsigned int linenumber
;
5225 unsigned int discriminator
;
5226 const char *sym_name
;
5227 const char *section_name
;
5228 bfd_vma addend2
= 0;
5230 if (start_address
!= (bfd_vma
) -1
5231 && q
->address
< start_address
)
5233 if (stop_address
!= (bfd_vma
) -1
5234 && q
->address
> stop_address
)
5237 if (with_line_numbers
5239 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
5240 &filename
, &functionname
,
5241 &linenumber
, &discriminator
))
5243 if (functionname
!= NULL
5244 && (last_functionname
== NULL
5245 || strcmp (functionname
, last_functionname
) != 0))
5247 printf ("%s():\n", sanitize_string (functionname
));
5248 if (last_functionname
!= NULL
)
5249 free (last_functionname
);
5250 last_functionname
= xstrdup (functionname
);
5254 && (linenumber
!= last_line
5255 || (filename
!= NULL
5256 && last_filename
!= NULL
5257 && filename_cmp (filename
, last_filename
) != 0)
5258 || (discriminator
!= last_discriminator
)))
5260 if (discriminator
> 0)
5261 printf ("%s:%u\n", filename
== NULL
? "???" :
5262 sanitize_string (filename
), linenumber
);
5264 printf ("%s:%u (discriminator %u)\n",
5265 filename
== NULL
? "???" : sanitize_string (filename
),
5266 linenumber
, discriminator
);
5267 last_line
= linenumber
;
5268 last_discriminator
= discriminator
;
5269 if (last_filename
!= NULL
)
5270 free (last_filename
);
5271 if (filename
== NULL
)
5272 last_filename
= NULL
;
5274 last_filename
= xstrdup (filename
);
5278 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
5280 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
5281 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
5286 section_name
= NULL
;
5289 bfd_printf_vma (abfd
, q
->address
);
5290 if (q
->howto
== NULL
)
5291 printf (" *unknown* ");
5292 else if (q
->howto
->name
)
5294 const char *name
= q
->howto
->name
;
5296 /* R_SPARC_OLO10 relocations contain two addends.
5297 But because 'arelent' lacks enough storage to
5298 store them both, the 64-bit ELF Sparc backend
5299 records this as two relocations. One R_SPARC_LO10
5300 and one R_SPARC_13, both pointing to the same
5301 address. This is merely so that we have some
5302 place to store both addend fields.
5304 Undo this transformation, otherwise the output
5305 will be confusing. */
5306 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
5307 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
5309 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
5311 arelent
*q2
= *(p
+ 1);
5314 && q
->address
== q2
->address
5315 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
5317 name
= "R_SPARC_OLO10";
5318 addend2
= q2
->addend
;
5322 printf (" %-16s ", name
);
5325 printf (" %-16d ", q
->howto
->type
);
5329 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
5333 if (section_name
== NULL
)
5334 section_name
= "*unknown*";
5335 printf ("[%s]", sanitize_string (section_name
));
5340 bfd_signed_vma addend
= q
->addend
;
5348 bfd_printf_vma (abfd
, addend
);
5353 bfd_printf_vma (abfd
, addend2
);
5359 if (last_filename
!= NULL
)
5360 free (last_filename
);
5361 if (last_functionname
!= NULL
)
5362 free (last_functionname
);
5366 dump_relocs_in_section (bfd
*abfd
,
5368 void *dummy ATTRIBUTE_UNUSED
)
5374 if ( bfd_is_abs_section (section
)
5375 || bfd_is_und_section (section
)
5376 || bfd_is_com_section (section
)
5377 || (! process_section_p (section
))
5378 || ((section
->flags
& SEC_RELOC
) == 0))
5381 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
5383 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
5386 printf (" (none)\n\n");
5397 relpp
= (arelent
**) xmalloc (relsize
);
5398 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
5404 non_fatal (_("failed to read relocs in: %s"),
5405 sanitize_string (bfd_get_filename (abfd
)));
5406 my_bfd_nonfatal (_("error message was"));
5408 else if (relcount
== 0)
5409 printf (" (none)\n\n");
5413 dump_reloc_set (abfd
, section
, relpp
, relcount
);
5420 dump_relocs (bfd
*abfd
)
5422 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
5426 dump_dynamic_relocs (bfd
*abfd
)
5432 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5434 printf ("DYNAMIC RELOCATION RECORDS");
5438 printf (" (none)\n\n");
5449 relpp
= (arelent
**) xmalloc (relsize
);
5450 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
5456 non_fatal (_("failed to read relocs in: %s"),
5457 sanitize_string (bfd_get_filename (abfd
)));
5458 my_bfd_nonfatal (_("error message was"));
5460 else if (relcount
== 0)
5461 printf (" (none)\n\n");
5465 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
5471 /* Creates a table of paths, to search for source files. */
5474 add_include_path (const char *path
)
5478 include_path_count
++;
5479 include_paths
= (const char **)
5480 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
5481 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5482 if (path
[1] == ':' && path
[2] == 0)
5483 path
= concat (path
, ".", (const char *) 0);
5485 include_paths
[include_path_count
- 1] = path
;
5489 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
5493 if ((section
->flags
& SEC_DEBUGGING
) == 0)
5495 bool *has_reloc_p
= (bool *) arg
;
5496 section
->vma
+= adjust_section_vma
;
5498 section
->lma
+= adjust_section_vma
;
5502 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5505 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5510 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5511 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5515 might_need_separate_debug_info (bool is_mainfile
)
5517 /* We do not follow links from debug info files. */
5521 /* Since do_follow_links might be enabled by default, only treat it as an
5522 indication that separate files should be loaded if setting it was a
5523 deliberate user action. */
5524 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
5527 if (process_links
|| dump_symtab
|| dump_debugging
5528 || dump_dwarf_section_info
|| with_source_code
)
5534 /* Dump selected contents of ABFD. */
5537 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5539 const struct elf_backend_data
* bed
;
5541 if (bfd_big_endian (abfd
))
5542 byte_get
= byte_get_big_endian
;
5543 else if (bfd_little_endian (abfd
))
5544 byte_get
= byte_get_little_endian
;
5548 /* Load any separate debug information files. */
5549 if (byte_get
!= NULL
&& might_need_separate_debug_info (is_mainfile
))
5551 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5553 /* If asked to do so, recursively dump the separate files. */
5554 if (do_follow_links
)
5558 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5559 dump_bfd (i
->handle
, false);
5563 /* Adjust user-specified start and stop limits for targets that use
5564 signed addresses. */
5565 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5566 && (bed
= get_elf_backend_data (abfd
)) != NULL
5567 && bed
->sign_extend_vma
)
5569 start_address
= sign_extend_address (abfd
, start_address
,
5571 stop_address
= sign_extend_address (abfd
, stop_address
,
5575 /* If we are adjusting section VMA's, change them all now. Changing
5576 the BFD information is a hack. However, we must do it, or
5577 bfd_find_nearest_line will not do the right thing. */
5578 if (adjust_section_vma
!= 0)
5580 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5581 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5584 if (is_mainfile
|| process_links
)
5586 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5587 printf (_("\n%s: file format %s\n"),
5588 sanitize_string (bfd_get_filename (abfd
)),
5591 print_arelt_descr (stdout
, abfd
, true, false);
5592 if (dump_file_header
)
5593 dump_bfd_header (abfd
);
5594 if (dump_private_headers
)
5595 dump_bfd_private_header (abfd
);
5596 if (dump_private_options
!= NULL
)
5597 dump_target_specific (abfd
);
5598 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5606 || dump_dwarf_section_info
)
5608 syms
= slurp_symtab (abfd
);
5610 /* If following links, load any symbol tables from the linked files as well. */
5611 if (do_follow_links
&& is_mainfile
)
5615 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5617 asymbol
** extra_syms
;
5618 long old_symcount
= symcount
;
5620 extra_syms
= slurp_symtab (i
->handle
);
5624 if (old_symcount
== 0)
5630 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5631 * sizeof (asymbol
*)));
5632 memcpy (syms
+ old_symcount
,
5634 (symcount
+ 1) * sizeof (asymbol
*));
5638 symcount
+= old_symcount
;
5643 if (is_mainfile
|| process_links
)
5645 if (dump_section_headers
)
5646 dump_headers (abfd
);
5648 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5649 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5650 dynsyms
= slurp_dynamic_symtab (abfd
);
5654 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5655 dynsymcount
, dynsyms
,
5662 dump_symbols (abfd
, false);
5663 if (dump_dynamic_symtab
)
5664 dump_symbols (abfd
, true);
5666 if (dump_dwarf_section_info
)
5667 dump_dwarf (abfd
, is_mainfile
);
5668 if (is_mainfile
|| process_links
)
5670 if (dump_ctf_section_info
)
5671 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5672 if (dump_sframe_section_info
)
5673 dump_section_sframe (abfd
, dump_sframe_section_name
);
5674 if (dump_stab_section_info
)
5676 if (dump_reloc_info
&& ! disassemble
)
5678 if (dump_dynamic_reloc_info
&& ! disassemble
)
5679 dump_dynamic_relocs (abfd
);
5680 if (dump_section_contents
)
5683 disassemble_data (abfd
);
5690 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5691 if (dhandle
!= NULL
)
5693 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5695 dump_debugging_tags
!= 0))
5697 non_fatal (_("%s: printing debugging information failed"),
5698 bfd_get_filename (abfd
));
5702 /* PR 6483: If there was no STABS debug info in the file, try
5704 else if (! dump_dwarf_section_info
)
5706 dwarf_select_sections_all ();
5707 dump_dwarf (abfd
, is_mainfile
);
5734 free_debug_memory ();
5738 display_object_bfd (bfd
*abfd
)
5742 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5744 dump_bfd (abfd
, true);
5748 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5750 my_bfd_nonfatal (bfd_get_filename (abfd
));
5751 list_matching_formats (matching
);
5755 if (bfd_get_error () != bfd_error_file_not_recognized
)
5757 my_bfd_nonfatal (bfd_get_filename (abfd
));
5761 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5763 dump_bfd (abfd
, true);
5767 my_bfd_nonfatal (bfd_get_filename (abfd
));
5769 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5770 list_matching_formats (matching
);
5774 display_any_bfd (bfd
*file
, int level
)
5776 /* Decompress sections unless dumping the section contents. */
5777 if (!dump_section_contents
)
5778 file
->flags
|= BFD_DECOMPRESS
;
5780 /* If the file is an archive, process all of its elements. */
5781 if (bfd_check_format (file
, bfd_archive
))
5784 bfd
*last_arfile
= NULL
;
5787 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5788 else if (level
> 100)
5790 /* Prevent corrupted files from spinning us into an
5791 infinite loop. 100 is an arbitrary heuristic. */
5792 non_fatal (_("Archive nesting is too deep"));
5797 printf (_("In nested archive %s:\n"),
5798 sanitize_string (bfd_get_filename (file
)));
5802 bfd_set_error (bfd_error_no_error
);
5804 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5807 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5808 my_bfd_nonfatal (bfd_get_filename (file
));
5812 display_any_bfd (arfile
, level
+ 1);
5814 if (last_arfile
!= NULL
)
5816 bfd_close (last_arfile
);
5817 /* PR 17512: file: ac585d01. */
5818 if (arfile
== last_arfile
)
5824 last_arfile
= arfile
;
5827 if (last_arfile
!= NULL
)
5828 bfd_close (last_arfile
);
5831 display_object_bfd (file
);
5835 display_file (char *filename
, char *target
, bool last_file
)
5839 if (get_file_size (filename
) < 1)
5845 file
= bfd_openr (filename
, target
);
5848 my_bfd_nonfatal (filename
);
5852 display_any_bfd (file
, 0);
5854 /* This is an optimization to improve the speed of objdump, especially when
5855 dumping a file with lots of associated debug informatiom. Calling
5856 bfd_close on such a file can take a non-trivial amount of time as there
5857 are lots of lists to walk and buffers to free. This is only really
5858 necessary however if we are about to load another file and we need the
5859 memory back. Otherwise, if we are about to exit, then we can save (a lot
5860 of) time by only doing a quick close, and allowing the OS to reclaim the
5865 bfd_close_all_done (file
);
5869 main (int argc
, char **argv
)
5872 char *target
= default_target
;
5873 bool seenflag
= false;
5875 #ifdef HAVE_LC_MESSAGES
5876 setlocale (LC_MESSAGES
, "");
5878 setlocale (LC_CTYPE
, "");
5880 bindtextdomain (PACKAGE
, LOCALEDIR
);
5881 textdomain (PACKAGE
);
5883 program_name
= *argv
;
5884 xmalloc_set_program_name (program_name
);
5885 bfd_set_error_program_name (program_name
);
5887 expandargv (&argc
, &argv
);
5889 if (bfd_init () != BFD_INIT_MAGIC
)
5890 fatal (_("fatal error: libbfd ABI mismatch"));
5891 set_default_bfd_target ();
5893 while ((c
= getopt_long (argc
, argv
,
5894 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5895 long_options
, (int *) 0))
5901 break; /* We've been given a long option. */
5908 if (disassembler_options
)
5909 /* Ignore potential memory leak for now. */
5910 options
= concat (disassembler_options
, ",",
5911 optarg
, (const char *) NULL
);
5914 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5921 display_file_offsets
= true;
5924 with_line_numbers
= true;
5933 enum demangling_styles style
;
5935 style
= cplus_demangle_name_to_style (optarg
);
5936 if (style
== unknown_demangling
)
5937 fatal (_("unknown demangling style `%s'"),
5940 cplus_demangle_set_style (style
);
5943 case OPTION_RECURSE_LIMIT
:
5944 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5946 case OPTION_NO_RECURSE_LIMIT
:
5947 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5950 do_wide
= wide_output
= true;
5952 case OPTION_ADJUST_VMA
:
5953 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5955 case OPTION_START_ADDRESS
:
5956 start_address
= parse_vma (optarg
, "--start-address");
5957 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5958 fatal (_("error: the start address should be before the end address"));
5960 case OPTION_STOP_ADDRESS
:
5961 stop_address
= parse_vma (optarg
, "--stop-address");
5962 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5963 fatal (_("error: the stop address should be after the start address"));
5967 prefix_length
= strlen (prefix
);
5968 /* Remove an unnecessary trailing '/' */
5969 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5972 case OPTION_PREFIX_STRIP
:
5973 prefix_strip
= atoi (optarg
);
5974 if (prefix_strip
< 0)
5975 fatal (_("error: prefix strip must be non-negative"));
5977 case OPTION_INSN_WIDTH
:
5978 insn_width
= strtoul (optarg
, NULL
, 0);
5979 if (insn_width
<= 0)
5980 fatal (_("error: instruction width must be positive"));
5982 case OPTION_INLINES
:
5983 unwind_inlines
= true;
5985 case OPTION_VISUALIZE_JUMPS
:
5986 visualize_jumps
= true;
5987 color_output
= false;
5988 extended_color_output
= false;
5991 if (streq (optarg
, "color"))
5992 color_output
= true;
5993 else if (streq (optarg
, "extended-color"))
5995 color_output
= true;
5996 extended_color_output
= true;
5998 else if (streq (optarg
, "off"))
5999 visualize_jumps
= false;
6002 non_fatal (_("unrecognized argument to --visualize-option"));
6007 case OPTION_DISASSEMBLER_COLOR
:
6008 if (streq (optarg
, "off"))
6009 disassembler_color
= off
;
6010 else if (streq (optarg
, "terminal"))
6011 disassembler_color
= on_if_terminal_output
;
6012 else if (streq (optarg
, "color")
6013 || streq (optarg
, "colour")
6014 || streq (optarg
, "on"))
6015 disassembler_color
= on
;
6016 else if (streq (optarg
, "extended")
6017 || streq (optarg
, "extended-color")
6018 || streq (optarg
, "extended-colour"))
6019 disassembler_color
= extended
;
6022 non_fatal (_("unrecognized argument to --disassembler-color"));
6027 if (strcmp (optarg
, "B") == 0)
6028 endian
= BFD_ENDIAN_BIG
;
6029 else if (strcmp (optarg
, "L") == 0)
6030 endian
= BFD_ENDIAN_LITTLE
;
6033 non_fatal (_("unrecognized -E option"));
6038 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
6039 endian
= BFD_ENDIAN_BIG
;
6040 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
6041 endian
= BFD_ENDIAN_LITTLE
;
6044 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
6050 dump_file_header
= true;
6054 formats_info
= true;
6058 add_include_path (optarg
);
6061 dump_private_headers
= true;
6065 dump_private_options
= optarg
;
6069 dump_private_headers
= true;
6071 dump_reloc_info
= true;
6072 dump_file_header
= true;
6073 dump_ar_hdrs
= true;
6074 dump_section_headers
= true;
6082 dump_dynamic_symtab
= true;
6088 disasm_sym
= optarg
;
6091 disassemble_zeroes
= true;
6095 disassemble_all
= true;
6100 with_source_code
= true;
6103 case OPTION_SOURCE_COMMENT
:
6105 with_source_code
= true;
6108 source_comment
= xstrdup (sanitize_string (optarg
));
6110 source_comment
= xstrdup ("# ");
6118 dump_debugging_tags
= 1;
6123 process_links
= true;
6124 do_follow_links
= true;
6130 if (dwarf_select_sections_by_letters (optarg
))
6131 dump_dwarf_section_info
= true;
6135 dump_dwarf_section_info
= true;
6136 dwarf_select_sections_all ();
6143 if (dwarf_select_sections_by_names (optarg
))
6144 dump_dwarf_section_info
= true;
6148 dwarf_select_sections_all ();
6149 dump_dwarf_section_info
= true;
6152 case OPTION_DWARF_DEPTH
:
6155 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6158 case OPTION_DWARF_START
:
6161 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6162 suppress_bfd_header
= 1;
6165 case OPTION_DWARF_CHECK
:
6168 #ifdef ENABLE_LIBCTF
6170 dump_ctf_section_info
= true;
6172 dump_ctf_section_name
= xstrdup (optarg
);
6175 case OPTION_CTF_PARENT
:
6176 dump_ctf_parent_name
= xstrdup (optarg
);
6180 dump_sframe_section_info
= true;
6182 dump_sframe_section_name
= xstrdup (optarg
);
6186 dump_stab_section_info
= true;
6190 dump_section_contents
= true;
6194 dump_reloc_info
= true;
6198 dump_dynamic_reloc_info
= true;
6202 dump_ar_hdrs
= true;
6206 dump_section_headers
= true;
6211 show_version
= true;
6216 if (streq (optarg
, "default") || streq (optarg
, "d"))
6217 unicode_display
= unicode_default
;
6218 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6219 unicode_display
= unicode_locale
;
6220 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6221 unicode_display
= unicode_escape
;
6222 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6223 unicode_display
= unicode_invalid
;
6224 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6225 unicode_display
= unicode_hex
;
6226 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6227 unicode_display
= unicode_highlight
;
6229 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
6234 /* No need to set seenflag or to break - usage() does not return. */
6240 if (disassembler_color
== on_if_terminal_output
)
6241 disassembler_color
= isatty (1) ? on
: off
;
6244 print_version ("objdump");
6249 dump_any_debugging
= (dump_debugging
6250 || dump_dwarf_section_info
6252 || with_source_code
);
6255 exit_status
= display_info ();
6259 display_file ("a.out", target
, true);
6261 for (; optind
< argc
;)
6263 display_file (argv
[optind
], target
, optind
== argc
- 1);
6269 free (dump_ctf_section_name
);
6270 free (dump_ctf_parent_name
);
6271 free ((void *) source_comment
);