1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2022 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. */
58 #include "demanguse.h"
61 #include "sframe-api.h"
63 #include "safe-ctype.h"
65 #include "libiberty.h"
67 #include "filenames.h"
76 #ifdef HAVE_LIBDEBUGINFOD
77 #include <elfutils/debuginfod.h>
80 /* Internal headers for the ELF .stab-dump code - sorry. */
81 #define BYTES_IN_WORD 32
82 #include "aout/aout64.h"
85 static int exit_status
= 0;
87 static char *default_target
= NULL
; /* Default at runtime. */
89 /* The following variables are set based on arguments passed on the
91 static int show_version
= 0; /* Show the version number. */
92 static int dump_section_contents
; /* -s */
93 static int dump_section_headers
; /* -h */
94 static bool dump_file_header
; /* -f */
95 static int dump_symtab
; /* -t */
96 static int dump_dynamic_symtab
; /* -T */
97 static int dump_reloc_info
; /* -r */
98 static int dump_dynamic_reloc_info
; /* -R */
99 static int dump_ar_hdrs
; /* -a */
100 static int dump_private_headers
; /* -p */
101 static char *dump_private_options
; /* -P */
102 static int no_addresses
; /* --no-addresses */
103 static int prefix_addresses
; /* --prefix-addresses */
104 static int with_line_numbers
; /* -l */
105 static bool with_source_code
; /* -S */
106 static int show_raw_insn
; /* --show-raw-insn */
107 static int dump_dwarf_section_info
; /* --dwarf */
108 static int dump_stab_section_info
; /* --stabs */
109 static int dump_ctf_section_info
; /* --ctf */
110 static char *dump_ctf_section_name
;
111 static char *dump_ctf_parent_name
; /* --ctf-parent */
112 static int dump_sframe_section_info
; /* --sframe */
113 static char *dump_sframe_section_name
;
114 static int do_demangle
; /* -C, --demangle */
115 static bool disassemble
; /* -d */
116 static bool disassemble_all
; /* -D */
117 static int disassemble_zeroes
; /* --disassemble-zeroes */
118 static bool formats_info
; /* -i */
119 static int wide_output
; /* -w */
120 static int insn_width
; /* --insn-width */
121 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
122 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
123 static int dump_debugging
; /* --debugging */
124 static int dump_debugging_tags
; /* --debugging-tags */
125 static int suppress_bfd_header
;
126 static int dump_special_syms
= 0; /* --special-syms */
127 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
128 static int file_start_context
= 0; /* --file-start-context */
129 static bool display_file_offsets
; /* -F */
130 static const char *prefix
; /* --prefix */
131 static int prefix_strip
; /* --prefix-strip */
132 static size_t prefix_length
;
133 static bool unwind_inlines
; /* --inlines. */
134 static const char * disasm_sym
; /* Disassembly start symbol. */
135 static const char * source_comment
; /* --source_comment. */
136 static bool visualize_jumps
= false; /* --visualize-jumps. */
137 static bool color_output
= false; /* --visualize-jumps=color. */
138 static bool extended_color_output
= false; /* --visualize-jumps=extended-color. */
139 static int process_links
= false; /* --process-links. */
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 --special-syms Include special symbols in symbol dumps\n"));
403 fprintf (stream
, _("\
404 --inlines Print all inlines for source line (with -l)\n"));
405 fprintf (stream
, _("\
406 --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
407 fprintf (stream
, _("\
408 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
409 fprintf (stream
, _("\
410 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
411 fprintf (stream
, _("\
412 --dwarf-start=N Display DIEs starting at offset N\n"));
413 fprintf (stream
, _("\
414 --dwarf-check Make additional dwarf consistency checks.\n"));
416 fprintf (stream
, _("\
417 --ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
419 fprintf (stream
, _("\
420 --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
421 fprintf (stream
, _("\
422 --visualize-jumps=color Use colors in the ASCII art\n"));
423 fprintf (stream
, _("\
424 --visualize-jumps=extended-color\n\
425 Use extended 8-bit color codes\n"));
426 fprintf (stream
, _("\
427 --visualize-jumps=off Disable jump visualization\n"));
428 #if DEFAULT_FOR_COLORED_DISASSEMBLY
429 fprintf (stream
, _("\
430 --disassembler-color=off Disable disassembler color output.\n"));
431 fprintf (stream
, _("\
432 --disassembler-color=terminal Enable disassembler color output if displaying on a terminal. (default)\n"));
434 fprintf (stream
, _("\
435 --disassembler-color=off Disable disassembler color output. (default)\n"));
436 fprintf (stream
, _("\
437 --disassembler-color=terminal Enable disassembler color output if displaying on a terminal.\n"));
439 fprintf (stream
, _("\
440 --disassembler-color=on Enable disassembler color output.\n"));
441 fprintf (stream
, _("\
442 --disassembler-color=extended Use 8-bit colors in disassembler output.\n\n"));
444 list_supported_targets (program_name
, stream
);
445 list_supported_architectures (program_name
, stream
);
447 disassembler_usage (stream
);
449 if (objdump_private_vectors
[0] != NULL
)
452 _("\nOptions supported for -P/--private switch:\n"));
453 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
454 (*desc
)->help (stream
);
457 if (REPORT_BUGS_TO
[0] && status
== 0)
458 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
462 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
466 OPTION_START_ADDRESS
,
476 OPTION_RECURSE_LIMIT
,
477 OPTION_NO_RECURSE_LIMIT
,
479 OPTION_SOURCE_COMMENT
,
485 OPTION_VISUALIZE_JUMPS
,
486 OPTION_DISASSEMBLER_COLOR
489 static struct option long_options
[]=
491 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
492 {"all-headers", no_argument
, NULL
, 'x'},
493 {"architecture", required_argument
, NULL
, 'm'},
494 {"archive-headers", no_argument
, NULL
, 'a'},
496 {"ctf", optional_argument
, NULL
, OPTION_CTF
},
497 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
499 {"debugging", no_argument
, NULL
, 'g'},
500 {"debugging-tags", no_argument
, NULL
, 'e'},
501 {"demangle", optional_argument
, NULL
, 'C'},
502 {"disassemble", optional_argument
, NULL
, 'd'},
503 {"disassemble-all", no_argument
, NULL
, 'D'},
504 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
505 {"disassembler-options", required_argument
, NULL
, 'M'},
506 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
507 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
508 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
509 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
510 {"dynamic-reloc", no_argument
, NULL
, 'R'},
511 {"dynamic-syms", no_argument
, NULL
, 'T'},
512 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
513 {"file-headers", no_argument
, NULL
, 'f'},
514 {"file-offsets", no_argument
, NULL
, 'F'},
515 {"file-start-context", no_argument
, &file_start_context
, 1},
516 {"full-contents", no_argument
, NULL
, 's'},
517 {"headers", no_argument
, NULL
, 'h'},
518 {"help", no_argument
, NULL
, 'H'},
519 {"include", required_argument
, NULL
, 'I'},
520 {"info", no_argument
, NULL
, 'i'},
521 {"inlines", no_argument
, 0, OPTION_INLINES
},
522 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
523 {"line-numbers", no_argument
, NULL
, 'l'},
524 {"no-addresses", no_argument
, &no_addresses
, 1},
525 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
526 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
527 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
528 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
529 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
530 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
531 {"private", required_argument
, NULL
, 'P'},
532 {"private-headers", no_argument
, NULL
, 'p'},
533 {"process-links", no_argument
, &process_links
, true},
534 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
535 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
536 {"reloc", no_argument
, NULL
, 'r'},
537 {"section", required_argument
, NULL
, 'j'},
538 {"section-headers", no_argument
, NULL
, 'h'},
539 {"sframe", optional_argument
, NULL
, OPTION_SFRAME
},
540 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
541 {"source", no_argument
, NULL
, 'S'},
542 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
543 {"special-syms", no_argument
, &dump_special_syms
, 1},
544 {"stabs", no_argument
, NULL
, 'G'},
545 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
546 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
547 {"syms", no_argument
, NULL
, 't'},
548 {"target", required_argument
, NULL
, 'b'},
549 {"unicode", required_argument
, NULL
, 'U'},
550 {"version", no_argument
, NULL
, 'V'},
551 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
552 {"wide", no_argument
, NULL
, 'w'},
553 {"disassembler-color", required_argument
, NULL
, OPTION_DISASSEMBLER_COLOR
},
554 {NULL
, no_argument
, NULL
, 0}
558 nonfatal (const char *msg
)
564 /* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
565 The conversion format is controlled by the unicode_display variable.
566 Returns the number of characters added to OUT.
567 Returns the number of bytes consumed from IN in CONSUMED.
568 Always consumes at least one byte and displays at least one character. */
571 display_utf8 (const unsigned char * in
, char * out
, unsigned int * consumed
)
573 char * orig_out
= out
;
574 unsigned int nchars
= 0;
577 if (unicode_display
== unicode_default
)
583 if ((in
[1] & 0xc0) != 0x80)
586 if ((in
[0] & 0x20) == 0)
592 if ((in
[2] & 0xc0) != 0x80)
595 if ((in
[0] & 0x10) == 0)
601 if ((in
[3] & 0xc0) != 0x80)
607 switch (unicode_display
)
610 /* Copy the bytes into the output buffer as is. */
611 memcpy (out
, in
, nchars
);
615 case unicode_invalid
:
617 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '<' : '{');
618 out
+= sprintf (out
, "0x");
619 for (j
= 0; j
< nchars
; j
++)
620 out
+= sprintf (out
, "%02x", in
[j
]);
621 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '>' : '}');
624 case unicode_highlight
:
626 out
+= sprintf (out
, "\x1B[31;47m"); /* Red. */
632 out
+= sprintf (out
, "\\u%02x%02x",
633 ((in
[0] & 0x1c) >> 2),
634 ((in
[0] & 0x03) << 6) | (in
[1] & 0x3f));
638 out
+= sprintf (out
, "\\u%02x%02x",
639 ((in
[0] & 0x0f) << 4) | ((in
[1] & 0x3c) >> 2),
640 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3f)));
644 out
+= sprintf (out
, "\\u%02x%02x%02x",
645 ((in
[0] & 0x07) << 6) | ((in
[1] & 0x3c) >> 2),
646 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3c) >> 2),
647 ((in
[2] & 0x03) << 6) | ((in
[3] & 0x3f)));
654 if (unicode_display
== unicode_highlight
&& isatty (1))
655 out
+= sprintf (out
, "\033[0m"); /* Default colour. */
664 return out
- orig_out
;
667 /* Not a valid UTF-8 sequence. */
673 /* Returns a version of IN with any control characters
674 replaced by escape sequences. Uses a static buffer
677 If unicode display is enabled, then also handles the
678 conversion of unicode characters. */
681 sanitize_string (const char * in
)
683 static char * buffer
= NULL
;
684 static size_t buffer_len
= 0;
685 const char * original
= in
;
692 /* See if any conversion is necessary. In the majority
693 of cases it will not be needed. */
696 unsigned char c
= *in
++;
704 if (unicode_display
!= unicode_default
&& c
>= 0xc0)
709 /* Copy the input, translating as needed. */
711 if (buffer_len
< (strlen (in
) * 9))
713 free ((void *) buffer
);
714 buffer_len
= strlen (in
) * 9;
715 buffer
= xmalloc (buffer_len
+ 1);
721 unsigned char c
= *in
++;
731 else if (unicode_display
!= unicode_default
&& c
>= 0xc0)
733 unsigned int num_consumed
;
735 out
+= display_utf8 ((const unsigned char *)(in
- 1), out
, & num_consumed
);
736 in
+= num_consumed
- 1;
748 /* Returns TRUE if the specified section should be dumped. */
751 process_section_p (asection
* section
)
755 if (only_list
== NULL
)
758 for (only
= only_list
; only
; only
= only
->next
)
759 if (strcmp (only
->name
, section
->name
) == 0)
768 /* Add an entry to the 'only' list. */
771 add_only (char * name
)
775 /* First check to make sure that we do not
776 already have an entry for this name. */
777 for (only
= only_list
; only
; only
= only
->next
)
778 if (strcmp (only
->name
, name
) == 0)
781 only
= xmalloc (sizeof * only
);
784 only
->next
= only_list
;
788 /* Release the memory used by the 'only' list.
789 PR 11225: Issue a warning message for unseen sections.
790 Only do this if none of the sections were seen. This is mainly to support
791 tools like the GAS testsuite where an object file is dumped with a list of
792 generic section names known to be present in a range of different file
796 free_only_list (void)
798 bool at_least_one_seen
= false;
802 if (only_list
== NULL
)
805 for (only
= only_list
; only
; only
= only
->next
)
808 at_least_one_seen
= true;
812 for (only
= only_list
; only
; only
= next
)
814 if (! at_least_one_seen
)
816 non_fatal (_("section '%s' mentioned in a -j option, "
817 "but not found in any input file"),
828 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
831 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
832 int longest_section_name
= *((int *) data
);
834 /* Ignore linker created section. See elfNN_ia64_object_p in
836 if (section
->flags
& SEC_LINKER_CREATED
)
839 /* PR 10413: Skip sections that we are ignoring. */
840 if (! process_section_p (section
))
843 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
844 sanitize_string (bfd_section_name (section
)),
845 (unsigned long) bfd_section_size (section
) / opb
);
846 bfd_printf_vma (abfd
, bfd_section_vma (section
));
848 bfd_printf_vma (abfd
, section
->lma
);
849 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
850 bfd_section_alignment (section
));
856 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
858 PF (SEC_HAS_CONTENTS
, "CONTENTS");
859 PF (SEC_ALLOC
, "ALLOC");
860 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
861 PF (SEC_LOAD
, "LOAD");
862 PF (SEC_RELOC
, "RELOC");
863 PF (SEC_READONLY
, "READONLY");
864 PF (SEC_CODE
, "CODE");
865 PF (SEC_DATA
, "DATA");
867 PF (SEC_DEBUGGING
, "DEBUGGING");
868 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
869 PF (SEC_EXCLUDE
, "EXCLUDE");
870 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
871 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
873 PF (SEC_TIC54X_BLOCK
, "BLOCK");
874 PF (SEC_TIC54X_CLINK
, "CLINK");
876 PF (SEC_SMALL_DATA
, "SMALL_DATA");
877 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
879 PF (SEC_COFF_SHARED
, "SHARED");
880 PF (SEC_COFF_NOREAD
, "NOREAD");
882 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
884 PF (SEC_ELF_OCTETS
, "OCTETS");
885 PF (SEC_ELF_PURECODE
, "PURECODE");
887 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
888 PF (SEC_GROUP
, "GROUP");
889 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
891 PF (SEC_MEP_VLIW
, "VLIW");
894 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
897 struct coff_comdat_info
*comdat
;
899 switch (section
->flags
& SEC_LINK_DUPLICATES
)
903 case SEC_LINK_DUPLICATES_DISCARD
:
904 ls
= "LINK_ONCE_DISCARD";
906 case SEC_LINK_DUPLICATES_ONE_ONLY
:
907 ls
= "LINK_ONCE_ONE_ONLY";
909 case SEC_LINK_DUPLICATES_SAME_SIZE
:
910 ls
= "LINK_ONCE_SAME_SIZE";
912 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
913 ls
= "LINK_ONCE_SAME_CONTENTS";
916 printf ("%s%s", comma
, ls
);
918 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
920 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
929 /* Called on each SECTION in ABFD, update the int variable pointed to by
930 DATA which contains the string length of the longest section name. */
933 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
934 asection
*section
, void *data
)
936 int *longest_so_far
= (int *) data
;
940 /* Ignore linker created section. */
941 if (section
->flags
& SEC_LINKER_CREATED
)
944 /* Skip sections that we are ignoring. */
945 if (! process_section_p (section
))
948 name
= bfd_section_name (section
);
949 len
= (int) strlen (name
);
950 if (len
> *longest_so_far
)
951 *longest_so_far
= len
;
955 dump_headers (bfd
*abfd
)
957 /* The default width of 13 is just an arbitrary choice. */
958 int max_section_name_length
= 13;
964 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
965 if (bfd_get_arch_size (abfd
) == 32)
971 printf (_("Sections:\n"));
974 bfd_map_over_sections (abfd
, find_longest_section_name
,
975 &max_section_name_length
);
977 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
978 max_section_name_length
, "Name",
979 bfd_vma_width
, "VMA",
980 bfd_vma_width
, "LMA");
983 printf (_(" Flags"));
986 bfd_map_over_sections (abfd
, dump_section_header
,
987 &max_section_name_length
);
991 slurp_symtab (bfd
*abfd
)
996 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1002 storage
= bfd_get_symtab_upper_bound (abfd
);
1005 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
1006 bfd_fatal (_("error message was"));
1011 off_t filesize
= bfd_get_file_size (abfd
);
1015 && filesize
< storage
1016 /* The MMO file format supports its own special compression
1017 technique, so its sections can be larger than the file size. */
1018 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
1020 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
1021 _("error: symbol table size (%#lx) "
1022 "is larger than filesize (%#lx)"),
1023 storage
, (long) filesize
);
1029 sy
= (asymbol
**) xmalloc (storage
);
1032 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1034 bfd_fatal (bfd_get_filename (abfd
));
1038 /* Read in the dynamic symbols. */
1041 slurp_dynamic_symtab (bfd
*abfd
)
1043 asymbol
**sy
= NULL
;
1046 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1049 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
1051 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
1057 bfd_fatal (bfd_get_filename (abfd
));
1061 sy
= (asymbol
**) xmalloc (storage
);
1063 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
1064 if (dynsymcount
< 0)
1065 bfd_fatal (bfd_get_filename (abfd
));
1069 /* Some symbol names are significant and should be kept in the
1070 table of sorted symbol names, even if they are marked as
1071 debugging/section symbols. */
1074 is_significant_symbol_name (const char * name
)
1076 return startswith (name
, ".plt") || startswith (name
, ".got");
1079 /* Filter out (in place) symbols that are useless for disassembly.
1080 COUNT is the number of elements in SYMBOLS.
1081 Return the number of useful symbols. */
1084 remove_useless_symbols (asymbol
**symbols
, long count
)
1086 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
1088 while (--count
>= 0)
1090 asymbol
*sym
= *in_ptr
++;
1092 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
1094 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
1095 && ! is_significant_symbol_name (sym
->name
))
1097 if (bfd_is_und_section (sym
->section
)
1098 || bfd_is_com_section (sym
->section
))
1103 return out_ptr
- symbols
;
1106 static const asection
*compare_section
;
1108 /* Sort symbols into value order. */
1111 compare_symbols (const void *ap
, const void *bp
)
1113 const asymbol
*a
= * (const asymbol
**) ap
;
1114 const asymbol
*b
= * (const asymbol
**) bp
;
1119 bool as
, af
, bs
, bf
;
1123 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
1125 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
1128 /* Prefer symbols from the section currently being disassembled.
1129 Don't sort symbols from other sections by section, since there
1130 isn't much reason to prefer one section over another otherwise.
1131 See sym_ok comment for why we compare by section name. */
1132 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
1133 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
1139 an
= bfd_asymbol_name (a
);
1140 bn
= bfd_asymbol_name (b
);
1144 /* The symbols gnu_compiled and gcc2_compiled convey no real
1145 information, so put them after other symbols with the same value. */
1146 af
= (strstr (an
, "gnu_compiled") != NULL
1147 || strstr (an
, "gcc2_compiled") != NULL
);
1148 bf
= (strstr (bn
, "gnu_compiled") != NULL
1149 || strstr (bn
, "gcc2_compiled") != NULL
);
1156 /* We use a heuristic for the file name, to try to sort it after
1157 more useful symbols. It may not work on non Unix systems, but it
1158 doesn't really matter; the only difference is precisely which
1159 symbol names get printed. */
1161 #define file_symbol(s, sn, snl) \
1162 (((s)->flags & BSF_FILE) != 0 \
1164 && (sn)[(snl) - 2] == '.' \
1165 && ((sn)[(snl) - 1] == 'o' \
1166 || (sn)[(snl) - 1] == 'a')))
1168 af
= file_symbol (a
, an
, anl
);
1169 bf
= file_symbol (b
, bn
, bnl
);
1176 /* Sort function and object symbols before global symbols before
1177 local symbols before section symbols before debugging symbols. */
1182 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
1184 if ((aflags
& BSF_DEBUGGING
) != 0)
1189 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
1191 if ((aflags
& BSF_SECTION_SYM
) != 0)
1196 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
1198 if ((aflags
& BSF_FUNCTION
) != 0)
1203 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
1205 if ((aflags
& BSF_OBJECT
) != 0)
1210 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
1212 if ((aflags
& BSF_LOCAL
) != 0)
1217 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
1219 if ((aflags
& BSF_GLOBAL
) != 0)
1225 /* Sort larger size ELF symbols before smaller. See PR20337. */
1227 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
1228 && bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
)
1229 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1231 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
1232 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1233 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1235 return asz
> bsz
? -1 : 1;
1237 /* Symbols that start with '.' might be section names, so sort them
1238 after symbols that don't start with '.'. */
1239 if (an
[0] == '.' && bn
[0] != '.')
1241 if (an
[0] != '.' && bn
[0] == '.')
1244 /* Finally, if we can't distinguish them in any other way, try to
1245 get consistent results by sorting the symbols by name. */
1246 return strcmp (an
, bn
);
1249 /* Sort relocs into address order. */
1252 compare_relocs (const void *ap
, const void *bp
)
1254 const arelent
*a
= * (const arelent
**) ap
;
1255 const arelent
*b
= * (const arelent
**) bp
;
1257 if (a
->address
> b
->address
)
1259 else if (a
->address
< b
->address
)
1262 /* So that associated relocations tied to the same address show up
1263 in the correct order, we don't do any further sorting. */
1272 /* Print an address (VMA) to the output stream in INFO.
1273 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1276 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1281 struct objdump_disasm_info
*aux
;
1283 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1284 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1289 for (p
= buf
; *p
== '0'; ++p
)
1294 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "%s", p
);
1297 /* Print the name of a symbol. */
1300 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1304 const char *name
, *version_string
= NULL
;
1305 bool hidden
= false;
1308 name
= bfd_asymbol_name (sym
);
1309 if (do_demangle
&& name
[0] != '\0')
1311 /* Demangle the name. */
1312 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1317 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1318 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1321 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1324 name
= sanitize_string (name
);
1328 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s", name
);
1329 if (version_string
&& *version_string
!= '\0')
1330 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
,
1331 hidden
? "@%s" : "@@%s",
1336 printf ("%s", name
);
1337 if (version_string
&& *version_string
!= '\0')
1338 printf (hidden
? "@%s" : "@@%s", version_string
);
1346 sym_ok (bool want_section
,
1347 bfd
*abfd ATTRIBUTE_UNUSED
,
1350 struct disassemble_info
*inf
)
1354 /* NB: An object file can have different sections with the same
1355 section name. Compare compare section pointers if they have
1357 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1358 && sorted_syms
[place
]->section
!= sec
)
1361 /* Note - we cannot just compare section pointers because they could
1362 be different, but the same... Ie the symbol that we are trying to
1363 find could have come from a separate debug info file. Under such
1364 circumstances the symbol will be associated with a section in the
1365 debug info file, whilst the section we want is in a normal file.
1366 So the section pointers will be different, but the section names
1367 will be the same. */
1368 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1369 bfd_section_name (sec
)) != 0)
1373 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1376 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1377 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1378 require the symbol to be in the section. Returns NULL if there is no
1379 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1380 of the symbol in sorted_syms. */
1383 find_symbol_for_address (bfd_vma vma
,
1384 struct disassemble_info
*inf
,
1387 /* @@ Would it speed things up to cache the last two symbols returned,
1388 and maybe their address ranges? For many processors, only one memory
1389 operand can be present at a time, so the 2-entry cache wouldn't be
1390 constantly churned by code doing heavy memory accesses. */
1392 /* Indices in `sorted_syms'. */
1394 long max_count
= sorted_symcount
;
1396 struct objdump_disasm_info
*aux
;
1403 if (sorted_symcount
< 1)
1406 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1409 opb
= inf
->octets_per_byte
;
1411 /* Perform a binary search looking for the closest symbol to the
1412 required value. We are searching the range (min, max_count]. */
1413 while (min
+ 1 < max_count
)
1417 thisplace
= (max_count
+ min
) / 2;
1418 sym
= sorted_syms
[thisplace
];
1420 if (bfd_asymbol_value (sym
) > vma
)
1421 max_count
= thisplace
;
1422 else if (bfd_asymbol_value (sym
) < vma
)
1431 /* The symbol we want is now in min, the low end of the range we
1432 were searching. If there are several symbols with the same
1433 value, we want the first one. */
1435 while (thisplace
> 0
1436 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1437 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1440 /* Prefer a symbol in the current section if we have multple symbols
1441 with the same value, as can occur with overlays or zero size
1444 while (min
< max_count
1445 && (bfd_asymbol_value (sorted_syms
[min
])
1446 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1448 if (sym_ok (true, abfd
, min
, sec
, inf
))
1455 return sorted_syms
[thisplace
];
1460 /* If the file is relocatable, and the symbol could be from this
1461 section, prefer a symbol from this section over symbols from
1462 others, even if the other symbol's value might be closer.
1464 Note that this may be wrong for some symbol references if the
1465 sections have overlapping memory ranges, but in that case there's
1466 no way to tell what's desired without looking at the relocation
1469 Also give the target a chance to reject symbols. */
1470 want_section
= (aux
->require_sec
1471 || ((abfd
->flags
& HAS_RELOC
) != 0
1472 && vma
>= bfd_section_vma (sec
)
1473 && vma
< (bfd_section_vma (sec
)
1474 + bfd_section_size (sec
) / opb
)));
1476 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1479 long newplace
= sorted_symcount
;
1481 for (i
= min
- 1; i
>= 0; i
--)
1483 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1485 if (newplace
== sorted_symcount
)
1488 if (bfd_asymbol_value (sorted_syms
[i
])
1489 != bfd_asymbol_value (sorted_syms
[newplace
]))
1492 /* Remember this symbol and keep searching until we reach
1493 an earlier address. */
1498 if (newplace
!= sorted_symcount
)
1499 thisplace
= newplace
;
1502 /* We didn't find a good symbol with a smaller value.
1503 Look for one with a larger value. */
1504 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1506 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1514 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1515 /* There is no suitable symbol. */
1519 /* If we have not found an exact match for the specified address
1520 and we have dynamic relocations available, then we can produce
1521 a better result by matching a relocation to the address and
1522 using the symbol associated with that relocation. */
1523 rel_count
= inf
->dynrelcount
;
1525 && sorted_syms
[thisplace
]->value
!= vma
1527 && inf
->dynrelbuf
!= NULL
1528 && inf
->dynrelbuf
[0]->address
<= vma
1529 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1530 /* If we have matched a synthetic symbol, then stick with that. */
1531 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1534 arelent
** rel_high
;
1536 rel_low
= inf
->dynrelbuf
;
1537 rel_high
= rel_low
+ rel_count
- 1;
1538 while (rel_low
<= rel_high
)
1540 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1541 arelent
* rel
= *rel_mid
;
1543 if (rel
->address
== vma
)
1545 /* Absolute relocations do not provide a more helpful
1546 symbolic address. Find a non-absolute relocation
1547 with the same address. */
1548 arelent
**rel_vma
= rel_mid
;
1550 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1554 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1558 if (rel
->sym_ptr_ptr
!= NULL
1559 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1562 * place
= thisplace
;
1563 return * rel
->sym_ptr_ptr
;
1569 if (vma
< rel
->address
)
1571 else if (vma
>= rel_mid
[1]->address
)
1572 rel_low
= rel_mid
+ 1;
1581 return sorted_syms
[thisplace
];
1584 /* Print an address and the offset to the nearest symbol. */
1587 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1588 bfd_vma vma
, struct disassemble_info
*inf
,
1593 objdump_print_value (vma
, inf
, skip_zeroes
);
1594 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, " ");
1601 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
,"<");
1602 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s",
1603 sanitize_string (bfd_section_name (sec
)));
1604 secaddr
= bfd_section_vma (sec
);
1607 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,
1609 objdump_print_value (secaddr
- vma
, inf
, true);
1611 else if (vma
> secaddr
)
1613 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1614 objdump_print_value (vma
- secaddr
, inf
, true);
1616 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1620 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, "<");
1622 objdump_print_symname (abfd
, inf
, sym
);
1624 if (bfd_asymbol_value (sym
) == vma
)
1626 /* Undefined symbols in an executables and dynamic objects do not have
1627 a value associated with them, so it does not make sense to display
1628 an offset relative to them. Normally we would not be provided with
1629 this kind of symbol, but the target backend might choose to do so,
1630 and the code in find_symbol_for_address might return an as yet
1631 unresolved symbol associated with a dynamic reloc. */
1632 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1633 && bfd_is_und_section (sym
->section
))
1635 else if (bfd_asymbol_value (sym
) > vma
)
1637 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,"-0x");
1638 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1640 else if (vma
> bfd_asymbol_value (sym
))
1642 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1643 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1646 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1649 if (display_file_offsets
)
1650 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1651 _(" (File Offset: 0x%lx)"),
1652 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1655 /* Print an address (VMA), symbolically if possible.
1656 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1659 objdump_print_addr (bfd_vma vma
,
1660 struct disassemble_info
*inf
,
1663 struct objdump_disasm_info
*aux
;
1664 asymbol
*sym
= NULL
;
1665 bool skip_find
= false;
1667 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1669 if (sorted_symcount
< 1)
1673 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "0x");
1674 objdump_print_value (vma
, inf
, skip_zeroes
);
1677 if (display_file_offsets
)
1678 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1679 _(" (File Offset: 0x%lx)"),
1680 (long int) (inf
->section
->filepos
1681 + (vma
- inf
->section
->vma
)));
1685 if (aux
->reloc
!= NULL
1686 && aux
->reloc
->sym_ptr_ptr
!= NULL
1687 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1689 sym
= * aux
->reloc
->sym_ptr_ptr
;
1691 /* Adjust the vma to the reloc. */
1692 vma
+= bfd_asymbol_value (sym
);
1694 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1699 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1701 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1705 /* Print VMA to INFO. This function is passed to the disassembler
1709 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1711 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1714 /* Determine if the given address has a symbol associated with it. */
1717 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1721 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1722 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1728 /* Hold the last function name and the last line number we displayed
1729 in a disassembly. */
1731 static char *prev_functionname
;
1732 static unsigned int prev_line
;
1733 static unsigned int prev_discriminator
;
1735 /* We keep a list of all files that we have seen when doing a
1736 disassembly with source, so that we know how much of the file to
1737 display. This can be important for inlined functions. */
1739 struct print_file_list
1741 struct print_file_list
*next
;
1742 const char *filename
;
1743 const char *modname
;
1746 const char **linemap
;
1749 unsigned max_printed
;
1753 static struct print_file_list
*print_files
;
1755 /* The number of preceding context lines to show when we start
1756 displaying a file for the first time. */
1758 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1760 #if HAVE_LIBDEBUGINFOD
1761 /* Return a hex string represention of the build-id. */
1764 get_build_id (void * data
)
1767 char * build_id_str
;
1768 bfd
* abfd
= (bfd
*) data
;
1769 const struct bfd_build_id
* build_id
;
1771 build_id
= abfd
->build_id
;
1772 if (build_id
== NULL
)
1775 build_id_str
= malloc (build_id
->size
* 2 + 1);
1776 if (build_id_str
== NULL
)
1779 for (i
= 0; i
< build_id
->size
; i
++)
1780 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
1781 build_id_str
[build_id
->size
* 2] = '\0';
1783 return (unsigned char *) build_id_str
;
1786 /* Search for a separate debug file matching ABFD's build-id. */
1789 find_separate_debug (const bfd
* abfd
)
1791 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1792 separate_info
* i
= first_separate_info
;
1794 if (build_id
== NULL
|| i
== NULL
)
1799 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1801 if (abfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1803 const unsigned char * data
= i_bfd
->build_id
->data
;
1804 size_t size
= i_bfd
->build_id
->size
;
1806 if (size
== build_id
->size
1807 && memcmp (data
, build_id
->data
, size
) == 0)
1808 return (bfd
*) i
->handle
;
1817 /* Search for a separate debug file matching ABFD's .gnu_debugaltlink
1821 find_alt_debug (const bfd
* abfd
)
1826 struct dwarf_section
* section
;
1827 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1828 separate_info
* i
= first_separate_info
;
1832 || !load_debug_section (gnu_debugaltlink
, (void *) abfd
))
1835 section
= &debug_displays
[gnu_debugaltlink
].section
;
1836 if (section
== NULL
)
1839 name
= (const char *) section
->start
;
1840 namelen
= strnlen (name
, section
->size
) + 1;
1843 if (namelen
>= section
->size
)
1846 id_len
= section
->size
- namelen
;
1850 /* Compare the .gnu_debugaltlink build-id with the build-ids of the
1851 known separate_info files. */
1854 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1856 if (i_bfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1858 const unsigned char * data
= i_bfd
->build_id
->data
;
1859 size_t size
= i_bfd
->build_id
->size
;
1862 && memcmp (section
->start
+ namelen
, data
, size
) == 0)
1863 return (bfd
*) i
->handle
;
1872 #endif /* HAVE_LIBDEBUGINFOD */
1874 /* Reads the contents of file FN into memory. Returns a pointer to the buffer.
1875 Also returns the size of the buffer in SIZE_RETURN and a filled out
1876 stat structure in FST_RETURN. Returns NULL upon failure. */
1879 slurp_file (const char * fn
,
1880 size_t * size_return
,
1881 struct stat
* fst_return
,
1882 bfd
* abfd ATTRIBUTE_UNUSED
)
1892 if (fn
== NULL
|| * fn
== 0 || size_return
== NULL
|| fst_return
== NULL
)
1895 fd
= open (fn
, O_RDONLY
| O_BINARY
);
1897 #if HAVE_LIBDEBUGINFOD
1898 if (fd
< 0 && use_debuginfod
&& fn
[0] == '/' && abfd
!= NULL
)
1900 unsigned char *build_id
= get_build_id (abfd
);
1904 debuginfod_client
*client
= debuginfod_begin ();
1908 fd
= debuginfod_find_source (client
, build_id
, 0, fn
, NULL
);
1909 debuginfod_end (client
);
1919 if (fstat (fd
, fst_return
) < 0)
1925 *size_return
= fst_return
->st_size
;
1928 ps
= getpagesize ();
1929 msize
= (*size_return
+ ps
- 1) & ~(ps
- 1);
1930 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1931 if (map
!= (char *) -1L)
1938 map
= (const char *) malloc (*size_return
);
1939 if (!map
|| (size_t) read (fd
, (char *) map
, *size_return
) != *size_return
)
1941 free ((void *) map
);
1948 #define line_map_decrease 5
1950 /* Precompute array of lines for a mapped file. */
1952 static const char **
1953 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1955 const char *p
, *lstart
, *end
;
1956 int chars_per_line
= 45; /* First iteration will use 40. */
1957 unsigned int lineno
;
1958 const char **linemap
= NULL
;
1959 unsigned long line_map_size
= 0;
1965 for (p
= map
; p
< end
; p
++)
1969 if (p
+ 1 < end
&& p
[1] == '\r')
1972 else if (*p
== '\r')
1974 if (p
+ 1 < end
&& p
[1] == '\n')
1980 /* End of line found. */
1982 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1984 unsigned long newsize
;
1986 chars_per_line
-= line_map_decrease
;
1987 if (chars_per_line
<= 1)
1989 line_map_size
= size
/ chars_per_line
+ 1;
1990 if (line_map_size
< lineno
+ 1)
1991 line_map_size
= lineno
+ 1;
1992 newsize
= line_map_size
* sizeof (char *);
1993 linemap
= (const char **) xrealloc (linemap
, newsize
);
1996 linemap
[lineno
++] = lstart
;
2004 /* Tries to open MODNAME, and if successful adds a node to print_files
2005 linked list and returns that node. Also fills in the stat structure
2006 pointed to by FST_RETURN. Returns NULL on failure. */
2008 static struct print_file_list
*
2009 try_print_file_open (const char * origname
,
2010 const char * modname
,
2011 struct stat
* fst_return
,
2014 struct print_file_list
*p
;
2016 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
2018 p
->map
= slurp_file (modname
, &p
->mapsize
, fst_return
, abfd
);
2025 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
2028 p
->filename
= origname
;
2029 p
->modname
= modname
;
2030 p
->next
= print_files
;
2036 /* If the source file, as described in the symtab, is not found
2037 try to locate it in one of the paths specified with -I
2038 If found, add location to print_files linked list. */
2040 static struct print_file_list
*
2041 update_source_path (const char *filename
, bfd
*abfd
)
2043 struct print_file_list
*p
;
2048 p
= try_print_file_open (filename
, filename
, &fst
, abfd
);
2051 if (include_path_count
== 0)
2054 /* Get the name of the file. */
2055 fname
= lbasename (filename
);
2057 /* If file exists under a new path, we need to add it to the list
2058 so that show_line knows about it. */
2059 for (i
= 0; i
< include_path_count
; i
++)
2061 char *modname
= concat (include_paths
[i
], "/", fname
,
2064 p
= try_print_file_open (filename
, modname
, &fst
, abfd
);
2074 long mtime
= bfd_get_mtime (abfd
);
2076 if (fst
.st_mtime
> mtime
)
2077 warn (_("source file %s is more recent than object file\n"),
2084 /* Print a source file line. */
2087 print_line (struct print_file_list
*p
, unsigned int linenum
)
2092 if (linenum
>= p
->maxline
)
2094 l
= p
->linemap
[linenum
];
2095 if (source_comment
!= NULL
&& strlen (l
) > 0)
2096 printf ("%s", source_comment
);
2097 len
= strcspn (l
, "\n\r");
2098 /* Test fwrite return value to quiet glibc warning. */
2099 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
2103 /* Print a range of source code lines. */
2106 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
2114 print_line (p
, start
);
2119 /* Show the line number, or the source line, in a disassembly
2123 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
2125 const char *filename
;
2126 const char *functionname
;
2127 unsigned int linenumber
;
2128 unsigned int discriminator
;
2132 if (! with_line_numbers
&& ! with_source_code
)
2135 #ifdef HAVE_LIBDEBUGINFOD
2138 const char *alt_filename
= NULL
;
2144 /* PR 29075: Check for separate debuginfo and .gnu_debugaltlink files.
2145 They need to be passed to bfd_find_nearest_line_with_alt in case they
2146 were downloaded from debuginfod. Otherwise libbfd will attempt to
2147 search for them and fail to locate them. */
2148 debug_bfd
= find_separate_debug (abfd
);
2149 if (debug_bfd
== NULL
)
2152 alt_bfd
= find_alt_debug (debug_bfd
);
2153 if (alt_bfd
!= NULL
)
2154 alt_filename
= bfd_get_filename (alt_bfd
);
2159 bfd_set_error (bfd_error_no_error
);
2160 if (! bfd_find_nearest_line_with_alt (debug_bfd
, alt_filename
,
2162 addr_offset
, &filename
,
2163 &functionname
, &linenumber
,
2166 if (bfd_get_error () == bfd_error_no_error
)
2168 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
,
2169 addr_offset
, &filename
,
2170 &functionname
, &linenumber
,
2176 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
2177 &filename
, &functionname
,
2178 &linenumber
, &discriminator
))
2182 if (filename
!= NULL
&& *filename
== '\0')
2184 if (functionname
!= NULL
&& *functionname
== '\0')
2185 functionname
= NULL
;
2188 && IS_ABSOLUTE_PATH (filename
)
2192 const char *fname
= filename
;
2194 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
2197 memcpy (path
, prefix
, prefix_length
);
2198 path_up
= path
+ prefix_length
;
2200 /* Build relocated filename, stripping off leading directories
2201 from the initial filename if requested. */
2202 if (prefix_strip
> 0)
2207 /* Skip selected directory levels. */
2208 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
2209 if (IS_DIR_SEPARATOR (*s
))
2216 /* Update complete filename. */
2217 strcpy (path_up
, fname
);
2225 if (with_line_numbers
)
2227 if (functionname
!= NULL
2228 && (prev_functionname
== NULL
2229 || strcmp (functionname
, prev_functionname
) != 0))
2231 char *demangle_alloc
= NULL
;
2232 if (do_demangle
&& functionname
[0] != '\0')
2234 /* Demangle the name. */
2235 demangle_alloc
= bfd_demangle (abfd
, functionname
,
2239 /* Demangling adds trailing parens, so don't print those. */
2240 if (demangle_alloc
!= NULL
)
2241 printf ("%s:\n", sanitize_string (demangle_alloc
));
2243 printf ("%s():\n", sanitize_string (functionname
));
2246 free (demangle_alloc
);
2249 && (linenumber
!= prev_line
2250 || discriminator
!= prev_discriminator
))
2252 if (discriminator
> 0)
2253 printf ("%s:%u (discriminator %u)\n",
2254 filename
== NULL
? "???" : sanitize_string (filename
),
2255 linenumber
, discriminator
);
2257 printf ("%s:%u\n", filename
== NULL
2258 ? "???" : sanitize_string (filename
),
2263 const char *filename2
;
2264 const char *functionname2
;
2267 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2270 printf ("inlined by %s:%u",
2271 sanitize_string (filename2
), line2
);
2272 printf (" (%s)\n", sanitize_string (functionname2
));
2277 if (with_source_code
2281 struct print_file_list
**pp
, *p
;
2284 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2285 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2292 filename
= xstrdup (filename
);
2293 p
= update_source_path (filename
, abfd
);
2296 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2298 if (file_start_context
&& p
->first
)
2302 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2303 if (l
>= linenumber
)
2305 if (p
->max_printed
>= l
)
2307 if (p
->max_printed
< linenumber
)
2308 l
= p
->max_printed
+ 1;
2313 dump_lines (p
, l
, linenumber
);
2314 if (p
->max_printed
< linenumber
)
2315 p
->max_printed
= linenumber
;
2316 p
->last_line
= linenumber
;
2321 if (functionname
!= NULL
2322 && (prev_functionname
== NULL
2323 || strcmp (functionname
, prev_functionname
) != 0))
2325 if (prev_functionname
!= NULL
)
2326 free (prev_functionname
);
2327 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2328 strcpy (prev_functionname
, functionname
);
2331 if (linenumber
> 0 && linenumber
!= prev_line
)
2332 prev_line
= linenumber
;
2334 if (discriminator
!= prev_discriminator
)
2335 prev_discriminator
= discriminator
;
2341 /* Pseudo FILE object for strings. */
2349 /* sprintf to a "stream". */
2351 static int ATTRIBUTE_PRINTF_2
2352 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2359 size_t space
= f
->alloc
- f
->pos
;
2361 va_start (args
, format
);
2362 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2368 f
->alloc
= (f
->alloc
+ n
) * 2;
2369 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2376 /* Return an integer greater than, or equal to zero, representing the color
2377 for STYLE, or -1 if no color should be used. */
2380 objdump_color_for_disassembler_style (enum disassembler_style style
)
2384 if (style
== dis_style_comment_start
)
2385 disassembler_in_comment
= true;
2387 if (disassembler_color
== on
)
2389 if (disassembler_in_comment
)
2394 case dis_style_symbol
:
2397 case dis_style_assembler_directive
:
2398 case dis_style_sub_mnemonic
:
2399 case dis_style_mnemonic
:
2402 case dis_style_register
:
2405 case dis_style_address
:
2406 case dis_style_address_offset
:
2407 case dis_style_immediate
:
2411 case dis_style_text
:
2416 else if (disassembler_color
== extended
)
2418 if (disassembler_in_comment
)
2423 case dis_style_symbol
:
2426 case dis_style_assembler_directive
:
2427 case dis_style_sub_mnemonic
:
2428 case dis_style_mnemonic
:
2431 case dis_style_register
:
2434 case dis_style_address
:
2435 case dis_style_address_offset
:
2436 case dis_style_immediate
:
2440 case dis_style_text
:
2445 else if (disassembler_color
!= off
)
2446 bfd_fatal (_("disassembly color not correctly selected"));
2451 /* Like objdump_sprintf, but add in escape sequences to highlight the
2452 content according to STYLE. */
2454 static int ATTRIBUTE_PRINTF_3
2455 objdump_styled_sprintf (SFILE
*f
, enum disassembler_style style
,
2456 const char *format
, ...)
2460 int color
= objdump_color_for_disassembler_style (style
);
2466 size_t space
= f
->alloc
- f
->pos
;
2468 if (disassembler_color
== on
)
2469 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[%dm", color
);
2471 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[38;5;%dm", color
);
2475 f
->alloc
= (f
->alloc
+ n
) * 2;
2476 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2483 size_t space
= f
->alloc
- f
->pos
;
2485 va_start (args
, format
);
2486 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2492 f
->alloc
= (f
->alloc
+ n
) * 2;
2493 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2501 size_t space
= f
->alloc
- f
->pos
;
2503 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[0m");
2508 f
->alloc
= (f
->alloc
+ n
) * 2;
2509 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2517 /* We discard the styling information here. This function is only used
2518 when objdump is printing auxiliary information, the symbol headers, and
2519 disassembly address, or the bytes of the disassembled instruction. We
2520 don't (currently) apply styling to any of this stuff, so, for now, just
2521 print the content with no additional style added. */
2523 static int ATTRIBUTE_PRINTF_3
2524 fprintf_styled (FILE *f
, enum disassembler_style style ATTRIBUTE_UNUSED
,
2525 const char *fmt
, ...)
2531 res
= vfprintf (f
, fmt
, ap
);
2537 /* Code for generating (colored) diagrams of control flow start and end
2540 /* Structure used to store the properties of a jump. */
2544 /* The next jump, or NULL if this is the last object. */
2545 struct jump_info
*next
;
2546 /* The previous jump, or NULL if this is the first object. */
2547 struct jump_info
*prev
;
2548 /* The start addresses of the jump. */
2551 /* The list of start addresses. */
2553 /* The number of elements. */
2555 /* The maximum number of elements that fit into the array. */
2558 /* The end address of the jump. */
2560 /* The drawing level of the jump. */
2564 /* Construct a jump object for a jump from start
2565 to end with the corresponding level. */
2567 static struct jump_info
*
2568 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2570 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2572 result
->next
= NULL
;
2573 result
->prev
= NULL
;
2574 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2575 result
->start
.addresses
[0] = start
;
2576 result
->start
.count
= 1;
2577 result
->start
.max_count
= 2;
2579 result
->level
= level
;
2584 /* Free a jump object and return the next object
2585 or NULL if this was the last one. */
2587 static struct jump_info
*
2588 jump_info_free (struct jump_info
*ji
)
2590 struct jump_info
*result
= NULL
;
2595 if (ji
->start
.addresses
)
2596 free (ji
->start
.addresses
);
2603 /* Get the smallest value of all start and end addresses. */
2606 jump_info_min_address (const struct jump_info
*ji
)
2608 bfd_vma min_address
= ji
->end
;
2611 for (i
= ji
->start
.count
; i
-- > 0;)
2612 if (ji
->start
.addresses
[i
] < min_address
)
2613 min_address
= ji
->start
.addresses
[i
];
2617 /* Get the largest value of all start and end addresses. */
2620 jump_info_max_address (const struct jump_info
*ji
)
2622 bfd_vma max_address
= ji
->end
;
2625 for (i
= ji
->start
.count
; i
-- > 0;)
2626 if (ji
->start
.addresses
[i
] > max_address
)
2627 max_address
= ji
->start
.addresses
[i
];
2631 /* Get the target address of a jump. */
2634 jump_info_end_address (const struct jump_info
*ji
)
2639 /* Test if an address is one of the start addresses of a jump. */
2642 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2644 bool result
= false;
2647 for (i
= ji
->start
.count
; i
-- > 0;)
2648 if (address
== ji
->start
.addresses
[i
])
2657 /* Test if an address is the target address of a jump. */
2660 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2662 return (address
== ji
->end
);
2665 /* Get the difference between the smallest and largest address of a jump. */
2668 jump_info_size (const struct jump_info
*ji
)
2670 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2673 /* Unlink a jump object from a list. */
2676 jump_info_unlink (struct jump_info
*node
,
2677 struct jump_info
**base
)
2680 node
->next
->prev
= node
->prev
;
2682 node
->prev
->next
= node
->next
;
2689 /* Insert unlinked jump info node into a list. */
2692 jump_info_insert (struct jump_info
*node
,
2693 struct jump_info
*target
,
2694 struct jump_info
**base
)
2696 node
->next
= target
;
2697 node
->prev
= target
->prev
;
2698 target
->prev
= node
;
2700 node
->prev
->next
= node
;
2705 /* Add unlinked node to the front of a list. */
2708 jump_info_add_front (struct jump_info
*node
,
2709 struct jump_info
**base
)
2713 node
->next
->prev
= node
;
2718 /* Move linked node to target position. */
2721 jump_info_move_linked (struct jump_info
*node
,
2722 struct jump_info
*target
,
2723 struct jump_info
**base
)
2726 jump_info_unlink (node
, base
);
2727 /* Insert node at target position. */
2728 jump_info_insert (node
, target
, base
);
2731 /* Test if two jumps intersect. */
2734 jump_info_intersect (const struct jump_info
*a
,
2735 const struct jump_info
*b
)
2737 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2738 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2741 /* Merge two compatible jump info objects. */
2744 jump_info_merge (struct jump_info
**base
)
2746 struct jump_info
*a
;
2748 for (a
= *base
; a
; a
= a
->next
)
2750 struct jump_info
*b
;
2752 for (b
= a
->next
; b
; b
= b
->next
)
2754 /* Merge both jumps into one. */
2755 if (a
->end
== b
->end
)
2757 /* Reallocate addresses. */
2758 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2761 if (needed_size
> a
->start
.max_count
)
2763 a
->start
.max_count
+= b
->start
.max_count
;
2764 a
->start
.addresses
=
2765 xrealloc (a
->start
.addresses
,
2766 a
->start
.max_count
* sizeof (bfd_vma
*));
2769 /* Append start addresses. */
2770 for (i
= 0; i
< b
->start
.count
; ++i
)
2771 a
->start
.addresses
[a
->start
.count
++] =
2772 b
->start
.addresses
[i
];
2774 /* Remove and delete jump. */
2775 struct jump_info
*tmp
= b
->prev
;
2776 jump_info_unlink (b
, base
);
2784 /* Sort jumps by their size and starting point using a stable
2785 minsort. This could be improved if sorting performance is
2786 an issue, for example by using mergesort. */
2789 jump_info_sort (struct jump_info
**base
)
2791 struct jump_info
*current_element
= *base
;
2793 while (current_element
)
2795 struct jump_info
*best_match
= current_element
;
2796 struct jump_info
*runner
= current_element
->next
;
2797 bfd_vma best_size
= jump_info_size (best_match
);
2801 bfd_vma runner_size
= jump_info_size (runner
);
2803 if ((runner_size
< best_size
)
2804 || ((runner_size
== best_size
)
2805 && (jump_info_min_address (runner
)
2806 < jump_info_min_address (best_match
))))
2808 best_match
= runner
;
2809 best_size
= runner_size
;
2812 runner
= runner
->next
;
2815 if (best_match
== current_element
)
2816 current_element
= current_element
->next
;
2818 jump_info_move_linked (best_match
, current_element
, base
);
2822 /* Visualize all jumps at a given address. */
2825 jump_info_visualize_address (bfd_vma address
,
2828 uint8_t *color_buffer
)
2830 struct jump_info
*ji
= detected_jumps
;
2831 size_t len
= (max_level
+ 1) * 3;
2833 /* Clear line buffer. */
2834 memset (line_buffer
, ' ', len
);
2835 memset (color_buffer
, 0, len
);
2837 /* Iterate over jumps and add their ASCII art. */
2840 /* Discard jumps that are never needed again. */
2841 if (jump_info_max_address (ji
) < address
)
2843 struct jump_info
*tmp
= ji
;
2846 jump_info_unlink (tmp
, &detected_jumps
);
2847 jump_info_free (tmp
);
2851 /* This jump intersects with the current address. */
2852 if (jump_info_min_address (ji
) <= address
)
2854 /* Hash target address to get an even
2855 distribution between all values. */
2856 bfd_vma hash_address
= jump_info_end_address (ji
);
2857 uint8_t color
= iterative_hash_object (hash_address
, 0);
2858 /* Fetch line offset. */
2859 int offset
= (max_level
- ji
->level
) * 3;
2861 /* Draw start line. */
2862 if (jump_info_is_start_address (ji
, address
))
2864 size_t i
= offset
+ 1;
2866 for (; i
< len
- 1; ++i
)
2867 if (line_buffer
[i
] == ' ')
2869 line_buffer
[i
] = '-';
2870 color_buffer
[i
] = color
;
2873 if (line_buffer
[i
] == ' ')
2875 line_buffer
[i
] = '-';
2876 color_buffer
[i
] = color
;
2878 else if (line_buffer
[i
] == '>')
2880 line_buffer
[i
] = 'X';
2881 color_buffer
[i
] = color
;
2884 if (line_buffer
[offset
] == ' ')
2886 if (address
<= ji
->end
)
2887 line_buffer
[offset
] =
2888 (jump_info_min_address (ji
) == address
) ? '/': '+';
2890 line_buffer
[offset
] =
2891 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2892 color_buffer
[offset
] = color
;
2895 /* Draw jump target. */
2896 else if (jump_info_is_end_address (ji
, address
))
2898 size_t i
= offset
+ 1;
2900 for (; i
< len
- 1; ++i
)
2901 if (line_buffer
[i
] == ' ')
2903 line_buffer
[i
] = '-';
2904 color_buffer
[i
] = color
;
2907 if (line_buffer
[i
] == ' ')
2909 line_buffer
[i
] = '>';
2910 color_buffer
[i
] = color
;
2912 else if (line_buffer
[i
] == '-')
2914 line_buffer
[i
] = 'X';
2915 color_buffer
[i
] = color
;
2918 if (line_buffer
[offset
] == ' ')
2920 if (jump_info_min_address (ji
) < address
)
2921 line_buffer
[offset
] =
2922 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2924 line_buffer
[offset
] = '/';
2925 color_buffer
[offset
] = color
;
2928 /* Draw intermediate line segment. */
2929 else if (line_buffer
[offset
] == ' ')
2931 line_buffer
[offset
] = '|';
2932 color_buffer
[offset
] = color
;
2940 /* Clone of disassemble_bytes to detect jumps inside a function. */
2941 /* FIXME: is this correct? Can we strip it down even further? */
2943 static struct jump_info
*
2944 disassemble_jumps (struct disassemble_info
* inf
,
2945 disassembler_ftype disassemble_fn
,
2946 bfd_vma start_offset
,
2947 bfd_vma stop_offset
,
2950 arelent
** relppend
)
2952 struct objdump_disasm_info
*aux
;
2953 struct jump_info
*jumps
= NULL
;
2955 bfd_vma addr_offset
;
2956 unsigned int opb
= inf
->octets_per_byte
;
2960 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2961 section
= inf
->section
;
2964 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2967 inf
->insn_info_valid
= 0;
2968 disassemble_set_printf (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
2969 (fprintf_styled_ftype
) objdump_styled_sprintf
);
2971 addr_offset
= start_offset
;
2972 while (addr_offset
< stop_offset
)
2974 int previous_octets
;
2976 /* Remember the length of the previous instruction. */
2977 previous_octets
= octets
;
2981 inf
->bytes_per_line
= 0;
2982 inf
->bytes_per_chunk
= 0;
2983 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2984 | (wide_output
? WIDE_OUTPUT
: 0));
2986 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2988 if (inf
->disassembler_needs_relocs
2989 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2990 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2991 && *relppp
< relppend
)
2993 bfd_signed_vma distance_to_rel
;
2995 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2997 /* Check to see if the current reloc is associated with
2998 the instruction that we are about to disassemble. */
2999 if (distance_to_rel
== 0
3000 /* FIXME: This is wrong. We are trying to catch
3001 relocs that are addressed part way through the
3002 current instruction, as might happen with a packed
3003 VLIW instruction. Unfortunately we do not know the
3004 length of the current instruction since we have not
3005 disassembled it yet. Instead we take a guess based
3006 upon the length of the previous instruction. The
3007 proper solution is to have a new target-specific
3008 disassembler function which just returns the length
3009 of an instruction at a given address without trying
3010 to display its disassembly. */
3011 || (distance_to_rel
> 0
3012 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
3014 inf
->flags
|= INSN_HAS_RELOC
;
3018 if (! disassemble_all
3019 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3020 == (SEC_CODE
| SEC_HAS_CONTENTS
))
3021 /* Set a stop_vma so that the disassembler will not read
3022 beyond the next symbol. We assume that symbols appear on
3023 the boundaries between instructions. We only do this when
3024 disassembling code of course, and when -D is in effect. */
3025 inf
->stop_vma
= section
->vma
+ stop_offset
;
3027 inf
->stop_offset
= stop_offset
;
3029 /* Extract jump information. */
3030 inf
->insn_info_valid
= 0;
3031 disassembler_in_comment
= false;
3032 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3033 /* Test if a jump was detected. */
3034 if (inf
->insn_info_valid
3035 && ((inf
->insn_type
== dis_branch
)
3036 || (inf
->insn_type
== dis_condbranch
)
3037 || (inf
->insn_type
== dis_jsr
)
3038 || (inf
->insn_type
== dis_condjsr
))
3039 && (inf
->target
>= section
->vma
+ start_offset
)
3040 && (inf
->target
< section
->vma
+ stop_offset
))
3042 struct jump_info
*ji
=
3043 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
3044 jump_info_add_front (ji
, &jumps
);
3049 addr_offset
+= octets
/ opb
;
3052 disassemble_set_printf (inf
, (void *) stdout
, (fprintf_ftype
) fprintf
,
3053 (fprintf_styled_ftype
) fprintf_styled
);
3054 free (sfile
.buffer
);
3057 jump_info_merge (&jumps
);
3058 /* Process jumps. */
3059 jump_info_sort (&jumps
);
3061 /* Group jumps by level. */
3062 struct jump_info
*last_jump
= jumps
;
3067 /* The last jump is part of the next group. */
3068 struct jump_info
*base
= last_jump
;
3069 /* Increment level. */
3070 base
->level
= ++max_level
;
3072 /* Find jumps that can be combined on the same
3073 level, with the largest jumps tested first.
3074 This has the advantage that large jumps are on
3075 lower levels and do not intersect with small
3076 jumps that get grouped on higher levels. */
3077 struct jump_info
*exchange_item
= last_jump
->next
;
3078 struct jump_info
*it
= exchange_item
;
3080 for (; it
; it
= it
->next
)
3082 /* Test if the jump intersects with any
3083 jump from current group. */
3085 struct jump_info
*it_collision
;
3087 for (it_collision
= base
;
3088 it_collision
!= exchange_item
;
3089 it_collision
= it_collision
->next
)
3091 /* This jump intersects so we leave it out. */
3092 if (jump_info_intersect (it_collision
, it
))
3099 /* Add jump to group. */
3102 /* Move current element to the front. */
3103 if (it
!= exchange_item
)
3105 struct jump_info
*save
= it
->prev
;
3106 jump_info_move_linked (it
, exchange_item
, &jumps
);
3112 last_jump
= exchange_item
;
3113 exchange_item
= exchange_item
->next
;
3115 last_jump
->level
= max_level
;
3119 /* Move to next group. */
3120 last_jump
= exchange_item
;
3126 /* The number of zeroes we want to see before we start skipping them.
3127 The number is arbitrarily chosen. */
3129 #define DEFAULT_SKIP_ZEROES 8
3131 /* The number of zeroes to skip at the end of a section. If the
3132 number of zeroes at the end is between SKIP_ZEROES_AT_END and
3133 SKIP_ZEROES, they will be disassembled. If there are fewer than
3134 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
3135 attempt to avoid disassembling zeroes inserted by section
3138 #define DEFAULT_SKIP_ZEROES_AT_END 3
3141 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
3146 /* Like null_print, but takes the extra STYLE argument. As this is not
3147 going to print anything, the extra argument is just ignored. */
3150 null_styled_print (const void * stream ATTRIBUTE_UNUSED
,
3151 enum disassembler_style style ATTRIBUTE_UNUSED
,
3152 const char * format ATTRIBUTE_UNUSED
, ...)
3157 /* Print out jump visualization. */
3160 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
3161 uint8_t *color_buffer
)
3166 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
3168 size_t line_buffer_size
= strlen (line_buffer
);
3169 char last_color
= 0;
3172 for (i
= 0; i
<= line_buffer_size
; ++i
)
3176 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
3178 if (color
!= last_color
)
3181 if (extended_color_output
)
3182 /* Use extended 8bit color, but
3183 do not choose dark colors. */
3184 printf ("\033[38;5;%dm", 124 + (color
% 108));
3186 /* Use simple terminal colors. */
3187 printf ("\033[%dm", 31 + (color
% 7));
3194 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
3198 /* Disassemble some data in memory between given values. */
3201 disassemble_bytes (struct disassemble_info
*inf
,
3202 disassembler_ftype disassemble_fn
,
3205 bfd_vma start_offset
,
3206 bfd_vma stop_offset
,
3211 struct objdump_disasm_info
*aux
;
3213 unsigned int octets_per_line
;
3214 unsigned int skip_addr_chars
;
3215 bfd_vma addr_offset
;
3216 unsigned int opb
= inf
->octets_per_byte
;
3217 unsigned int skip_zeroes
= inf
->skip_zeroes
;
3218 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
3222 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
3223 section
= inf
->section
;
3226 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
3230 octets_per_line
= insn_width
;
3232 octets_per_line
= 4;
3234 octets_per_line
= 16;
3236 /* Figure out how many characters to skip at the start of an
3237 address, to make the disassembly look nicer. We discard leading
3238 zeroes in chunks of 4, ensuring that there is always a leading
3240 skip_addr_chars
= 0;
3241 if (!no_addresses
&& !prefix_addresses
)
3245 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
3247 while (buf
[skip_addr_chars
] == '0')
3250 /* Don't discard zeros on overflow. */
3251 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
3252 skip_addr_chars
= 0;
3254 if (skip_addr_chars
!= 0)
3255 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
3258 inf
->insn_info_valid
= 0;
3260 /* Determine maximum level. */
3261 uint8_t *color_buffer
= NULL
;
3262 char *line_buffer
= NULL
;
3265 /* Some jumps were detected. */
3268 struct jump_info
*ji
;
3270 /* Find maximum jump level. */
3271 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
3273 if (ji
->level
> max_level
)
3274 max_level
= ji
->level
;
3277 /* Allocate buffers. */
3278 size_t len
= (max_level
+ 1) * 3 + 1;
3279 line_buffer
= xmalloc (len
);
3280 line_buffer
[len
- 1] = 0;
3281 color_buffer
= xmalloc (len
);
3282 color_buffer
[len
- 1] = 0;
3285 addr_offset
= start_offset
;
3286 while (addr_offset
< stop_offset
)
3288 bool need_nl
= false;
3292 /* Make sure we don't use relocs from previous instructions. */
3295 /* If we see more than SKIP_ZEROES octets of zeroes, we just
3297 if (! disassemble_zeroes
)
3298 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
3299 if (data
[addr_offset
* opb
+ octets
] != 0)
3301 if (! disassemble_zeroes
3302 && (inf
->insn_info_valid
== 0
3303 || inf
->branch_delay_insns
== 0)
3304 && (octets
>= skip_zeroes
3305 || (addr_offset
* opb
+ octets
== stop_offset
* opb
3306 && octets
< skip_zeroes_at_end
)))
3308 /* If there are more nonzero octets to follow, we only skip
3309 zeroes in multiples of 4, to try to avoid running over
3310 the start of an instruction which happens to start with
3312 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
3315 /* If we are going to display more data, and we are displaying
3316 file offsets, then tell the user how many zeroes we skip
3317 and the file offset from where we resume dumping. */
3318 if (display_file_offsets
3319 && addr_offset
+ octets
/ opb
< stop_offset
)
3320 printf (_("\t... (skipping %lu zeroes, "
3321 "resuming at file offset: 0x%lx)\n"),
3322 (unsigned long) (octets
/ opb
),
3323 (unsigned long) (section
->filepos
3324 + addr_offset
+ octets
/ opb
));
3331 unsigned int bpc
= 0;
3332 unsigned int pb
= 0;
3334 if (with_line_numbers
|| with_source_code
)
3335 show_line (aux
->abfd
, section
, addr_offset
);
3339 else if (!prefix_addresses
)
3343 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
3344 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3348 printf ("%s:\t", buf
+ skip_addr_chars
);
3352 aux
->require_sec
= true;
3353 objdump_print_address (section
->vma
+ addr_offset
, inf
);
3354 aux
->require_sec
= false;
3358 print_jump_visualisation (section
->vma
+ addr_offset
,
3359 max_level
, line_buffer
,
3367 disassemble_set_printf
3368 (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
3369 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3370 inf
->bytes_per_line
= 0;
3371 inf
->bytes_per_chunk
= 0;
3372 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
3373 | (wide_output
? WIDE_OUTPUT
: 0));
3375 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
3377 if (inf
->disassembler_needs_relocs
3378 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
3379 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
3380 && *relppp
< relppend
)
3382 bfd_signed_vma distance_to_rel
;
3383 int max_reloc_offset
3384 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
3386 distance_to_rel
= ((**relppp
)->address
- rel_offset
3390 if (distance_to_rel
> 0
3391 && (max_reloc_offset
< 0
3392 || distance_to_rel
<= max_reloc_offset
))
3394 /* This reloc *might* apply to the current insn,
3395 starting somewhere inside it. Discover the length
3396 of the current insn so that the check below will
3399 insn_size
= insn_width
;
3402 /* We find the length by calling the dissassembler
3403 function with a dummy print handler. This should
3404 work unless the disassembler is not expecting to
3405 be called multiple times for the same address.
3407 This does mean disassembling the instruction
3408 twice, but we only do this when there is a high
3409 probability that there is a reloc that will
3410 affect the instruction. */
3411 disassemble_set_printf
3412 (inf
, inf
->stream
, (fprintf_ftype
) null_print
,
3413 (fprintf_styled_ftype
) null_styled_print
);
3414 insn_size
= disassemble_fn (section
->vma
3415 + addr_offset
, inf
);
3416 disassemble_set_printf
3418 (fprintf_ftype
) objdump_sprintf
,
3419 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3423 /* Check to see if the current reloc is associated with
3424 the instruction that we are about to disassemble. */
3425 if (distance_to_rel
== 0
3426 || (distance_to_rel
> 0
3427 && distance_to_rel
< insn_size
/ (int) opb
))
3429 inf
->flags
|= INSN_HAS_RELOC
;
3430 aux
->reloc
= **relppp
;
3434 if (! disassemble_all
3435 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3436 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3437 /* Set a stop_vma so that the disassembler will not read
3438 beyond the next symbol. We assume that symbols appear on
3439 the boundaries between instructions. We only do this when
3440 disassembling code of course, and when -D is in effect. */
3441 inf
->stop_vma
= section
->vma
+ stop_offset
;
3443 inf
->stop_offset
= stop_offset
;
3444 disassembler_in_comment
= false;
3445 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3449 disassemble_set_printf (inf
, stdout
, (fprintf_ftype
) fprintf
,
3450 (fprintf_styled_ftype
) fprintf_styled
);
3451 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3452 octets_per_line
= inf
->bytes_per_line
;
3453 if (insn_size
< (int) opb
)
3456 printf ("%s\n", sfile
.buffer
);
3459 non_fatal (_("disassemble_fn returned length %d"),
3470 octets
= octets_per_line
;
3471 if (addr_offset
+ octets
/ opb
> stop_offset
)
3472 octets
= (stop_offset
- addr_offset
) * opb
;
3474 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3476 if (ISPRINT (data
[j
]))
3477 buf
[j
- addr_offset
* opb
] = data
[j
];
3479 buf
[j
- addr_offset
* opb
] = '.';
3481 buf
[j
- addr_offset
* opb
] = '\0';
3484 if (prefix_addresses
3486 : show_raw_insn
>= 0)
3490 /* If ! prefix_addresses and ! wide_output, we print
3491 octets_per_line octets per line. */
3493 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3494 pb
= octets_per_line
;
3496 if (inf
->bytes_per_chunk
)
3497 bpc
= inf
->bytes_per_chunk
;
3501 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3503 /* PR 21580: Check for a buffer ending early. */
3504 if (j
+ bpc
<= stop_offset
* opb
)
3508 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3510 for (k
= bpc
; k
-- != 0; )
3511 printf ("%02x", (unsigned) data
[j
+ k
]);
3515 for (k
= 0; k
< bpc
; k
++)
3516 printf ("%02x", (unsigned) data
[j
+ k
]);
3522 for (; pb
< octets_per_line
; pb
+= bpc
)
3526 for (k
= 0; k
< bpc
; k
++)
3531 /* Separate raw data from instruction by extra space. */
3541 printf ("%s", sfile
.buffer
);
3543 if (prefix_addresses
3545 : show_raw_insn
>= 0)
3553 j
= addr_offset
* opb
+ pb
;
3559 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3560 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3564 printf ("%s:\t", buf
+ skip_addr_chars
);
3567 print_jump_visualisation (section
->vma
+ j
/ opb
,
3568 max_level
, line_buffer
,
3571 pb
+= octets_per_line
;
3574 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3576 /* PR 21619: Check for a buffer ending early. */
3577 if (j
+ bpc
<= stop_offset
* opb
)
3581 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3583 for (k
= bpc
; k
-- != 0; )
3584 printf ("%02x", (unsigned) data
[j
+ k
]);
3588 for (k
= 0; k
< bpc
; k
++)
3589 printf ("%02x", (unsigned) data
[j
+ k
]);
3603 while ((*relppp
) < relppend
3604 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3606 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3619 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3624 if (q
->howto
== NULL
)
3625 printf ("*unknown*\t");
3626 else if (q
->howto
->name
)
3627 printf ("%s\t", q
->howto
->name
);
3629 printf ("%d\t", q
->howto
->type
);
3631 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3632 printf ("*unknown*");
3635 const char *sym_name
;
3637 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3638 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3639 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3644 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3645 sym_name
= bfd_section_name (sym_sec
);
3646 if (sym_name
== NULL
|| *sym_name
== '\0')
3647 sym_name
= "*unknown*";
3648 printf ("%s", sanitize_string (sym_name
));
3654 bfd_vma addend
= q
->addend
;
3655 if ((bfd_signed_vma
) addend
< 0)
3662 objdump_print_value (addend
, inf
, true);
3674 addr_offset
+= octets
/ opb
;
3677 free (sfile
.buffer
);
3679 free (color_buffer
);
3683 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3685 const struct elf_backend_data
*bed
;
3686 bfd_vma sign_adjust
= 0;
3687 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3688 struct objdump_disasm_info
*paux
;
3689 unsigned int opb
= pinfo
->octets_per_byte
;
3690 bfd_byte
*data
= NULL
;
3691 bfd_size_type datasize
= 0;
3692 arelent
**rel_pp
= NULL
;
3693 arelent
**rel_ppstart
= NULL
;
3694 arelent
**rel_ppend
;
3695 bfd_vma stop_offset
;
3696 asymbol
*sym
= NULL
;
3700 unsigned long addr_offset
;
3704 stop_offset_reached
,
3709 /* Sections that do not contain machine
3710 code are not normally disassembled. */
3711 if (! disassemble_all
3712 && only_list
== NULL
3713 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3714 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3717 if (! process_section_p (section
))
3720 datasize
= bfd_section_size (section
);
3724 if (start_address
== (bfd_vma
) -1
3725 || start_address
< section
->vma
)
3728 addr_offset
= start_address
- section
->vma
;
3730 if (stop_address
== (bfd_vma
) -1)
3731 stop_offset
= datasize
/ opb
;
3734 if (stop_address
< section
->vma
)
3737 stop_offset
= stop_address
- section
->vma
;
3738 if (stop_offset
> datasize
/ opb
)
3739 stop_offset
= datasize
/ opb
;
3742 if (addr_offset
>= stop_offset
)
3745 /* Decide which set of relocs to use. Load them if necessary. */
3746 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3747 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3749 rel_pp
= pinfo
->dynrelbuf
;
3750 rel_count
= pinfo
->dynrelcount
;
3751 /* Dynamic reloc addresses are absolute, non-dynamic are section
3752 relative. REL_OFFSET specifies the reloc address corresponding
3753 to the start of this section. */
3754 rel_offset
= section
->vma
;
3762 if ((section
->flags
& SEC_RELOC
) != 0
3763 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3767 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3769 bfd_fatal (bfd_get_filename (abfd
));
3773 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3774 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3776 bfd_fatal (bfd_get_filename (abfd
));
3778 /* Sort the relocs by address. */
3779 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3783 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3785 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3787 non_fatal (_("Reading section %s failed because: %s"),
3788 section
->name
, bfd_errmsg (bfd_get_error ()));
3792 pinfo
->buffer
= data
;
3793 pinfo
->buffer_vma
= section
->vma
;
3794 pinfo
->buffer_length
= datasize
;
3795 pinfo
->section
= section
;
3797 /* Sort the symbols into value and section order. */
3798 compare_section
= section
;
3799 if (sorted_symcount
> 1)
3800 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3802 /* Skip over the relocs belonging to addresses below the
3804 while (rel_pp
< rel_ppend
3805 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3808 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3810 /* Find the nearest symbol forwards from our current position. */
3811 paux
->require_sec
= true;
3812 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3813 (struct disassemble_info
*) inf
,
3815 paux
->require_sec
= false;
3817 /* PR 9774: If the target used signed addresses then we must make
3818 sure that we sign extend the value that we calculate for 'addr'
3819 in the loop below. */
3820 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3821 && (bed
= get_elf_backend_data (abfd
)) != NULL
3822 && bed
->sign_extend_vma
)
3823 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3825 /* Disassemble a block of instructions up to the address associated with
3826 the symbol we have just found. Then print the symbol and find the
3827 next symbol on. Repeat until we have disassembled the entire section
3828 or we have reached the end of the address range we are interested in. */
3829 do_print
= paux
->symbol
== NULL
;
3830 loop_until
= stop_offset_reached
;
3832 while (addr_offset
< stop_offset
)
3836 bfd_vma nextstop_offset
;
3839 addr
= section
->vma
+ addr_offset
;
3840 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3842 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3847 (x
< sorted_symcount
3848 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3852 pinfo
->symbols
= sorted_syms
+ place
;
3853 pinfo
->num_symbols
= x
- place
;
3854 pinfo
->symtab_pos
= place
;
3858 pinfo
->symbols
= NULL
;
3859 pinfo
->num_symbols
= 0;
3860 pinfo
->symtab_pos
= -1;
3863 /* If we are only disassembling from a specific symbol,
3864 check to see if we should start or stop displaying. */
3865 if (sym
&& paux
->symbol
)
3869 /* See if we should stop printing. */
3873 if (sym
->flags
& BSF_FUNCTION
)
3877 case stop_offset_reached
:
3878 /* Handled by the while loop. */
3882 /* FIXME: There is an implicit assumption here
3883 that the name of sym is different from
3885 if (! bfd_is_local_label (abfd
, sym
))
3892 const char * name
= bfd_asymbol_name (sym
);
3893 char * alloc
= NULL
;
3895 if (do_demangle
&& name
[0] != '\0')
3897 /* Demangle the name. */
3898 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3903 /* We are not currently printing. Check to see
3904 if the current symbol matches the requested symbol. */
3905 if (streq (name
, paux
->symbol
))
3909 if (sym
->flags
& BSF_FUNCTION
)
3911 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3912 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3914 /* Sym is a function symbol with a size associated
3915 with it. Turn on automatic disassembly for the
3916 next VALUE bytes. */
3917 stop_offset
= addr_offset
3918 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3919 loop_until
= stop_offset_reached
;
3923 /* Otherwise we need to tell the loop heuristic to
3924 loop until the next function symbol is encountered. */
3925 loop_until
= function_sym
;
3930 /* Otherwise loop until the next symbol is encountered. */
3931 loop_until
= next_sym
;
3939 if (! prefix_addresses
&& do_print
)
3941 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3942 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3944 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3947 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3949 else if (sym
== NULL
)
3953 #define is_valid_next_sym(SYM) \
3954 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3955 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3956 && pinfo->symbol_is_valid (SYM, pinfo))
3958 /* Search forward for the next appropriate symbol in
3959 SECTION. Note that all the symbols are sorted
3960 together into one big array, and that some sections
3961 may have overlapping addresses. */
3962 while (place
< sorted_symcount
3963 && ! is_valid_next_sym (sorted_syms
[place
]))
3966 if (place
>= sorted_symcount
)
3969 nextsym
= sorted_syms
[place
];
3972 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3973 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3974 else if (nextsym
== NULL
)
3975 nextstop_offset
= stop_offset
;
3977 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3979 if (nextstop_offset
> stop_offset
3980 || nextstop_offset
<= addr_offset
)
3981 nextstop_offset
= stop_offset
;
3983 /* If a symbol is explicitly marked as being an object
3984 rather than a function, just dump the bytes without
3985 disassembling them. */
3988 || sym
->section
!= section
3989 || bfd_asymbol_value (sym
) > addr
3990 || ((sym
->flags
& BSF_OBJECT
) == 0
3991 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3993 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3995 || (sym
->flags
& BSF_FUNCTION
) != 0)
4002 /* Resolve symbol name. */
4003 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
4005 struct disassemble_info di
;
4008 sf
.alloc
= strlen (sym
->name
) + 40;
4009 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
4011 disassemble_set_printf
4012 (&di
, &sf
, (fprintf_ftype
) objdump_sprintf
,
4013 (fprintf_styled_ftype
) objdump_styled_sprintf
);
4015 objdump_print_symname (abfd
, &di
, sym
);
4017 /* Fetch jump information. */
4018 detected_jumps
= disassemble_jumps
4019 (pinfo
, paux
->disassemble_fn
,
4020 addr_offset
, nextstop_offset
,
4021 rel_offset
, &rel_pp
, rel_ppend
);
4023 /* Free symbol name. */
4027 /* Add jumps to output. */
4028 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
4029 addr_offset
, nextstop_offset
,
4030 rel_offset
, &rel_pp
, rel_ppend
);
4033 while (detected_jumps
)
4035 detected_jumps
= jump_info_free (detected_jumps
);
4039 addr_offset
= nextstop_offset
;
4045 if (rel_ppstart
!= NULL
)
4049 /* Disassemble the contents of an object file. */
4052 disassemble_data (bfd
*abfd
)
4054 struct disassemble_info disasm_info
;
4055 struct objdump_disasm_info aux
;
4059 prev_functionname
= NULL
;
4061 prev_discriminator
= 0;
4063 /* We make a copy of syms to sort. We don't want to sort syms
4064 because that will screw up the relocs. */
4065 sorted_symcount
= symcount
? symcount
: dynsymcount
;
4066 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
4067 * sizeof (asymbol
*));
4068 if (sorted_symcount
!= 0)
4070 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
4071 sorted_symcount
* sizeof (asymbol
*));
4073 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
4076 for (i
= 0; i
< synthcount
; ++i
)
4078 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
4082 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
,
4083 (fprintf_styled_ftype
) fprintf_styled
);
4084 disasm_info
.application_data
= (void *) &aux
;
4086 aux
.require_sec
= false;
4087 disasm_info
.dynrelbuf
= NULL
;
4088 disasm_info
.dynrelcount
= 0;
4090 aux
.symbol
= disasm_sym
;
4092 disasm_info
.print_address_func
= objdump_print_address
;
4093 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
4095 if (machine
!= NULL
)
4097 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
4100 fatal (_("can't use supplied machine %s"), machine
);
4102 abfd
->arch_info
= inf
;
4105 if (endian
!= BFD_ENDIAN_UNKNOWN
)
4107 struct bfd_target
*xvec
;
4109 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
4110 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
4111 xvec
->byteorder
= endian
;
4115 /* Use libopcodes to locate a suitable disassembler. */
4116 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
4117 bfd_big_endian (abfd
),
4118 bfd_get_mach (abfd
), abfd
);
4119 if (!aux
.disassemble_fn
)
4121 non_fatal (_("can't disassemble for architecture %s\n"),
4122 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
4127 disasm_info
.flavour
= bfd_get_flavour (abfd
);
4128 disasm_info
.arch
= bfd_get_arch (abfd
);
4129 disasm_info
.mach
= bfd_get_mach (abfd
);
4130 disasm_info
.disassembler_options
= disassembler_options
;
4131 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
4132 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
4133 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
4134 disasm_info
.disassembler_needs_relocs
= false;
4136 if (bfd_big_endian (abfd
))
4137 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
4138 else if (bfd_little_endian (abfd
))
4139 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
4141 /* ??? Aborting here seems too drastic. We could default to big or little
4143 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
4145 disasm_info
.endian_code
= disasm_info
.endian
;
4147 /* Allow the target to customize the info structure. */
4148 disassemble_init_for_target (& disasm_info
);
4150 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
4151 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4153 if (relsize
< 0 && dump_dynamic_reloc_info
)
4154 bfd_fatal (bfd_get_filename (abfd
));
4158 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
4159 disasm_info
.dynrelcount
4160 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
4161 if (disasm_info
.dynrelcount
< 0)
4162 bfd_fatal (bfd_get_filename (abfd
));
4164 /* Sort the relocs by address. */
4165 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
4169 disasm_info
.symtab
= sorted_syms
;
4170 disasm_info
.symtab_size
= sorted_symcount
;
4172 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
4174 free (disasm_info
.dynrelbuf
);
4175 disasm_info
.dynrelbuf
= NULL
;
4177 disassemble_free_target (&disasm_info
);
4181 load_specific_debug_section (enum dwarf_section_display_enum debug
,
4182 asection
*sec
, void *file
)
4184 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4185 bfd
*abfd
= (bfd
*) file
;
4191 if (section
->start
!= NULL
)
4193 /* If it is already loaded, do nothing. */
4194 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4196 free (section
->start
);
4199 section
->filename
= bfd_get_filename (abfd
);
4200 section
->reloc_info
= NULL
;
4201 section
->num_relocs
= 0;
4202 section
->address
= bfd_section_vma (sec
);
4203 section
->size
= bfd_section_size (sec
);
4204 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
4205 alloced
= amt
= section
->size
+ 1;
4206 if (alloced
!= amt
|| alloced
== 0)
4208 section
->start
= NULL
;
4209 free_debug_section (debug
);
4210 printf (_("\nSection '%s' has an invalid size: %#" PRIx64
".\n"),
4211 sanitize_string (section
->name
),
4216 section
->start
= contents
= xmalloc (alloced
);
4217 /* Ensure any string section has a terminating NUL. */
4218 section
->start
[section
->size
] = 0;
4220 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4221 && debug_displays
[debug
].relocate
)
4223 ret
= bfd_simple_get_relocated_section_contents (abfd
,
4229 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
4236 relocs
= (arelent
**) xmalloc (reloc_size
);
4238 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, syms
);
4239 if (reloc_count
<= 0)
4243 section
->reloc_info
= relocs
;
4244 section
->num_relocs
= reloc_count
;
4250 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
4254 free_debug_section (debug
);
4255 printf (_("\nCan't get contents for section '%s'.\n"),
4256 sanitize_string (section
->name
));
4264 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
4269 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
4272 relocs
= (arelent
**) dsec
->reloc_info
;
4274 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
4275 if (rp
->address
== offset
)
4282 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
4284 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4285 bfd
*abfd
= (bfd
*) file
;
4289 if (!dump_any_debugging
)
4292 /* If it is already loaded, do nothing. */
4293 if (section
->start
!= NULL
)
4295 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4298 /* Locate the debug section. */
4299 name
= section
->uncompressed_name
;
4300 sec
= bfd_get_section_by_name (abfd
, name
);
4303 name
= section
->compressed_name
;
4305 sec
= bfd_get_section_by_name (abfd
, name
);
4309 name
= section
->xcoff_name
;
4311 sec
= bfd_get_section_by_name (abfd
, name
);
4316 section
->name
= name
;
4317 return load_specific_debug_section (debug
, sec
, file
);
4321 free_debug_section (enum dwarf_section_display_enum debug
)
4323 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4325 free ((char *) section
->start
);
4326 section
->start
= NULL
;
4327 section
->address
= 0;
4329 free ((char*) section
->reloc_info
);
4330 section
->reloc_info
= NULL
;
4331 section
->num_relocs
= 0;
4335 close_debug_file (void * file
)
4337 bfd
* abfd
= (bfd
*) file
;
4343 open_debug_file (const char * pathname
)
4347 data
= bfd_openr (pathname
, NULL
);
4351 if (! bfd_check_format (data
, bfd_object
))
4358 dump_dwarf_section (bfd
*abfd
, asection
*section
,
4361 const char *name
= bfd_section_name (section
);
4364 bool is_mainfile
= *(bool *) arg
;
4369 if (!is_mainfile
&& !process_links
4370 && (section
->flags
& SEC_DEBUGGING
) == 0)
4373 if (startswith (name
, ".gnu.linkonce.wi."))
4374 match
= ".debug_info";
4378 for (i
= 0; i
< max
; i
++)
4379 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
4380 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
4381 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
4382 && debug_displays
[i
].enabled
!= NULL
4383 && *debug_displays
[i
].enabled
)
4385 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
4387 if (strcmp (sec
->uncompressed_name
, match
) == 0)
4388 sec
->name
= sec
->uncompressed_name
;
4389 else if (strcmp (sec
->compressed_name
, match
) == 0)
4390 sec
->name
= sec
->compressed_name
;
4392 sec
->name
= sec
->xcoff_name
;
4393 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
4396 debug_displays
[i
].display (sec
, abfd
);
4398 if (i
!= info
&& i
!= abbrev
)
4399 free_debug_section ((enum dwarf_section_display_enum
) i
);
4405 /* Dump the dwarf debugging information. */
4408 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4410 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4411 if (byte_get
== NULL
)
4413 warn (_("File %s does not contain any dwarf debug information\n"),
4414 bfd_get_filename (abfd
));
4418 switch (bfd_get_arch (abfd
))
4421 /* S12Z has a 24 bit address space. But the only known
4422 producer of dwarf_info encodes addresses into 32 bits. */
4427 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4431 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4432 bfd_get_mach (abfd
));
4434 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4437 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
4438 it. Return NULL on failure. */
4441 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4442 bfd_size_type
*entsize_ptr
)
4447 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
4448 if (stabsect
== NULL
)
4450 printf (_("No %s section present\n\n"),
4451 sanitize_string (sect_name
));
4455 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
4457 non_fatal (_("reading %s section of %s failed: %s"),
4458 sect_name
, bfd_get_filename (abfd
),
4459 bfd_errmsg (bfd_get_error ()));
4465 *size_ptr
= bfd_section_size (stabsect
);
4467 *entsize_ptr
= stabsect
->entsize
;
4472 /* Stabs entries use a 12 byte format:
4473 4 byte string table index
4475 1 byte stab other field
4476 2 byte stab desc field
4478 FIXME: This will have to change for a 64 bit object format. */
4480 #define STRDXOFF (0)
4482 #define OTHEROFF (5)
4485 #define STABSIZE (12)
4487 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4488 using string table section STRSECT_NAME (in `strtab'). */
4491 print_section_stabs (bfd
*abfd
,
4492 const char *stabsect_name
,
4493 unsigned *string_offset_ptr
)
4496 unsigned file_string_table_offset
= 0;
4497 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4498 bfd_byte
*stabp
, *stabs_end
;
4501 stabs_end
= stabp
+ stab_size
;
4503 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4504 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4506 /* Loop through all symbols and print them.
4508 We start the index at -1 because there is a dummy symbol on
4509 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4510 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
4514 unsigned char type
, other
;
4515 unsigned short desc
;
4518 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4519 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4520 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4521 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4522 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4524 printf ("\n%-6d ", i
);
4525 /* Either print the stab name, or, if unnamed, print its number
4526 again (makes consistent formatting for tools like awk). */
4527 name
= bfd_get_stab_name (type
);
4529 printf ("%-6s", sanitize_string (name
));
4530 else if (type
== N_UNDF
)
4533 printf ("%-6d", type
);
4534 printf (" %-6d %-6d ", other
, desc
);
4535 bfd_printf_vma (abfd
, value
);
4536 printf (" %-6lu", strx
);
4538 /* Symbols with type == 0 (N_UNDF) specify the length of the
4539 string table associated with this file. We use that info
4540 to know how to relocate the *next* file's string table indices. */
4543 file_string_table_offset
= next_file_string_table_offset
;
4544 next_file_string_table_offset
+= value
;
4548 bfd_size_type amt
= strx
+ file_string_table_offset
;
4550 /* Using the (possibly updated) string table offset, print the
4551 string (if any) associated with this symbol. */
4552 if (amt
< stabstr_size
)
4553 /* PR 17512: file: 079-79389-0.001:0.1.
4554 FIXME: May need to sanitize this string before displaying. */
4555 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4561 *string_offset_ptr
= next_file_string_table_offset
;
4566 const char * section_name
;
4567 const char * string_section_name
;
4568 unsigned string_offset
;
4573 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4576 stab_section_names
* sought
= (stab_section_names
*) names
;
4578 /* Check for section names for which stabsect_name is a prefix, to
4579 handle .stab.N, etc. */
4580 len
= strlen (sought
->section_name
);
4582 /* If the prefix matches, and the files section name ends with a
4583 nul or a digit, then we match. I.e., we want either an exact
4584 match or a section followed by a number. */
4585 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4586 && (section
->name
[len
] == 0
4587 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4590 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
4591 &stabstr_size
, NULL
);
4595 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
4597 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4603 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4605 stab_section_names s
;
4607 s
.section_name
= stabsect_name
;
4608 s
.string_section_name
= strsect_name
;
4609 s
.string_offset
= 0;
4611 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4617 /* Dump the any sections containing stabs debugging information. */
4620 dump_stabs (bfd
*abfd
)
4622 dump_stabs_section (abfd
, ".stab", ".stabstr");
4623 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4624 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4627 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4629 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4633 dump_bfd_header (bfd
*abfd
)
4637 printf (_("architecture: %s, "),
4638 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4639 bfd_get_mach (abfd
)));
4640 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4642 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4643 PF (HAS_RELOC
, "HAS_RELOC");
4644 PF (EXEC_P
, "EXEC_P");
4645 PF (HAS_LINENO
, "HAS_LINENO");
4646 PF (HAS_DEBUG
, "HAS_DEBUG");
4647 PF (HAS_SYMS
, "HAS_SYMS");
4648 PF (HAS_LOCALS
, "HAS_LOCALS");
4649 PF (DYNAMIC
, "DYNAMIC");
4650 PF (WP_TEXT
, "WP_TEXT");
4651 PF (D_PAGED
, "D_PAGED");
4652 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4653 printf (_("\nstart address 0x"));
4654 bfd_printf_vma (abfd
, abfd
->start_address
);
4659 #ifdef ENABLE_LIBCTF
4660 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4661 it is passed, or a pointer to newly-allocated storage, in which case
4662 dump_ctf() will free it when it no longer needs it. */
4665 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4668 const char *blanks
= arg
;
4671 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4676 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4678 make_ctfsect (const char *name
, bfd_byte
*data
,
4683 ctfsect
.cts_name
= name
;
4684 ctfsect
.cts_entsize
= 1;
4685 ctfsect
.cts_size
= size
;
4686 ctfsect
.cts_data
= data
;
4691 /* Dump CTF errors/warnings. */
4693 dump_ctf_errs (ctf_dict_t
*fp
)
4695 ctf_next_t
*it
= NULL
;
4700 /* Dump accumulated errors and warnings. */
4701 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4703 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4707 if (err
!= ECTF_NEXT_END
)
4709 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4714 /* Dump one CTF archive member. */
4717 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4720 const char *things
[] = {"Header", "Labels", "Data objects",
4721 "Function objects", "Variables", "Types", "Strings",
4726 /* Don't print out the name of the default-named archive member if it appears
4727 first in the list. The name .ctf appears everywhere, even for things that
4728 aren't really archives, so printing it out is liable to be confusing; also,
4729 the common case by far is for only one archive member to exist, and hiding
4730 it in that case seems worthwhile. */
4732 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4733 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4735 if (ctf_parent_name (ctf
) != NULL
)
4736 ctf_import (ctf
, parent
);
4738 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4740 ctf_dump_state_t
*s
= NULL
;
4743 printf ("\n %s:\n", *thing
);
4744 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4745 (void *) " ")) != NULL
)
4747 printf ("%s\n", item
);
4751 if (ctf_errno (ctf
))
4753 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4754 ctf_errmsg (ctf_errno (ctf
)));
4759 dump_ctf_errs (ctf
);
4762 /* Dump the CTF debugging information. */
4765 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4767 ctf_archive_t
*ctfa
= NULL
;
4768 bfd_byte
*ctfdata
= NULL
;
4769 bfd_size_type ctfsize
;
4773 ctf_next_t
*i
= NULL
;
4778 if (sect_name
== NULL
)
4781 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4782 bfd_fatal (bfd_get_filename (abfd
));
4784 /* Load the CTF file and dump it. Preload the parent dict, since it will
4785 need to be imported into every child in turn. */
4787 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4788 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4790 dump_ctf_errs (NULL
);
4791 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4792 bfd_fatal (bfd_get_filename (abfd
));
4795 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4797 dump_ctf_errs (NULL
);
4798 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4799 bfd_fatal (bfd_get_filename (abfd
));
4802 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4804 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4805 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4806 if (err
!= ECTF_NEXT_END
)
4808 dump_ctf_errs (NULL
);
4809 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4810 bfd_fatal (bfd_get_filename (abfd
));
4812 ctf_dict_close (parent
);
4818 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4819 const char *parent_name ATTRIBUTE_UNUSED
) {}
4823 read_section_sframe (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4824 bfd_vma
*sframe_vma
)
4826 asection
*sframe_sect
;
4829 sframe_sect
= bfd_get_section_by_name (abfd
, sect_name
);
4830 if (sframe_sect
== NULL
)
4832 printf (_("No %s section present\n\n"),
4833 sanitize_string (sect_name
));
4837 if (!bfd_malloc_and_get_section (abfd
, sframe_sect
, &contents
))
4839 non_fatal (_("reading %s section of %s failed: %s"),
4840 sect_name
, bfd_get_filename (abfd
),
4841 bfd_errmsg (bfd_get_error ()));
4847 *size_ptr
= bfd_section_size (sframe_sect
);
4848 *sframe_vma
= bfd_section_vma (sframe_sect
);
4854 dump_section_sframe (bfd
*abfd ATTRIBUTE_UNUSED
,
4855 const char * sect_name
)
4857 sframe_decoder_ctx
*sfd_ctx
= NULL
;
4858 bfd_size_type sf_size
;
4859 bfd_byte
*sframe_data
= NULL
;
4863 if (sect_name
== NULL
)
4864 sect_name
= ".sframe";
4866 sframe_data
= read_section_sframe (abfd
, sect_name
, &sf_size
, &sf_vma
);
4868 if (sframe_data
== NULL
)
4869 bfd_fatal (bfd_get_filename (abfd
));
4871 /* Decode the contents of the section. */
4872 sfd_ctx
= sframe_decode ((const char*)sframe_data
, sf_size
, &err
);
4876 bfd_fatal (bfd_get_filename (abfd
));
4879 printf (_("Contents of the SFrame section %s:"),
4880 sanitize_string (sect_name
));
4881 /* Dump the contents as text. */
4882 dump_sframe (sfd_ctx
, sf_vma
);
4885 sframe_decoder_free (&sfd_ctx
);
4890 dump_bfd_private_header (bfd
*abfd
)
4892 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4893 non_fatal (_("warning: private headers incomplete: %s"),
4894 bfd_errmsg (bfd_get_error ()));
4898 dump_target_specific (bfd
*abfd
)
4900 const struct objdump_private_desc
* const *desc
;
4901 struct objdump_private_option
*opt
;
4904 /* Find the desc. */
4905 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4906 if ((*desc
)->filter (abfd
))
4911 non_fatal (_("option -P/--private not supported by this file"));
4915 /* Clear all options. */
4916 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4917 opt
->selected
= false;
4919 /* Decode options. */
4920 b
= dump_private_options
;
4923 e
= strchr (b
, ',');
4928 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4929 if (strcmp (opt
->name
, b
) == 0)
4931 opt
->selected
= true;
4934 if (opt
->name
== NULL
)
4935 non_fatal (_("target specific dump '%s' not supported"), b
);
4946 (*desc
)->dump (abfd
);
4949 /* Display a section in hexadecimal format with associated characters.
4950 Each line prefixed by the zero padded address. */
4953 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4955 bfd_byte
*data
= NULL
;
4956 bfd_size_type datasize
;
4957 bfd_vma addr_offset
;
4958 bfd_vma start_offset
;
4959 bfd_vma stop_offset
;
4960 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4961 /* Bytes per line. */
4962 const int onaline
= 16;
4967 if (! process_section_p (section
))
4970 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4973 if ((datasize
= bfd_section_size (section
)) == 0)
4976 /* Compute the address range to display. */
4977 if (start_address
== (bfd_vma
) -1
4978 || start_address
< section
->vma
)
4981 start_offset
= start_address
- section
->vma
;
4983 if (stop_address
== (bfd_vma
) -1)
4984 stop_offset
= datasize
/ opb
;
4987 if (stop_address
< section
->vma
)
4990 stop_offset
= stop_address
- section
->vma
;
4992 if (stop_offset
> datasize
/ opb
)
4993 stop_offset
= datasize
/ opb
;
4996 if (start_offset
>= stop_offset
)
4999 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
5000 if (display_file_offsets
)
5001 printf (_(" (Starting at file offset: 0x%lx)"),
5002 (unsigned long) (section
->filepos
+ start_offset
));
5005 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
5007 non_fatal (_("Reading section %s failed because: %s"),
5008 section
->name
, bfd_errmsg (bfd_get_error ()));
5014 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
5015 if (strlen (buf
) >= sizeof (buf
))
5019 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5021 count
= strlen (buf
) - count
;
5025 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
5026 if (strlen (buf
) >= sizeof (buf
))
5030 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5032 count
= strlen (buf
) - count
;
5036 for (addr_offset
= start_offset
;
5037 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
5041 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
5042 count
= strlen (buf
);
5043 if ((size_t) count
>= sizeof (buf
))
5047 while (count
< width
)
5052 fputs (buf
+ count
- width
, stdout
);
5055 for (j
= addr_offset
* opb
;
5056 j
< addr_offset
* opb
+ onaline
; j
++)
5058 if (j
< stop_offset
* opb
)
5059 printf ("%02x", (unsigned) (data
[j
]));
5067 for (j
= addr_offset
* opb
;
5068 j
< addr_offset
* opb
+ onaline
; j
++)
5070 if (j
>= stop_offset
* opb
)
5073 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
5080 /* Actually display the various requested regions. */
5083 dump_data (bfd
*abfd
)
5085 bfd_map_over_sections (abfd
, dump_section
, NULL
);
5088 /* Should perhaps share code and display with nm? */
5091 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
5100 max_count
= dynsymcount
;
5101 printf ("DYNAMIC SYMBOL TABLE:\n");
5106 max_count
= symcount
;
5107 printf ("SYMBOL TABLE:\n");
5111 printf (_("no symbols\n"));
5113 for (count
= 0; count
< max_count
; count
++)
5117 if (*current
== NULL
)
5118 printf (_("no information for symbol number %ld\n"), count
);
5120 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
5121 printf (_("could not determine the type of symbol number %ld\n"),
5124 else if (process_section_p ((* current
)->section
)
5125 && (dump_special_syms
5126 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
5128 const char *name
= (*current
)->name
;
5130 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
5134 /* If we want to demangle the name, we demangle it
5135 here, and temporarily clobber it while calling
5136 bfd_print_symbol. FIXME: This is a gross hack. */
5137 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
5139 (*current
)->name
= alloc
;
5140 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5141 bfd_print_symbol_all
);
5144 (*current
)->name
= name
;
5148 else if (unicode_display
!= unicode_default
5149 && name
!= NULL
&& *name
!= '\0')
5151 const char * sanitized_name
;
5153 /* If we want to sanitize the name, we do it here, and
5154 temporarily clobber it while calling bfd_print_symbol.
5155 FIXME: This is a gross hack. */
5156 sanitized_name
= sanitize_string (name
);
5157 if (sanitized_name
!= name
)
5158 (*current
)->name
= sanitized_name
;
5160 sanitized_name
= NULL
;
5161 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5162 bfd_print_symbol_all
);
5163 if (sanitized_name
!= NULL
)
5164 (*current
)->name
= name
;
5167 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5168 bfd_print_symbol_all
);
5178 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
5181 char *last_filename
, *last_functionname
;
5182 unsigned int last_line
;
5183 unsigned int last_discriminator
;
5185 /* Get column headers lined up reasonably. */
5193 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
5194 width
= strlen (buf
) - 7;
5196 printf ("OFFSET %*s TYPE %*s VALUE\n", width
, "", 12, "");
5199 last_filename
= NULL
;
5200 last_functionname
= NULL
;
5202 last_discriminator
= 0;
5204 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
5207 const char *filename
, *functionname
;
5208 unsigned int linenumber
;
5209 unsigned int discriminator
;
5210 const char *sym_name
;
5211 const char *section_name
;
5212 bfd_vma addend2
= 0;
5214 if (start_address
!= (bfd_vma
) -1
5215 && q
->address
< start_address
)
5217 if (stop_address
!= (bfd_vma
) -1
5218 && q
->address
> stop_address
)
5221 if (with_line_numbers
5223 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
5224 &filename
, &functionname
,
5225 &linenumber
, &discriminator
))
5227 if (functionname
!= NULL
5228 && (last_functionname
== NULL
5229 || strcmp (functionname
, last_functionname
) != 0))
5231 printf ("%s():\n", sanitize_string (functionname
));
5232 if (last_functionname
!= NULL
)
5233 free (last_functionname
);
5234 last_functionname
= xstrdup (functionname
);
5238 && (linenumber
!= last_line
5239 || (filename
!= NULL
5240 && last_filename
!= NULL
5241 && filename_cmp (filename
, last_filename
) != 0)
5242 || (discriminator
!= last_discriminator
)))
5244 if (discriminator
> 0)
5245 printf ("%s:%u\n", filename
== NULL
? "???" :
5246 sanitize_string (filename
), linenumber
);
5248 printf ("%s:%u (discriminator %u)\n",
5249 filename
== NULL
? "???" : sanitize_string (filename
),
5250 linenumber
, discriminator
);
5251 last_line
= linenumber
;
5252 last_discriminator
= discriminator
;
5253 if (last_filename
!= NULL
)
5254 free (last_filename
);
5255 if (filename
== NULL
)
5256 last_filename
= NULL
;
5258 last_filename
= xstrdup (filename
);
5262 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
5264 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
5265 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
5270 section_name
= NULL
;
5273 bfd_printf_vma (abfd
, q
->address
);
5274 if (q
->howto
== NULL
)
5275 printf (" *unknown* ");
5276 else if (q
->howto
->name
)
5278 const char *name
= q
->howto
->name
;
5280 /* R_SPARC_OLO10 relocations contain two addends.
5281 But because 'arelent' lacks enough storage to
5282 store them both, the 64-bit ELF Sparc backend
5283 records this as two relocations. One R_SPARC_LO10
5284 and one R_SPARC_13, both pointing to the same
5285 address. This is merely so that we have some
5286 place to store both addend fields.
5288 Undo this transformation, otherwise the output
5289 will be confusing. */
5290 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
5291 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
5293 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
5295 arelent
*q2
= *(p
+ 1);
5298 && q
->address
== q2
->address
5299 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
5301 name
= "R_SPARC_OLO10";
5302 addend2
= q2
->addend
;
5306 printf (" %-16s ", name
);
5309 printf (" %-16d ", q
->howto
->type
);
5313 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
5317 if (section_name
== NULL
)
5318 section_name
= "*unknown*";
5319 printf ("[%s]", sanitize_string (section_name
));
5324 bfd_signed_vma addend
= q
->addend
;
5332 bfd_printf_vma (abfd
, addend
);
5337 bfd_printf_vma (abfd
, addend2
);
5343 if (last_filename
!= NULL
)
5344 free (last_filename
);
5345 if (last_functionname
!= NULL
)
5346 free (last_functionname
);
5350 dump_relocs_in_section (bfd
*abfd
,
5352 void *dummy ATTRIBUTE_UNUSED
)
5354 arelent
**relpp
= NULL
;
5358 if ( bfd_is_abs_section (section
)
5359 || bfd_is_und_section (section
)
5360 || bfd_is_com_section (section
)
5361 || (! process_section_p (section
))
5362 || ((section
->flags
& SEC_RELOC
) == 0))
5365 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
5367 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
5370 printf (" (none)\n\n");
5378 relpp
= (arelent
**) xmalloc (relsize
);
5379 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
5385 non_fatal (_("failed to read relocs in: %s"),
5386 sanitize_string (bfd_get_filename (abfd
)));
5387 bfd_fatal (_("error message was"));
5389 else if (relcount
== 0)
5390 printf (" (none)\n\n");
5394 dump_reloc_set (abfd
, section
, relpp
, relcount
);
5401 dump_relocs (bfd
*abfd
)
5403 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
5407 dump_dynamic_relocs (bfd
*abfd
)
5413 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5415 bfd_fatal (bfd_get_filename (abfd
));
5417 printf ("DYNAMIC RELOCATION RECORDS");
5420 printf (" (none)\n\n");
5423 relpp
= (arelent
**) xmalloc (relsize
);
5424 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
5427 bfd_fatal (bfd_get_filename (abfd
));
5428 else if (relcount
== 0)
5429 printf (" (none)\n\n");
5433 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
5440 /* Creates a table of paths, to search for source files. */
5443 add_include_path (const char *path
)
5447 include_path_count
++;
5448 include_paths
= (const char **)
5449 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
5450 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5451 if (path
[1] == ':' && path
[2] == 0)
5452 path
= concat (path
, ".", (const char *) 0);
5454 include_paths
[include_path_count
- 1] = path
;
5458 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
5462 if ((section
->flags
& SEC_DEBUGGING
) == 0)
5464 bool *has_reloc_p
= (bool *) arg
;
5465 section
->vma
+= adjust_section_vma
;
5467 section
->lma
+= adjust_section_vma
;
5471 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5474 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5479 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5480 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5484 might_need_separate_debug_info (bool is_mainfile
)
5486 /* We do not follow links from debug info files. */
5490 /* Since do_follow_links might be enabled by default, only treat it as an
5491 indication that separate files should be loaded if setting it was a
5492 deliberate user action. */
5493 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
5496 if (process_links
|| dump_symtab
|| dump_debugging
5497 || dump_dwarf_section_info
|| with_source_code
)
5503 /* Dump selected contents of ABFD. */
5506 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5508 const struct elf_backend_data
* bed
;
5510 if (bfd_big_endian (abfd
))
5511 byte_get
= byte_get_big_endian
;
5512 else if (bfd_little_endian (abfd
))
5513 byte_get
= byte_get_little_endian
;
5517 /* Load any separate debug information files. */
5518 if (byte_get
!= NULL
&& might_need_separate_debug_info (is_mainfile
))
5520 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5522 /* If asked to do so, recursively dump the separate files. */
5523 if (do_follow_links
)
5527 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5528 dump_bfd (i
->handle
, false);
5532 /* Adjust user-specified start and stop limits for targets that use
5533 signed addresses. */
5534 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5535 && (bed
= get_elf_backend_data (abfd
)) != NULL
5536 && bed
->sign_extend_vma
)
5538 start_address
= sign_extend_address (abfd
, start_address
,
5540 stop_address
= sign_extend_address (abfd
, stop_address
,
5544 /* If we are adjusting section VMA's, change them all now. Changing
5545 the BFD information is a hack. However, we must do it, or
5546 bfd_find_nearest_line will not do the right thing. */
5547 if (adjust_section_vma
!= 0)
5549 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5550 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5553 if (is_mainfile
|| process_links
)
5555 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5556 printf (_("\n%s: file format %s\n"),
5557 sanitize_string (bfd_get_filename (abfd
)),
5560 print_arelt_descr (stdout
, abfd
, true, false);
5561 if (dump_file_header
)
5562 dump_bfd_header (abfd
);
5563 if (dump_private_headers
)
5564 dump_bfd_private_header (abfd
);
5565 if (dump_private_options
!= NULL
)
5566 dump_target_specific (abfd
);
5567 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5575 || dump_dwarf_section_info
)
5577 syms
= slurp_symtab (abfd
);
5579 /* If following links, load any symbol tables from the linked files as well. */
5580 if (do_follow_links
&& is_mainfile
)
5584 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5586 asymbol
** extra_syms
;
5587 long old_symcount
= symcount
;
5589 extra_syms
= slurp_symtab (i
->handle
);
5593 if (old_symcount
== 0)
5599 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5600 * sizeof (asymbol
*)));
5601 memcpy (syms
+ old_symcount
,
5603 (symcount
+ 1) * sizeof (asymbol
*));
5607 symcount
+= old_symcount
;
5612 if (is_mainfile
|| process_links
)
5614 if (dump_section_headers
)
5615 dump_headers (abfd
);
5617 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5618 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5619 dynsyms
= slurp_dynamic_symtab (abfd
);
5623 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5624 dynsymcount
, dynsyms
,
5631 dump_symbols (abfd
, false);
5632 if (dump_dynamic_symtab
)
5633 dump_symbols (abfd
, true);
5635 if (dump_dwarf_section_info
)
5636 dump_dwarf (abfd
, is_mainfile
);
5637 if (is_mainfile
|| process_links
)
5639 if (dump_ctf_section_info
)
5640 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5641 if (dump_sframe_section_info
)
5642 dump_section_sframe (abfd
, dump_sframe_section_name
);
5643 if (dump_stab_section_info
)
5645 if (dump_reloc_info
&& ! disassemble
)
5647 if (dump_dynamic_reloc_info
&& ! disassemble
)
5648 dump_dynamic_relocs (abfd
);
5649 if (dump_section_contents
)
5652 disassemble_data (abfd
);
5659 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5660 if (dhandle
!= NULL
)
5662 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5664 dump_debugging_tags
!= 0))
5666 non_fatal (_("%s: printing debugging information failed"),
5667 bfd_get_filename (abfd
));
5673 /* PR 6483: If there was no STABS debug info in the file, try
5675 else if (! dump_dwarf_section_info
)
5677 dwarf_select_sections_all ();
5678 dump_dwarf (abfd
, is_mainfile
);
5705 free_debug_memory ();
5709 display_object_bfd (bfd
*abfd
)
5713 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5715 dump_bfd (abfd
, true);
5719 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5721 nonfatal (bfd_get_filename (abfd
));
5722 list_matching_formats (matching
);
5726 if (bfd_get_error () != bfd_error_file_not_recognized
)
5728 nonfatal (bfd_get_filename (abfd
));
5732 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5734 dump_bfd (abfd
, true);
5738 nonfatal (bfd_get_filename (abfd
));
5740 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5741 list_matching_formats (matching
);
5745 display_any_bfd (bfd
*file
, int level
)
5747 /* Decompress sections unless dumping the section contents. */
5748 if (!dump_section_contents
)
5749 file
->flags
|= BFD_DECOMPRESS
;
5751 /* If the file is an archive, process all of its elements. */
5752 if (bfd_check_format (file
, bfd_archive
))
5755 bfd
*last_arfile
= NULL
;
5758 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5759 else if (level
> 100)
5761 /* Prevent corrupted files from spinning us into an
5762 infinite loop. 100 is an arbitrary heuristic. */
5763 fatal (_("Archive nesting is too deep"));
5767 printf (_("In nested archive %s:\n"),
5768 sanitize_string (bfd_get_filename (file
)));
5772 bfd_set_error (bfd_error_no_error
);
5774 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5777 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5778 nonfatal (bfd_get_filename (file
));
5782 display_any_bfd (arfile
, level
+ 1);
5784 if (last_arfile
!= NULL
)
5786 bfd_close (last_arfile
);
5787 /* PR 17512: file: ac585d01. */
5788 if (arfile
== last_arfile
)
5794 last_arfile
= arfile
;
5797 if (last_arfile
!= NULL
)
5798 bfd_close (last_arfile
);
5801 display_object_bfd (file
);
5805 display_file (char *filename
, char *target
, bool last_file
)
5809 if (get_file_size (filename
) < 1)
5815 file
= bfd_openr (filename
, target
);
5818 nonfatal (filename
);
5822 display_any_bfd (file
, 0);
5824 /* This is an optimization to improve the speed of objdump, especially when
5825 dumping a file with lots of associated debug informatiom. Calling
5826 bfd_close on such a file can take a non-trivial amount of time as there
5827 are lots of lists to walk and buffers to free. This is only really
5828 necessary however if we are about to load another file and we need the
5829 memory back. Otherwise, if we are about to exit, then we can save (a lot
5830 of) time by only doing a quick close, and allowing the OS to reclaim the
5835 bfd_close_all_done (file
);
5839 main (int argc
, char **argv
)
5842 char *target
= default_target
;
5843 bool seenflag
= false;
5845 #ifdef HAVE_LC_MESSAGES
5846 setlocale (LC_MESSAGES
, "");
5848 setlocale (LC_CTYPE
, "");
5850 bindtextdomain (PACKAGE
, LOCALEDIR
);
5851 textdomain (PACKAGE
);
5853 program_name
= *argv
;
5854 xmalloc_set_program_name (program_name
);
5855 bfd_set_error_program_name (program_name
);
5857 START_PROGRESS (program_name
, 0);
5859 expandargv (&argc
, &argv
);
5861 if (bfd_init () != BFD_INIT_MAGIC
)
5862 fatal (_("fatal error: libbfd ABI mismatch"));
5863 set_default_bfd_target ();
5865 while ((c
= getopt_long (argc
, argv
,
5866 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5867 long_options
, (int *) 0))
5873 break; /* We've been given a long option. */
5880 if (disassembler_options
)
5881 /* Ignore potential memory leak for now. */
5882 options
= concat (disassembler_options
, ",",
5883 optarg
, (const char *) NULL
);
5886 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5893 display_file_offsets
= true;
5896 with_line_numbers
= true;
5905 enum demangling_styles style
;
5907 style
= cplus_demangle_name_to_style (optarg
);
5908 if (style
== unknown_demangling
)
5909 fatal (_("unknown demangling style `%s'"),
5912 cplus_demangle_set_style (style
);
5915 case OPTION_RECURSE_LIMIT
:
5916 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5918 case OPTION_NO_RECURSE_LIMIT
:
5919 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5922 do_wide
= wide_output
= true;
5924 case OPTION_ADJUST_VMA
:
5925 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5927 case OPTION_START_ADDRESS
:
5928 start_address
= parse_vma (optarg
, "--start-address");
5929 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5930 fatal (_("error: the start address should be before the end address"));
5932 case OPTION_STOP_ADDRESS
:
5933 stop_address
= parse_vma (optarg
, "--stop-address");
5934 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5935 fatal (_("error: the stop address should be after the start address"));
5939 prefix_length
= strlen (prefix
);
5940 /* Remove an unnecessary trailing '/' */
5941 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5944 case OPTION_PREFIX_STRIP
:
5945 prefix_strip
= atoi (optarg
);
5946 if (prefix_strip
< 0)
5947 fatal (_("error: prefix strip must be non-negative"));
5949 case OPTION_INSN_WIDTH
:
5950 insn_width
= strtoul (optarg
, NULL
, 0);
5951 if (insn_width
<= 0)
5952 fatal (_("error: instruction width must be positive"));
5954 case OPTION_INLINES
:
5955 unwind_inlines
= true;
5957 case OPTION_VISUALIZE_JUMPS
:
5958 visualize_jumps
= true;
5959 color_output
= false;
5960 extended_color_output
= false;
5963 if (streq (optarg
, "color"))
5964 color_output
= true;
5965 else if (streq (optarg
, "extended-color"))
5967 color_output
= true;
5968 extended_color_output
= true;
5970 else if (streq (optarg
, "off"))
5971 visualize_jumps
= false;
5973 nonfatal (_("unrecognized argument to --visualize-option"));
5976 case OPTION_DISASSEMBLER_COLOR
:
5977 if (streq (optarg
, "off"))
5978 disassembler_color
= off
;
5979 else if (streq (optarg
, "terminal"))
5980 disassembler_color
= on_if_terminal_output
;
5981 else if (streq (optarg
, "color")
5982 || streq (optarg
, "colour")
5983 || streq (optarg
, "on"))
5984 disassembler_color
= on
;
5985 else if (streq (optarg
, "extended")
5986 || streq (optarg
, "extended-color")
5987 || streq (optarg
, "extended-colour"))
5988 disassembler_color
= extended
;
5990 nonfatal (_("unrecognized argument to --disassembler-color"));
5993 if (strcmp (optarg
, "B") == 0)
5994 endian
= BFD_ENDIAN_BIG
;
5995 else if (strcmp (optarg
, "L") == 0)
5996 endian
= BFD_ENDIAN_LITTLE
;
5999 nonfatal (_("unrecognized -E option"));
6004 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
6005 endian
= BFD_ENDIAN_BIG
;
6006 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
6007 endian
= BFD_ENDIAN_LITTLE
;
6010 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
6017 dump_file_header
= true;
6021 formats_info
= true;
6025 add_include_path (optarg
);
6028 dump_private_headers
= true;
6032 dump_private_options
= optarg
;
6036 dump_private_headers
= true;
6038 dump_reloc_info
= true;
6039 dump_file_header
= true;
6040 dump_ar_hdrs
= true;
6041 dump_section_headers
= true;
6049 dump_dynamic_symtab
= true;
6055 disasm_sym
= optarg
;
6058 disassemble_zeroes
= true;
6062 disassemble_all
= true;
6067 with_source_code
= true;
6070 case OPTION_SOURCE_COMMENT
:
6072 with_source_code
= true;
6075 source_comment
= xstrdup (sanitize_string (optarg
));
6077 source_comment
= xstrdup ("# ");
6085 dump_debugging_tags
= 1;
6090 process_links
= true;
6091 do_follow_links
= true;
6097 if (dwarf_select_sections_by_letters (optarg
))
6098 dump_dwarf_section_info
= true;
6102 dump_dwarf_section_info
= true;
6103 dwarf_select_sections_all ();
6110 if (dwarf_select_sections_by_names (optarg
))
6111 dump_dwarf_section_info
= true;
6115 dwarf_select_sections_all ();
6116 dump_dwarf_section_info
= true;
6119 case OPTION_DWARF_DEPTH
:
6122 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6125 case OPTION_DWARF_START
:
6128 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6129 suppress_bfd_header
= 1;
6132 case OPTION_DWARF_CHECK
:
6135 #ifdef ENABLE_LIBCTF
6137 dump_ctf_section_info
= true;
6139 dump_ctf_section_name
= xstrdup (optarg
);
6142 case OPTION_CTF_PARENT
:
6143 dump_ctf_parent_name
= xstrdup (optarg
);
6147 dump_sframe_section_info
= true;
6149 dump_sframe_section_name
= xstrdup (optarg
);
6153 dump_stab_section_info
= true;
6157 dump_section_contents
= true;
6161 dump_reloc_info
= true;
6165 dump_dynamic_reloc_info
= true;
6169 dump_ar_hdrs
= true;
6173 dump_section_headers
= true;
6178 show_version
= true;
6183 if (streq (optarg
, "default") || streq (optarg
, "d"))
6184 unicode_display
= unicode_default
;
6185 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6186 unicode_display
= unicode_locale
;
6187 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6188 unicode_display
= unicode_escape
;
6189 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6190 unicode_display
= unicode_invalid
;
6191 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6192 unicode_display
= unicode_hex
;
6193 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6194 unicode_display
= unicode_highlight
;
6196 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
6201 /* No need to set seenflag or to break - usage() does not return. */
6207 if (disassembler_color
== on_if_terminal_output
)
6208 disassembler_color
= isatty (1) ? on
: off
;
6211 print_version ("objdump");
6216 dump_any_debugging
= (dump_debugging
6217 || dump_dwarf_section_info
6219 || with_source_code
);
6222 exit_status
= display_info ();
6226 display_file ("a.out", target
, true);
6228 for (; optind
< argc
;)
6230 display_file (argv
[optind
], target
, optind
== argc
- 1);
6236 free (dump_ctf_section_name
);
6237 free (dump_ctf_parent_name
);
6238 free ((void *) source_comment
);
6240 END_PROGRESS (program_name
);