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 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
1226 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1231 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1232 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1234 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1235 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1237 return asz
> bsz
? -1 : 1;
1240 /* Symbols that start with '.' might be section names, so sort them
1241 after symbols that don't start with '.'. */
1242 if (an
[0] == '.' && bn
[0] != '.')
1244 if (an
[0] != '.' && bn
[0] == '.')
1247 /* Finally, if we can't distinguish them in any other way, try to
1248 get consistent results by sorting the symbols by name. */
1249 return strcmp (an
, bn
);
1252 /* Sort relocs into address order. */
1255 compare_relocs (const void *ap
, const void *bp
)
1257 const arelent
*a
= * (const arelent
**) ap
;
1258 const arelent
*b
= * (const arelent
**) bp
;
1260 if (a
->address
> b
->address
)
1262 else if (a
->address
< b
->address
)
1265 /* So that associated relocations tied to the same address show up
1266 in the correct order, we don't do any further sorting. */
1275 /* Print an address (VMA) to the output stream in INFO.
1276 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1279 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1284 struct objdump_disasm_info
*aux
;
1286 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1287 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1292 for (p
= buf
; *p
== '0'; ++p
)
1297 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "%s", p
);
1300 /* Print the name of a symbol. */
1303 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1307 const char *name
, *version_string
= NULL
;
1308 bool hidden
= false;
1311 name
= bfd_asymbol_name (sym
);
1312 if (do_demangle
&& name
[0] != '\0')
1314 /* Demangle the name. */
1315 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1320 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1321 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1324 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1327 name
= sanitize_string (name
);
1331 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s", name
);
1332 if (version_string
&& *version_string
!= '\0')
1333 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
,
1334 hidden
? "@%s" : "@@%s",
1339 printf ("%s", name
);
1340 if (version_string
&& *version_string
!= '\0')
1341 printf (hidden
? "@%s" : "@@%s", version_string
);
1349 sym_ok (bool want_section
,
1350 bfd
*abfd ATTRIBUTE_UNUSED
,
1353 struct disassemble_info
*inf
)
1357 /* NB: An object file can have different sections with the same
1358 section name. Compare compare section pointers if they have
1360 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1361 && sorted_syms
[place
]->section
!= sec
)
1364 /* Note - we cannot just compare section pointers because they could
1365 be different, but the same... Ie the symbol that we are trying to
1366 find could have come from a separate debug info file. Under such
1367 circumstances the symbol will be associated with a section in the
1368 debug info file, whilst the section we want is in a normal file.
1369 So the section pointers will be different, but the section names
1370 will be the same. */
1371 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1372 bfd_section_name (sec
)) != 0)
1376 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1379 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1380 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1381 require the symbol to be in the section. Returns NULL if there is no
1382 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1383 of the symbol in sorted_syms. */
1386 find_symbol_for_address (bfd_vma vma
,
1387 struct disassemble_info
*inf
,
1390 /* @@ Would it speed things up to cache the last two symbols returned,
1391 and maybe their address ranges? For many processors, only one memory
1392 operand can be present at a time, so the 2-entry cache wouldn't be
1393 constantly churned by code doing heavy memory accesses. */
1395 /* Indices in `sorted_syms'. */
1397 long max_count
= sorted_symcount
;
1399 struct objdump_disasm_info
*aux
;
1406 if (sorted_symcount
< 1)
1409 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1412 opb
= inf
->octets_per_byte
;
1414 /* Perform a binary search looking for the closest symbol to the
1415 required value. We are searching the range (min, max_count]. */
1416 while (min
+ 1 < max_count
)
1420 thisplace
= (max_count
+ min
) / 2;
1421 sym
= sorted_syms
[thisplace
];
1423 if (bfd_asymbol_value (sym
) > vma
)
1424 max_count
= thisplace
;
1425 else if (bfd_asymbol_value (sym
) < vma
)
1434 /* The symbol we want is now in min, the low end of the range we
1435 were searching. If there are several symbols with the same
1436 value, we want the first one. */
1438 while (thisplace
> 0
1439 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1440 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1443 /* Prefer a symbol in the current section if we have multple symbols
1444 with the same value, as can occur with overlays or zero size
1447 while (min
< max_count
1448 && (bfd_asymbol_value (sorted_syms
[min
])
1449 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1451 if (sym_ok (true, abfd
, min
, sec
, inf
))
1458 return sorted_syms
[thisplace
];
1463 /* If the file is relocatable, and the symbol could be from this
1464 section, prefer a symbol from this section over symbols from
1465 others, even if the other symbol's value might be closer.
1467 Note that this may be wrong for some symbol references if the
1468 sections have overlapping memory ranges, but in that case there's
1469 no way to tell what's desired without looking at the relocation
1472 Also give the target a chance to reject symbols. */
1473 want_section
= (aux
->require_sec
1474 || ((abfd
->flags
& HAS_RELOC
) != 0
1475 && vma
>= bfd_section_vma (sec
)
1476 && vma
< (bfd_section_vma (sec
)
1477 + bfd_section_size (sec
) / opb
)));
1479 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1482 long newplace
= sorted_symcount
;
1484 for (i
= min
- 1; i
>= 0; i
--)
1486 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1488 if (newplace
== sorted_symcount
)
1491 if (bfd_asymbol_value (sorted_syms
[i
])
1492 != bfd_asymbol_value (sorted_syms
[newplace
]))
1495 /* Remember this symbol and keep searching until we reach
1496 an earlier address. */
1501 if (newplace
!= sorted_symcount
)
1502 thisplace
= newplace
;
1505 /* We didn't find a good symbol with a smaller value.
1506 Look for one with a larger value. */
1507 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1509 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1517 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1518 /* There is no suitable symbol. */
1522 /* If we have not found an exact match for the specified address
1523 and we have dynamic relocations available, then we can produce
1524 a better result by matching a relocation to the address and
1525 using the symbol associated with that relocation. */
1526 rel_count
= inf
->dynrelcount
;
1528 && sorted_syms
[thisplace
]->value
!= vma
1530 && inf
->dynrelbuf
!= NULL
1531 && inf
->dynrelbuf
[0]->address
<= vma
1532 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1533 /* If we have matched a synthetic symbol, then stick with that. */
1534 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1537 arelent
** rel_high
;
1539 rel_low
= inf
->dynrelbuf
;
1540 rel_high
= rel_low
+ rel_count
- 1;
1541 while (rel_low
<= rel_high
)
1543 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1544 arelent
* rel
= *rel_mid
;
1546 if (rel
->address
== vma
)
1548 /* Absolute relocations do not provide a more helpful
1549 symbolic address. Find a non-absolute relocation
1550 with the same address. */
1551 arelent
**rel_vma
= rel_mid
;
1553 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1557 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1561 if (rel
->sym_ptr_ptr
!= NULL
1562 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1565 * place
= thisplace
;
1566 return * rel
->sym_ptr_ptr
;
1572 if (vma
< rel
->address
)
1574 else if (vma
>= rel_mid
[1]->address
)
1575 rel_low
= rel_mid
+ 1;
1584 return sorted_syms
[thisplace
];
1587 /* Print an address and the offset to the nearest symbol. */
1590 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1591 bfd_vma vma
, struct disassemble_info
*inf
,
1596 objdump_print_value (vma
, inf
, skip_zeroes
);
1597 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, " ");
1604 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
,"<");
1605 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s",
1606 sanitize_string (bfd_section_name (sec
)));
1607 secaddr
= bfd_section_vma (sec
);
1610 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,
1612 objdump_print_value (secaddr
- vma
, inf
, true);
1614 else if (vma
> secaddr
)
1616 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1617 objdump_print_value (vma
- secaddr
, inf
, true);
1619 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1623 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, "<");
1625 objdump_print_symname (abfd
, inf
, sym
);
1627 if (bfd_asymbol_value (sym
) == vma
)
1629 /* Undefined symbols in an executables and dynamic objects do not have
1630 a value associated with them, so it does not make sense to display
1631 an offset relative to them. Normally we would not be provided with
1632 this kind of symbol, but the target backend might choose to do so,
1633 and the code in find_symbol_for_address might return an as yet
1634 unresolved symbol associated with a dynamic reloc. */
1635 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1636 && bfd_is_und_section (sym
->section
))
1638 else if (bfd_asymbol_value (sym
) > vma
)
1640 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,"-0x");
1641 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1643 else if (vma
> bfd_asymbol_value (sym
))
1645 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1646 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1649 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1652 if (display_file_offsets
)
1653 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1654 _(" (File Offset: 0x%lx)"),
1655 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1658 /* Print an address (VMA), symbolically if possible.
1659 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1662 objdump_print_addr (bfd_vma vma
,
1663 struct disassemble_info
*inf
,
1666 struct objdump_disasm_info
*aux
;
1667 asymbol
*sym
= NULL
;
1668 bool skip_find
= false;
1670 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1672 if (sorted_symcount
< 1)
1676 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "0x");
1677 objdump_print_value (vma
, inf
, skip_zeroes
);
1680 if (display_file_offsets
)
1681 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1682 _(" (File Offset: 0x%lx)"),
1683 (long int) (inf
->section
->filepos
1684 + (vma
- inf
->section
->vma
)));
1688 if (aux
->reloc
!= NULL
1689 && aux
->reloc
->sym_ptr_ptr
!= NULL
1690 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1692 sym
= * aux
->reloc
->sym_ptr_ptr
;
1694 /* Adjust the vma to the reloc. */
1695 vma
+= bfd_asymbol_value (sym
);
1697 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1702 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1704 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1708 /* Print VMA to INFO. This function is passed to the disassembler
1712 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1714 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1717 /* Determine if the given address has a symbol associated with it. */
1720 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1724 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1725 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1731 /* Hold the last function name and the last line number we displayed
1732 in a disassembly. */
1734 static char *prev_functionname
;
1735 static unsigned int prev_line
;
1736 static unsigned int prev_discriminator
;
1738 /* We keep a list of all files that we have seen when doing a
1739 disassembly with source, so that we know how much of the file to
1740 display. This can be important for inlined functions. */
1742 struct print_file_list
1744 struct print_file_list
*next
;
1745 const char *filename
;
1746 const char *modname
;
1749 const char **linemap
;
1752 unsigned max_printed
;
1756 static struct print_file_list
*print_files
;
1758 /* The number of preceding context lines to show when we start
1759 displaying a file for the first time. */
1761 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1763 #if HAVE_LIBDEBUGINFOD
1764 /* Return a hex string represention of the build-id. */
1767 get_build_id (void * data
)
1770 char * build_id_str
;
1771 bfd
* abfd
= (bfd
*) data
;
1772 const struct bfd_build_id
* build_id
;
1774 build_id
= abfd
->build_id
;
1775 if (build_id
== NULL
)
1778 build_id_str
= malloc (build_id
->size
* 2 + 1);
1779 if (build_id_str
== NULL
)
1782 for (i
= 0; i
< build_id
->size
; i
++)
1783 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
1784 build_id_str
[build_id
->size
* 2] = '\0';
1786 return (unsigned char *) build_id_str
;
1789 /* Search for a separate debug file matching ABFD's build-id. */
1792 find_separate_debug (const bfd
* abfd
)
1794 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1795 separate_info
* i
= first_separate_info
;
1797 if (build_id
== NULL
|| i
== NULL
)
1802 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1804 if (abfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1806 const unsigned char * data
= i_bfd
->build_id
->data
;
1807 size_t size
= i_bfd
->build_id
->size
;
1809 if (size
== build_id
->size
1810 && memcmp (data
, build_id
->data
, size
) == 0)
1811 return (bfd
*) i
->handle
;
1820 /* Search for a separate debug file matching ABFD's .gnu_debugaltlink
1824 find_alt_debug (const bfd
* abfd
)
1829 struct dwarf_section
* section
;
1830 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1831 separate_info
* i
= first_separate_info
;
1835 || !load_debug_section (gnu_debugaltlink
, (void *) abfd
))
1838 section
= &debug_displays
[gnu_debugaltlink
].section
;
1839 if (section
== NULL
)
1842 name
= (const char *) section
->start
;
1843 namelen
= strnlen (name
, section
->size
) + 1;
1846 if (namelen
>= section
->size
)
1849 id_len
= section
->size
- namelen
;
1853 /* Compare the .gnu_debugaltlink build-id with the build-ids of the
1854 known separate_info files. */
1857 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1859 if (i_bfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1861 const unsigned char * data
= i_bfd
->build_id
->data
;
1862 size_t size
= i_bfd
->build_id
->size
;
1865 && memcmp (section
->start
+ namelen
, data
, size
) == 0)
1866 return (bfd
*) i
->handle
;
1875 #endif /* HAVE_LIBDEBUGINFOD */
1877 /* Reads the contents of file FN into memory. Returns a pointer to the buffer.
1878 Also returns the size of the buffer in SIZE_RETURN and a filled out
1879 stat structure in FST_RETURN. Returns NULL upon failure. */
1882 slurp_file (const char * fn
,
1883 size_t * size_return
,
1884 struct stat
* fst_return
,
1885 bfd
* abfd ATTRIBUTE_UNUSED
)
1895 if (fn
== NULL
|| * fn
== 0 || size_return
== NULL
|| fst_return
== NULL
)
1898 fd
= open (fn
, O_RDONLY
| O_BINARY
);
1900 #if HAVE_LIBDEBUGINFOD
1901 if (fd
< 0 && use_debuginfod
&& fn
[0] == '/' && abfd
!= NULL
)
1903 unsigned char *build_id
= get_build_id (abfd
);
1907 debuginfod_client
*client
= debuginfod_begin ();
1911 fd
= debuginfod_find_source (client
, build_id
, 0, fn
, NULL
);
1912 debuginfod_end (client
);
1922 if (fstat (fd
, fst_return
) < 0)
1928 *size_return
= fst_return
->st_size
;
1931 ps
= getpagesize ();
1932 msize
= (*size_return
+ ps
- 1) & ~(ps
- 1);
1933 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1934 if (map
!= (char *) -1L)
1941 map
= (const char *) malloc (*size_return
);
1942 if (!map
|| (size_t) read (fd
, (char *) map
, *size_return
) != *size_return
)
1944 free ((void *) map
);
1951 #define line_map_decrease 5
1953 /* Precompute array of lines for a mapped file. */
1955 static const char **
1956 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1958 const char *p
, *lstart
, *end
;
1959 int chars_per_line
= 45; /* First iteration will use 40. */
1960 unsigned int lineno
;
1961 const char **linemap
= NULL
;
1962 unsigned long line_map_size
= 0;
1968 for (p
= map
; p
< end
; p
++)
1972 if (p
+ 1 < end
&& p
[1] == '\r')
1975 else if (*p
== '\r')
1977 if (p
+ 1 < end
&& p
[1] == '\n')
1983 /* End of line found. */
1985 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1987 unsigned long newsize
;
1989 chars_per_line
-= line_map_decrease
;
1990 if (chars_per_line
<= 1)
1992 line_map_size
= size
/ chars_per_line
+ 1;
1993 if (line_map_size
< lineno
+ 1)
1994 line_map_size
= lineno
+ 1;
1995 newsize
= line_map_size
* sizeof (char *);
1996 linemap
= (const char **) xrealloc (linemap
, newsize
);
1999 linemap
[lineno
++] = lstart
;
2007 /* Tries to open MODNAME, and if successful adds a node to print_files
2008 linked list and returns that node. Also fills in the stat structure
2009 pointed to by FST_RETURN. Returns NULL on failure. */
2011 static struct print_file_list
*
2012 try_print_file_open (const char * origname
,
2013 const char * modname
,
2014 struct stat
* fst_return
,
2017 struct print_file_list
*p
;
2019 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
2021 p
->map
= slurp_file (modname
, &p
->mapsize
, fst_return
, abfd
);
2028 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
2031 p
->filename
= origname
;
2032 p
->modname
= modname
;
2033 p
->next
= print_files
;
2039 /* If the source file, as described in the symtab, is not found
2040 try to locate it in one of the paths specified with -I
2041 If found, add location to print_files linked list. */
2043 static struct print_file_list
*
2044 update_source_path (const char *filename
, bfd
*abfd
)
2046 struct print_file_list
*p
;
2051 p
= try_print_file_open (filename
, filename
, &fst
, abfd
);
2054 if (include_path_count
== 0)
2057 /* Get the name of the file. */
2058 fname
= lbasename (filename
);
2060 /* If file exists under a new path, we need to add it to the list
2061 so that show_line knows about it. */
2062 for (i
= 0; i
< include_path_count
; i
++)
2064 char *modname
= concat (include_paths
[i
], "/", fname
,
2067 p
= try_print_file_open (filename
, modname
, &fst
, abfd
);
2077 long mtime
= bfd_get_mtime (abfd
);
2079 if (fst
.st_mtime
> mtime
)
2080 warn (_("source file %s is more recent than object file\n"),
2087 /* Print a source file line. */
2090 print_line (struct print_file_list
*p
, unsigned int linenum
)
2095 if (linenum
>= p
->maxline
)
2097 l
= p
->linemap
[linenum
];
2098 if (source_comment
!= NULL
&& strlen (l
) > 0)
2099 printf ("%s", source_comment
);
2100 len
= strcspn (l
, "\n\r");
2101 /* Test fwrite return value to quiet glibc warning. */
2102 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
2106 /* Print a range of source code lines. */
2109 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
2117 print_line (p
, start
);
2122 /* Show the line number, or the source line, in a disassembly
2126 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
2128 const char *filename
;
2129 const char *functionname
;
2130 unsigned int linenumber
;
2131 unsigned int discriminator
;
2135 if (! with_line_numbers
&& ! with_source_code
)
2138 #ifdef HAVE_LIBDEBUGINFOD
2141 const char *alt_filename
= NULL
;
2147 /* PR 29075: Check for separate debuginfo and .gnu_debugaltlink files.
2148 They need to be passed to bfd_find_nearest_line_with_alt in case they
2149 were downloaded from debuginfod. Otherwise libbfd will attempt to
2150 search for them and fail to locate them. */
2151 debug_bfd
= find_separate_debug (abfd
);
2152 if (debug_bfd
== NULL
)
2155 alt_bfd
= find_alt_debug (debug_bfd
);
2156 if (alt_bfd
!= NULL
)
2157 alt_filename
= bfd_get_filename (alt_bfd
);
2162 bfd_set_error (bfd_error_no_error
);
2163 if (! bfd_find_nearest_line_with_alt (debug_bfd
, alt_filename
,
2165 addr_offset
, &filename
,
2166 &functionname
, &linenumber
,
2169 if (bfd_get_error () == bfd_error_no_error
)
2171 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
,
2172 addr_offset
, &filename
,
2173 &functionname
, &linenumber
,
2179 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
2180 &filename
, &functionname
,
2181 &linenumber
, &discriminator
))
2185 if (filename
!= NULL
&& *filename
== '\0')
2187 if (functionname
!= NULL
&& *functionname
== '\0')
2188 functionname
= NULL
;
2191 && IS_ABSOLUTE_PATH (filename
)
2195 const char *fname
= filename
;
2197 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
2200 memcpy (path
, prefix
, prefix_length
);
2201 path_up
= path
+ prefix_length
;
2203 /* Build relocated filename, stripping off leading directories
2204 from the initial filename if requested. */
2205 if (prefix_strip
> 0)
2210 /* Skip selected directory levels. */
2211 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
2212 if (IS_DIR_SEPARATOR (*s
))
2219 /* Update complete filename. */
2220 strcpy (path_up
, fname
);
2228 if (with_line_numbers
)
2230 if (functionname
!= NULL
2231 && (prev_functionname
== NULL
2232 || strcmp (functionname
, prev_functionname
) != 0))
2234 char *demangle_alloc
= NULL
;
2235 if (do_demangle
&& functionname
[0] != '\0')
2237 /* Demangle the name. */
2238 demangle_alloc
= bfd_demangle (abfd
, functionname
,
2242 /* Demangling adds trailing parens, so don't print those. */
2243 if (demangle_alloc
!= NULL
)
2244 printf ("%s:\n", sanitize_string (demangle_alloc
));
2246 printf ("%s():\n", sanitize_string (functionname
));
2249 free (demangle_alloc
);
2252 && (linenumber
!= prev_line
2253 || discriminator
!= prev_discriminator
))
2255 if (discriminator
> 0)
2256 printf ("%s:%u (discriminator %u)\n",
2257 filename
== NULL
? "???" : sanitize_string (filename
),
2258 linenumber
, discriminator
);
2260 printf ("%s:%u\n", filename
== NULL
2261 ? "???" : sanitize_string (filename
),
2266 const char *filename2
;
2267 const char *functionname2
;
2270 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2273 printf ("inlined by %s:%u",
2274 sanitize_string (filename2
), line2
);
2275 printf (" (%s)\n", sanitize_string (functionname2
));
2280 if (with_source_code
2284 struct print_file_list
**pp
, *p
;
2287 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2288 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2295 filename
= xstrdup (filename
);
2296 p
= update_source_path (filename
, abfd
);
2299 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2301 if (file_start_context
&& p
->first
)
2305 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2306 if (l
>= linenumber
)
2308 if (p
->max_printed
>= l
)
2310 if (p
->max_printed
< linenumber
)
2311 l
= p
->max_printed
+ 1;
2316 dump_lines (p
, l
, linenumber
);
2317 if (p
->max_printed
< linenumber
)
2318 p
->max_printed
= linenumber
;
2319 p
->last_line
= linenumber
;
2324 if (functionname
!= NULL
2325 && (prev_functionname
== NULL
2326 || strcmp (functionname
, prev_functionname
) != 0))
2328 if (prev_functionname
!= NULL
)
2329 free (prev_functionname
);
2330 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2331 strcpy (prev_functionname
, functionname
);
2334 if (linenumber
> 0 && linenumber
!= prev_line
)
2335 prev_line
= linenumber
;
2337 if (discriminator
!= prev_discriminator
)
2338 prev_discriminator
= discriminator
;
2344 /* Pseudo FILE object for strings. */
2352 /* sprintf to a "stream". */
2354 static int ATTRIBUTE_PRINTF_2
2355 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2362 size_t space
= f
->alloc
- f
->pos
;
2364 va_start (args
, format
);
2365 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2371 f
->alloc
= (f
->alloc
+ n
) * 2;
2372 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2379 /* Return an integer greater than, or equal to zero, representing the color
2380 for STYLE, or -1 if no color should be used. */
2383 objdump_color_for_disassembler_style (enum disassembler_style style
)
2387 if (style
== dis_style_comment_start
)
2388 disassembler_in_comment
= true;
2390 if (disassembler_color
== on
)
2392 if (disassembler_in_comment
)
2397 case dis_style_symbol
:
2400 case dis_style_assembler_directive
:
2401 case dis_style_sub_mnemonic
:
2402 case dis_style_mnemonic
:
2405 case dis_style_register
:
2408 case dis_style_address
:
2409 case dis_style_address_offset
:
2410 case dis_style_immediate
:
2414 case dis_style_text
:
2419 else if (disassembler_color
== extended
)
2421 if (disassembler_in_comment
)
2426 case dis_style_symbol
:
2429 case dis_style_assembler_directive
:
2430 case dis_style_sub_mnemonic
:
2431 case dis_style_mnemonic
:
2434 case dis_style_register
:
2437 case dis_style_address
:
2438 case dis_style_address_offset
:
2439 case dis_style_immediate
:
2443 case dis_style_text
:
2448 else if (disassembler_color
!= off
)
2449 bfd_fatal (_("disassembly color not correctly selected"));
2454 /* Like objdump_sprintf, but add in escape sequences to highlight the
2455 content according to STYLE. */
2457 static int ATTRIBUTE_PRINTF_3
2458 objdump_styled_sprintf (SFILE
*f
, enum disassembler_style style
,
2459 const char *format
, ...)
2463 int color
= objdump_color_for_disassembler_style (style
);
2469 size_t space
= f
->alloc
- f
->pos
;
2471 if (disassembler_color
== on
)
2472 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[%dm", color
);
2474 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[38;5;%dm", color
);
2478 f
->alloc
= (f
->alloc
+ n
) * 2;
2479 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2486 size_t space
= f
->alloc
- f
->pos
;
2488 va_start (args
, format
);
2489 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2495 f
->alloc
= (f
->alloc
+ n
) * 2;
2496 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2504 size_t space
= f
->alloc
- f
->pos
;
2506 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[0m");
2511 f
->alloc
= (f
->alloc
+ n
) * 2;
2512 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2520 /* We discard the styling information here. This function is only used
2521 when objdump is printing auxiliary information, the symbol headers, and
2522 disassembly address, or the bytes of the disassembled instruction. We
2523 don't (currently) apply styling to any of this stuff, so, for now, just
2524 print the content with no additional style added. */
2526 static int ATTRIBUTE_PRINTF_3
2527 fprintf_styled (FILE *f
, enum disassembler_style style ATTRIBUTE_UNUSED
,
2528 const char *fmt
, ...)
2534 res
= vfprintf (f
, fmt
, ap
);
2540 /* Code for generating (colored) diagrams of control flow start and end
2543 /* Structure used to store the properties of a jump. */
2547 /* The next jump, or NULL if this is the last object. */
2548 struct jump_info
*next
;
2549 /* The previous jump, or NULL if this is the first object. */
2550 struct jump_info
*prev
;
2551 /* The start addresses of the jump. */
2554 /* The list of start addresses. */
2556 /* The number of elements. */
2558 /* The maximum number of elements that fit into the array. */
2561 /* The end address of the jump. */
2563 /* The drawing level of the jump. */
2567 /* Construct a jump object for a jump from start
2568 to end with the corresponding level. */
2570 static struct jump_info
*
2571 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2573 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2575 result
->next
= NULL
;
2576 result
->prev
= NULL
;
2577 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2578 result
->start
.addresses
[0] = start
;
2579 result
->start
.count
= 1;
2580 result
->start
.max_count
= 2;
2582 result
->level
= level
;
2587 /* Free a jump object and return the next object
2588 or NULL if this was the last one. */
2590 static struct jump_info
*
2591 jump_info_free (struct jump_info
*ji
)
2593 struct jump_info
*result
= NULL
;
2598 if (ji
->start
.addresses
)
2599 free (ji
->start
.addresses
);
2606 /* Get the smallest value of all start and end addresses. */
2609 jump_info_min_address (const struct jump_info
*ji
)
2611 bfd_vma min_address
= ji
->end
;
2614 for (i
= ji
->start
.count
; i
-- > 0;)
2615 if (ji
->start
.addresses
[i
] < min_address
)
2616 min_address
= ji
->start
.addresses
[i
];
2620 /* Get the largest value of all start and end addresses. */
2623 jump_info_max_address (const struct jump_info
*ji
)
2625 bfd_vma max_address
= ji
->end
;
2628 for (i
= ji
->start
.count
; i
-- > 0;)
2629 if (ji
->start
.addresses
[i
] > max_address
)
2630 max_address
= ji
->start
.addresses
[i
];
2634 /* Get the target address of a jump. */
2637 jump_info_end_address (const struct jump_info
*ji
)
2642 /* Test if an address is one of the start addresses of a jump. */
2645 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2647 bool result
= false;
2650 for (i
= ji
->start
.count
; i
-- > 0;)
2651 if (address
== ji
->start
.addresses
[i
])
2660 /* Test if an address is the target address of a jump. */
2663 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2665 return (address
== ji
->end
);
2668 /* Get the difference between the smallest and largest address of a jump. */
2671 jump_info_size (const struct jump_info
*ji
)
2673 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2676 /* Unlink a jump object from a list. */
2679 jump_info_unlink (struct jump_info
*node
,
2680 struct jump_info
**base
)
2683 node
->next
->prev
= node
->prev
;
2685 node
->prev
->next
= node
->next
;
2692 /* Insert unlinked jump info node into a list. */
2695 jump_info_insert (struct jump_info
*node
,
2696 struct jump_info
*target
,
2697 struct jump_info
**base
)
2699 node
->next
= target
;
2700 node
->prev
= target
->prev
;
2701 target
->prev
= node
;
2703 node
->prev
->next
= node
;
2708 /* Add unlinked node to the front of a list. */
2711 jump_info_add_front (struct jump_info
*node
,
2712 struct jump_info
**base
)
2716 node
->next
->prev
= node
;
2721 /* Move linked node to target position. */
2724 jump_info_move_linked (struct jump_info
*node
,
2725 struct jump_info
*target
,
2726 struct jump_info
**base
)
2729 jump_info_unlink (node
, base
);
2730 /* Insert node at target position. */
2731 jump_info_insert (node
, target
, base
);
2734 /* Test if two jumps intersect. */
2737 jump_info_intersect (const struct jump_info
*a
,
2738 const struct jump_info
*b
)
2740 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2741 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2744 /* Merge two compatible jump info objects. */
2747 jump_info_merge (struct jump_info
**base
)
2749 struct jump_info
*a
;
2751 for (a
= *base
; a
; a
= a
->next
)
2753 struct jump_info
*b
;
2755 for (b
= a
->next
; b
; b
= b
->next
)
2757 /* Merge both jumps into one. */
2758 if (a
->end
== b
->end
)
2760 /* Reallocate addresses. */
2761 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2764 if (needed_size
> a
->start
.max_count
)
2766 a
->start
.max_count
+= b
->start
.max_count
;
2767 a
->start
.addresses
=
2768 xrealloc (a
->start
.addresses
,
2769 a
->start
.max_count
* sizeof (bfd_vma
*));
2772 /* Append start addresses. */
2773 for (i
= 0; i
< b
->start
.count
; ++i
)
2774 a
->start
.addresses
[a
->start
.count
++] =
2775 b
->start
.addresses
[i
];
2777 /* Remove and delete jump. */
2778 struct jump_info
*tmp
= b
->prev
;
2779 jump_info_unlink (b
, base
);
2787 /* Sort jumps by their size and starting point using a stable
2788 minsort. This could be improved if sorting performance is
2789 an issue, for example by using mergesort. */
2792 jump_info_sort (struct jump_info
**base
)
2794 struct jump_info
*current_element
= *base
;
2796 while (current_element
)
2798 struct jump_info
*best_match
= current_element
;
2799 struct jump_info
*runner
= current_element
->next
;
2800 bfd_vma best_size
= jump_info_size (best_match
);
2804 bfd_vma runner_size
= jump_info_size (runner
);
2806 if ((runner_size
< best_size
)
2807 || ((runner_size
== best_size
)
2808 && (jump_info_min_address (runner
)
2809 < jump_info_min_address (best_match
))))
2811 best_match
= runner
;
2812 best_size
= runner_size
;
2815 runner
= runner
->next
;
2818 if (best_match
== current_element
)
2819 current_element
= current_element
->next
;
2821 jump_info_move_linked (best_match
, current_element
, base
);
2825 /* Visualize all jumps at a given address. */
2828 jump_info_visualize_address (bfd_vma address
,
2831 uint8_t *color_buffer
)
2833 struct jump_info
*ji
= detected_jumps
;
2834 size_t len
= (max_level
+ 1) * 3;
2836 /* Clear line buffer. */
2837 memset (line_buffer
, ' ', len
);
2838 memset (color_buffer
, 0, len
);
2840 /* Iterate over jumps and add their ASCII art. */
2843 /* Discard jumps that are never needed again. */
2844 if (jump_info_max_address (ji
) < address
)
2846 struct jump_info
*tmp
= ji
;
2849 jump_info_unlink (tmp
, &detected_jumps
);
2850 jump_info_free (tmp
);
2854 /* This jump intersects with the current address. */
2855 if (jump_info_min_address (ji
) <= address
)
2857 /* Hash target address to get an even
2858 distribution between all values. */
2859 bfd_vma hash_address
= jump_info_end_address (ji
);
2860 uint8_t color
= iterative_hash_object (hash_address
, 0);
2861 /* Fetch line offset. */
2862 int offset
= (max_level
- ji
->level
) * 3;
2864 /* Draw start line. */
2865 if (jump_info_is_start_address (ji
, address
))
2867 size_t i
= offset
+ 1;
2869 for (; i
< len
- 1; ++i
)
2870 if (line_buffer
[i
] == ' ')
2872 line_buffer
[i
] = '-';
2873 color_buffer
[i
] = color
;
2876 if (line_buffer
[i
] == ' ')
2878 line_buffer
[i
] = '-';
2879 color_buffer
[i
] = color
;
2881 else if (line_buffer
[i
] == '>')
2883 line_buffer
[i
] = 'X';
2884 color_buffer
[i
] = color
;
2887 if (line_buffer
[offset
] == ' ')
2889 if (address
<= ji
->end
)
2890 line_buffer
[offset
] =
2891 (jump_info_min_address (ji
) == address
) ? '/': '+';
2893 line_buffer
[offset
] =
2894 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2895 color_buffer
[offset
] = color
;
2898 /* Draw jump target. */
2899 else if (jump_info_is_end_address (ji
, address
))
2901 size_t i
= offset
+ 1;
2903 for (; i
< len
- 1; ++i
)
2904 if (line_buffer
[i
] == ' ')
2906 line_buffer
[i
] = '-';
2907 color_buffer
[i
] = color
;
2910 if (line_buffer
[i
] == ' ')
2912 line_buffer
[i
] = '>';
2913 color_buffer
[i
] = color
;
2915 else if (line_buffer
[i
] == '-')
2917 line_buffer
[i
] = 'X';
2918 color_buffer
[i
] = color
;
2921 if (line_buffer
[offset
] == ' ')
2923 if (jump_info_min_address (ji
) < address
)
2924 line_buffer
[offset
] =
2925 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2927 line_buffer
[offset
] = '/';
2928 color_buffer
[offset
] = color
;
2931 /* Draw intermediate line segment. */
2932 else if (line_buffer
[offset
] == ' ')
2934 line_buffer
[offset
] = '|';
2935 color_buffer
[offset
] = color
;
2943 /* Clone of disassemble_bytes to detect jumps inside a function. */
2944 /* FIXME: is this correct? Can we strip it down even further? */
2946 static struct jump_info
*
2947 disassemble_jumps (struct disassemble_info
* inf
,
2948 disassembler_ftype disassemble_fn
,
2949 bfd_vma start_offset
,
2950 bfd_vma stop_offset
,
2953 arelent
** relppend
)
2955 struct objdump_disasm_info
*aux
;
2956 struct jump_info
*jumps
= NULL
;
2958 bfd_vma addr_offset
;
2959 unsigned int opb
= inf
->octets_per_byte
;
2963 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2964 section
= inf
->section
;
2967 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2970 inf
->insn_info_valid
= 0;
2971 disassemble_set_printf (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
2972 (fprintf_styled_ftype
) objdump_styled_sprintf
);
2974 addr_offset
= start_offset
;
2975 while (addr_offset
< stop_offset
)
2977 int previous_octets
;
2979 /* Remember the length of the previous instruction. */
2980 previous_octets
= octets
;
2984 inf
->bytes_per_line
= 0;
2985 inf
->bytes_per_chunk
= 0;
2986 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2987 | (wide_output
? WIDE_OUTPUT
: 0));
2989 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2991 if (inf
->disassembler_needs_relocs
2992 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2993 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2994 && *relppp
< relppend
)
2996 bfd_signed_vma distance_to_rel
;
2998 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
3000 /* Check to see if the current reloc is associated with
3001 the instruction that we are about to disassemble. */
3002 if (distance_to_rel
== 0
3003 /* FIXME: This is wrong. We are trying to catch
3004 relocs that are addressed part way through the
3005 current instruction, as might happen with a packed
3006 VLIW instruction. Unfortunately we do not know the
3007 length of the current instruction since we have not
3008 disassembled it yet. Instead we take a guess based
3009 upon the length of the previous instruction. The
3010 proper solution is to have a new target-specific
3011 disassembler function which just returns the length
3012 of an instruction at a given address without trying
3013 to display its disassembly. */
3014 || (distance_to_rel
> 0
3015 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
3017 inf
->flags
|= INSN_HAS_RELOC
;
3021 if (! disassemble_all
3022 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3023 == (SEC_CODE
| SEC_HAS_CONTENTS
))
3024 /* Set a stop_vma so that the disassembler will not read
3025 beyond the next symbol. We assume that symbols appear on
3026 the boundaries between instructions. We only do this when
3027 disassembling code of course, and when -D is in effect. */
3028 inf
->stop_vma
= section
->vma
+ stop_offset
;
3030 inf
->stop_offset
= stop_offset
;
3032 /* Extract jump information. */
3033 inf
->insn_info_valid
= 0;
3034 disassembler_in_comment
= false;
3035 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3036 /* Test if a jump was detected. */
3037 if (inf
->insn_info_valid
3038 && ((inf
->insn_type
== dis_branch
)
3039 || (inf
->insn_type
== dis_condbranch
)
3040 || (inf
->insn_type
== dis_jsr
)
3041 || (inf
->insn_type
== dis_condjsr
))
3042 && (inf
->target
>= section
->vma
+ start_offset
)
3043 && (inf
->target
< section
->vma
+ stop_offset
))
3045 struct jump_info
*ji
=
3046 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
3047 jump_info_add_front (ji
, &jumps
);
3052 addr_offset
+= octets
/ opb
;
3055 disassemble_set_printf (inf
, (void *) stdout
, (fprintf_ftype
) fprintf
,
3056 (fprintf_styled_ftype
) fprintf_styled
);
3057 free (sfile
.buffer
);
3060 jump_info_merge (&jumps
);
3061 /* Process jumps. */
3062 jump_info_sort (&jumps
);
3064 /* Group jumps by level. */
3065 struct jump_info
*last_jump
= jumps
;
3070 /* The last jump is part of the next group. */
3071 struct jump_info
*base
= last_jump
;
3072 /* Increment level. */
3073 base
->level
= ++max_level
;
3075 /* Find jumps that can be combined on the same
3076 level, with the largest jumps tested first.
3077 This has the advantage that large jumps are on
3078 lower levels and do not intersect with small
3079 jumps that get grouped on higher levels. */
3080 struct jump_info
*exchange_item
= last_jump
->next
;
3081 struct jump_info
*it
= exchange_item
;
3083 for (; it
; it
= it
->next
)
3085 /* Test if the jump intersects with any
3086 jump from current group. */
3088 struct jump_info
*it_collision
;
3090 for (it_collision
= base
;
3091 it_collision
!= exchange_item
;
3092 it_collision
= it_collision
->next
)
3094 /* This jump intersects so we leave it out. */
3095 if (jump_info_intersect (it_collision
, it
))
3102 /* Add jump to group. */
3105 /* Move current element to the front. */
3106 if (it
!= exchange_item
)
3108 struct jump_info
*save
= it
->prev
;
3109 jump_info_move_linked (it
, exchange_item
, &jumps
);
3115 last_jump
= exchange_item
;
3116 exchange_item
= exchange_item
->next
;
3118 last_jump
->level
= max_level
;
3122 /* Move to next group. */
3123 last_jump
= exchange_item
;
3129 /* The number of zeroes we want to see before we start skipping them.
3130 The number is arbitrarily chosen. */
3132 #define DEFAULT_SKIP_ZEROES 8
3134 /* The number of zeroes to skip at the end of a section. If the
3135 number of zeroes at the end is between SKIP_ZEROES_AT_END and
3136 SKIP_ZEROES, they will be disassembled. If there are fewer than
3137 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
3138 attempt to avoid disassembling zeroes inserted by section
3141 #define DEFAULT_SKIP_ZEROES_AT_END 3
3144 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
3149 /* Like null_print, but takes the extra STYLE argument. As this is not
3150 going to print anything, the extra argument is just ignored. */
3153 null_styled_print (const void * stream ATTRIBUTE_UNUSED
,
3154 enum disassembler_style style ATTRIBUTE_UNUSED
,
3155 const char * format ATTRIBUTE_UNUSED
, ...)
3160 /* Print out jump visualization. */
3163 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
3164 uint8_t *color_buffer
)
3169 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
3171 size_t line_buffer_size
= strlen (line_buffer
);
3172 char last_color
= 0;
3175 for (i
= 0; i
<= line_buffer_size
; ++i
)
3179 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
3181 if (color
!= last_color
)
3184 if (extended_color_output
)
3185 /* Use extended 8bit color, but
3186 do not choose dark colors. */
3187 printf ("\033[38;5;%dm", 124 + (color
% 108));
3189 /* Use simple terminal colors. */
3190 printf ("\033[%dm", 31 + (color
% 7));
3197 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
3201 /* Disassemble some data in memory between given values. */
3204 disassemble_bytes (struct disassemble_info
*inf
,
3205 disassembler_ftype disassemble_fn
,
3208 bfd_vma start_offset
,
3209 bfd_vma stop_offset
,
3214 struct objdump_disasm_info
*aux
;
3216 unsigned int octets_per_line
;
3217 unsigned int skip_addr_chars
;
3218 bfd_vma addr_offset
;
3219 unsigned int opb
= inf
->octets_per_byte
;
3220 unsigned int skip_zeroes
= inf
->skip_zeroes
;
3221 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
3225 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
3226 section
= inf
->section
;
3229 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
3233 octets_per_line
= insn_width
;
3235 octets_per_line
= 4;
3237 octets_per_line
= 16;
3239 /* Figure out how many characters to skip at the start of an
3240 address, to make the disassembly look nicer. We discard leading
3241 zeroes in chunks of 4, ensuring that there is always a leading
3243 skip_addr_chars
= 0;
3244 if (!no_addresses
&& !prefix_addresses
)
3248 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
3250 while (buf
[skip_addr_chars
] == '0')
3253 /* Don't discard zeros on overflow. */
3254 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
3255 skip_addr_chars
= 0;
3257 if (skip_addr_chars
!= 0)
3258 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
3261 inf
->insn_info_valid
= 0;
3263 /* Determine maximum level. */
3264 uint8_t *color_buffer
= NULL
;
3265 char *line_buffer
= NULL
;
3268 /* Some jumps were detected. */
3271 struct jump_info
*ji
;
3273 /* Find maximum jump level. */
3274 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
3276 if (ji
->level
> max_level
)
3277 max_level
= ji
->level
;
3280 /* Allocate buffers. */
3281 size_t len
= (max_level
+ 1) * 3 + 1;
3282 line_buffer
= xmalloc (len
);
3283 line_buffer
[len
- 1] = 0;
3284 color_buffer
= xmalloc (len
);
3285 color_buffer
[len
- 1] = 0;
3288 addr_offset
= start_offset
;
3289 while (addr_offset
< stop_offset
)
3291 bool need_nl
= false;
3295 /* Make sure we don't use relocs from previous instructions. */
3298 /* If we see more than SKIP_ZEROES octets of zeroes, we just
3300 if (! disassemble_zeroes
)
3301 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
3302 if (data
[addr_offset
* opb
+ octets
] != 0)
3304 if (! disassemble_zeroes
3305 && (inf
->insn_info_valid
== 0
3306 || inf
->branch_delay_insns
== 0)
3307 && (octets
>= skip_zeroes
3308 || (addr_offset
* opb
+ octets
== stop_offset
* opb
3309 && octets
< skip_zeroes_at_end
)))
3311 /* If there are more nonzero octets to follow, we only skip
3312 zeroes in multiples of 4, to try to avoid running over
3313 the start of an instruction which happens to start with
3315 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
3318 /* If we are going to display more data, and we are displaying
3319 file offsets, then tell the user how many zeroes we skip
3320 and the file offset from where we resume dumping. */
3321 if (display_file_offsets
3322 && addr_offset
+ octets
/ opb
< stop_offset
)
3323 printf (_("\t... (skipping %lu zeroes, "
3324 "resuming at file offset: 0x%lx)\n"),
3325 (unsigned long) (octets
/ opb
),
3326 (unsigned long) (section
->filepos
3327 + addr_offset
+ octets
/ opb
));
3334 unsigned int bpc
= 0;
3335 unsigned int pb
= 0;
3337 if (with_line_numbers
|| with_source_code
)
3338 show_line (aux
->abfd
, section
, addr_offset
);
3342 else if (!prefix_addresses
)
3346 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
3347 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3351 printf ("%s:\t", buf
+ skip_addr_chars
);
3355 aux
->require_sec
= true;
3356 objdump_print_address (section
->vma
+ addr_offset
, inf
);
3357 aux
->require_sec
= false;
3361 print_jump_visualisation (section
->vma
+ addr_offset
,
3362 max_level
, line_buffer
,
3370 disassemble_set_printf
3371 (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
3372 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3373 inf
->bytes_per_line
= 0;
3374 inf
->bytes_per_chunk
= 0;
3375 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
3376 | (wide_output
? WIDE_OUTPUT
: 0));
3378 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
3380 if (inf
->disassembler_needs_relocs
3381 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
3382 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
3383 && *relppp
< relppend
)
3385 bfd_signed_vma distance_to_rel
;
3386 int max_reloc_offset
3387 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
3389 distance_to_rel
= ((**relppp
)->address
- rel_offset
3393 if (distance_to_rel
> 0
3394 && (max_reloc_offset
< 0
3395 || distance_to_rel
<= max_reloc_offset
))
3397 /* This reloc *might* apply to the current insn,
3398 starting somewhere inside it. Discover the length
3399 of the current insn so that the check below will
3402 insn_size
= insn_width
;
3405 /* We find the length by calling the dissassembler
3406 function with a dummy print handler. This should
3407 work unless the disassembler is not expecting to
3408 be called multiple times for the same address.
3410 This does mean disassembling the instruction
3411 twice, but we only do this when there is a high
3412 probability that there is a reloc that will
3413 affect the instruction. */
3414 disassemble_set_printf
3415 (inf
, inf
->stream
, (fprintf_ftype
) null_print
,
3416 (fprintf_styled_ftype
) null_styled_print
);
3417 insn_size
= disassemble_fn (section
->vma
3418 + addr_offset
, inf
);
3419 disassemble_set_printf
3421 (fprintf_ftype
) objdump_sprintf
,
3422 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3426 /* Check to see if the current reloc is associated with
3427 the instruction that we are about to disassemble. */
3428 if (distance_to_rel
== 0
3429 || (distance_to_rel
> 0
3430 && distance_to_rel
< insn_size
/ (int) opb
))
3432 inf
->flags
|= INSN_HAS_RELOC
;
3433 aux
->reloc
= **relppp
;
3437 if (! disassemble_all
3438 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3439 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3440 /* Set a stop_vma so that the disassembler will not read
3441 beyond the next symbol. We assume that symbols appear on
3442 the boundaries between instructions. We only do this when
3443 disassembling code of course, and when -D is in effect. */
3444 inf
->stop_vma
= section
->vma
+ stop_offset
;
3446 inf
->stop_offset
= stop_offset
;
3447 disassembler_in_comment
= false;
3448 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3452 disassemble_set_printf (inf
, stdout
, (fprintf_ftype
) fprintf
,
3453 (fprintf_styled_ftype
) fprintf_styled
);
3454 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3455 octets_per_line
= inf
->bytes_per_line
;
3456 if (insn_size
< (int) opb
)
3459 printf ("%s\n", sfile
.buffer
);
3462 non_fatal (_("disassemble_fn returned length %d"),
3473 octets
= octets_per_line
;
3474 if (addr_offset
+ octets
/ opb
> stop_offset
)
3475 octets
= (stop_offset
- addr_offset
) * opb
;
3477 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3479 if (ISPRINT (data
[j
]))
3480 buf
[j
- addr_offset
* opb
] = data
[j
];
3482 buf
[j
- addr_offset
* opb
] = '.';
3484 buf
[j
- addr_offset
* opb
] = '\0';
3487 if (prefix_addresses
3489 : show_raw_insn
>= 0)
3493 /* If ! prefix_addresses and ! wide_output, we print
3494 octets_per_line octets per line. */
3496 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3497 pb
= octets_per_line
;
3499 if (inf
->bytes_per_chunk
)
3500 bpc
= inf
->bytes_per_chunk
;
3504 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3506 /* PR 21580: Check for a buffer ending early. */
3507 if (j
+ bpc
<= stop_offset
* opb
)
3511 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3513 for (k
= bpc
; k
-- != 0; )
3514 printf ("%02x", (unsigned) data
[j
+ k
]);
3518 for (k
= 0; k
< bpc
; k
++)
3519 printf ("%02x", (unsigned) data
[j
+ k
]);
3525 for (; pb
< octets_per_line
; pb
+= bpc
)
3529 for (k
= 0; k
< bpc
; k
++)
3534 /* Separate raw data from instruction by extra space. */
3544 printf ("%s", sfile
.buffer
);
3546 if (prefix_addresses
3548 : show_raw_insn
>= 0)
3556 j
= addr_offset
* opb
+ pb
;
3562 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3563 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3567 printf ("%s:\t", buf
+ skip_addr_chars
);
3570 print_jump_visualisation (section
->vma
+ j
/ opb
,
3571 max_level
, line_buffer
,
3574 pb
+= octets_per_line
;
3577 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3579 /* PR 21619: Check for a buffer ending early. */
3580 if (j
+ bpc
<= stop_offset
* opb
)
3584 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3586 for (k
= bpc
; k
-- != 0; )
3587 printf ("%02x", (unsigned) data
[j
+ k
]);
3591 for (k
= 0; k
< bpc
; k
++)
3592 printf ("%02x", (unsigned) data
[j
+ k
]);
3606 while ((*relppp
) < relppend
3607 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3609 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3622 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3627 if (q
->howto
== NULL
)
3628 printf ("*unknown*\t");
3629 else if (q
->howto
->name
)
3630 printf ("%s\t", q
->howto
->name
);
3632 printf ("%d\t", q
->howto
->type
);
3634 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3635 printf ("*unknown*");
3638 const char *sym_name
;
3640 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3641 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3642 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3647 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3648 sym_name
= bfd_section_name (sym_sec
);
3649 if (sym_name
== NULL
|| *sym_name
== '\0')
3650 sym_name
= "*unknown*";
3651 printf ("%s", sanitize_string (sym_name
));
3657 bfd_vma addend
= q
->addend
;
3658 if ((bfd_signed_vma
) addend
< 0)
3665 objdump_print_value (addend
, inf
, true);
3677 addr_offset
+= octets
/ opb
;
3680 free (sfile
.buffer
);
3682 free (color_buffer
);
3686 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3688 const struct elf_backend_data
*bed
;
3689 bfd_vma sign_adjust
= 0;
3690 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3691 struct objdump_disasm_info
*paux
;
3692 unsigned int opb
= pinfo
->octets_per_byte
;
3693 bfd_byte
*data
= NULL
;
3694 bfd_size_type datasize
= 0;
3695 arelent
**rel_pp
= NULL
;
3696 arelent
**rel_ppstart
= NULL
;
3697 arelent
**rel_ppend
;
3698 bfd_vma stop_offset
;
3699 asymbol
*sym
= NULL
;
3703 unsigned long addr_offset
;
3707 stop_offset_reached
,
3712 /* Sections that do not contain machine
3713 code are not normally disassembled. */
3714 if (! disassemble_all
3715 && only_list
== NULL
3716 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3717 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3720 if (! process_section_p (section
))
3723 datasize
= bfd_section_size (section
);
3727 if (start_address
== (bfd_vma
) -1
3728 || start_address
< section
->vma
)
3731 addr_offset
= start_address
- section
->vma
;
3733 if (stop_address
== (bfd_vma
) -1)
3734 stop_offset
= datasize
/ opb
;
3737 if (stop_address
< section
->vma
)
3740 stop_offset
= stop_address
- section
->vma
;
3741 if (stop_offset
> datasize
/ opb
)
3742 stop_offset
= datasize
/ opb
;
3745 if (addr_offset
>= stop_offset
)
3748 /* Decide which set of relocs to use. Load them if necessary. */
3749 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3750 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3752 rel_pp
= pinfo
->dynrelbuf
;
3753 rel_count
= pinfo
->dynrelcount
;
3754 /* Dynamic reloc addresses are absolute, non-dynamic are section
3755 relative. REL_OFFSET specifies the reloc address corresponding
3756 to the start of this section. */
3757 rel_offset
= section
->vma
;
3765 if ((section
->flags
& SEC_RELOC
) != 0
3766 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3770 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3772 bfd_fatal (bfd_get_filename (abfd
));
3776 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3777 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3779 bfd_fatal (bfd_get_filename (abfd
));
3781 /* Sort the relocs by address. */
3782 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3786 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3788 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3790 non_fatal (_("Reading section %s failed because: %s"),
3791 section
->name
, bfd_errmsg (bfd_get_error ()));
3795 pinfo
->buffer
= data
;
3796 pinfo
->buffer_vma
= section
->vma
;
3797 pinfo
->buffer_length
= datasize
;
3798 pinfo
->section
= section
;
3800 /* Sort the symbols into value and section order. */
3801 compare_section
= section
;
3802 if (sorted_symcount
> 1)
3803 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3805 /* Skip over the relocs belonging to addresses below the
3807 while (rel_pp
< rel_ppend
3808 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3811 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3813 /* Find the nearest symbol forwards from our current position. */
3814 paux
->require_sec
= true;
3815 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3816 (struct disassemble_info
*) inf
,
3818 paux
->require_sec
= false;
3820 /* PR 9774: If the target used signed addresses then we must make
3821 sure that we sign extend the value that we calculate for 'addr'
3822 in the loop below. */
3823 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3824 && (bed
= get_elf_backend_data (abfd
)) != NULL
3825 && bed
->sign_extend_vma
)
3826 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3828 /* Disassemble a block of instructions up to the address associated with
3829 the symbol we have just found. Then print the symbol and find the
3830 next symbol on. Repeat until we have disassembled the entire section
3831 or we have reached the end of the address range we are interested in. */
3832 do_print
= paux
->symbol
== NULL
;
3833 loop_until
= stop_offset_reached
;
3835 while (addr_offset
< stop_offset
)
3839 bfd_vma nextstop_offset
;
3842 addr
= section
->vma
+ addr_offset
;
3843 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3845 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3850 (x
< sorted_symcount
3851 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3855 pinfo
->symbols
= sorted_syms
+ place
;
3856 pinfo
->num_symbols
= x
- place
;
3857 pinfo
->symtab_pos
= place
;
3861 pinfo
->symbols
= NULL
;
3862 pinfo
->num_symbols
= 0;
3863 pinfo
->symtab_pos
= -1;
3866 /* If we are only disassembling from a specific symbol,
3867 check to see if we should start or stop displaying. */
3868 if (sym
&& paux
->symbol
)
3872 /* See if we should stop printing. */
3876 if (sym
->flags
& BSF_FUNCTION
)
3880 case stop_offset_reached
:
3881 /* Handled by the while loop. */
3885 /* FIXME: There is an implicit assumption here
3886 that the name of sym is different from
3888 if (! bfd_is_local_label (abfd
, sym
))
3895 const char * name
= bfd_asymbol_name (sym
);
3896 char * alloc
= NULL
;
3898 if (do_demangle
&& name
[0] != '\0')
3900 /* Demangle the name. */
3901 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3906 /* We are not currently printing. Check to see
3907 if the current symbol matches the requested symbol. */
3908 if (streq (name
, paux
->symbol
))
3912 if (sym
->flags
& BSF_FUNCTION
)
3914 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3915 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3917 /* Sym is a function symbol with a size associated
3918 with it. Turn on automatic disassembly for the
3919 next VALUE bytes. */
3920 stop_offset
= addr_offset
3921 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3922 loop_until
= stop_offset_reached
;
3926 /* Otherwise we need to tell the loop heuristic to
3927 loop until the next function symbol is encountered. */
3928 loop_until
= function_sym
;
3933 /* Otherwise loop until the next symbol is encountered. */
3934 loop_until
= next_sym
;
3942 if (! prefix_addresses
&& do_print
)
3944 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3945 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3947 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3950 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3952 else if (sym
== NULL
)
3956 #define is_valid_next_sym(SYM) \
3957 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3958 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3959 && pinfo->symbol_is_valid (SYM, pinfo))
3961 /* Search forward for the next appropriate symbol in
3962 SECTION. Note that all the symbols are sorted
3963 together into one big array, and that some sections
3964 may have overlapping addresses. */
3965 while (place
< sorted_symcount
3966 && ! is_valid_next_sym (sorted_syms
[place
]))
3969 if (place
>= sorted_symcount
)
3972 nextsym
= sorted_syms
[place
];
3975 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3976 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3977 else if (nextsym
== NULL
)
3978 nextstop_offset
= stop_offset
;
3980 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3982 if (nextstop_offset
> stop_offset
3983 || nextstop_offset
<= addr_offset
)
3984 nextstop_offset
= stop_offset
;
3986 /* If a symbol is explicitly marked as being an object
3987 rather than a function, just dump the bytes without
3988 disassembling them. */
3991 || sym
->section
!= section
3992 || bfd_asymbol_value (sym
) > addr
3993 || ((sym
->flags
& BSF_OBJECT
) == 0
3994 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3996 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3998 || (sym
->flags
& BSF_FUNCTION
) != 0)
4005 /* Resolve symbol name. */
4006 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
4008 struct disassemble_info di
;
4011 sf
.alloc
= strlen (sym
->name
) + 40;
4012 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
4014 disassemble_set_printf
4015 (&di
, &sf
, (fprintf_ftype
) objdump_sprintf
,
4016 (fprintf_styled_ftype
) objdump_styled_sprintf
);
4018 objdump_print_symname (abfd
, &di
, sym
);
4020 /* Fetch jump information. */
4021 detected_jumps
= disassemble_jumps
4022 (pinfo
, paux
->disassemble_fn
,
4023 addr_offset
, nextstop_offset
,
4024 rel_offset
, &rel_pp
, rel_ppend
);
4026 /* Free symbol name. */
4030 /* Add jumps to output. */
4031 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
4032 addr_offset
, nextstop_offset
,
4033 rel_offset
, &rel_pp
, rel_ppend
);
4036 while (detected_jumps
)
4038 detected_jumps
= jump_info_free (detected_jumps
);
4042 addr_offset
= nextstop_offset
;
4048 if (rel_ppstart
!= NULL
)
4052 /* Disassemble the contents of an object file. */
4055 disassemble_data (bfd
*abfd
)
4057 struct disassemble_info disasm_info
;
4058 struct objdump_disasm_info aux
;
4062 prev_functionname
= NULL
;
4064 prev_discriminator
= 0;
4066 /* We make a copy of syms to sort. We don't want to sort syms
4067 because that will screw up the relocs. */
4068 sorted_symcount
= symcount
? symcount
: dynsymcount
;
4069 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
4070 * sizeof (asymbol
*));
4071 if (sorted_symcount
!= 0)
4073 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
4074 sorted_symcount
* sizeof (asymbol
*));
4076 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
4079 for (i
= 0; i
< synthcount
; ++i
)
4081 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
4085 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
,
4086 (fprintf_styled_ftype
) fprintf_styled
);
4087 disasm_info
.application_data
= (void *) &aux
;
4089 aux
.require_sec
= false;
4090 disasm_info
.dynrelbuf
= NULL
;
4091 disasm_info
.dynrelcount
= 0;
4093 aux
.symbol
= disasm_sym
;
4095 disasm_info
.print_address_func
= objdump_print_address
;
4096 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
4098 if (machine
!= NULL
)
4100 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
4103 fatal (_("can't use supplied machine %s"), machine
);
4105 abfd
->arch_info
= inf
;
4108 if (endian
!= BFD_ENDIAN_UNKNOWN
)
4110 struct bfd_target
*xvec
;
4112 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
4113 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
4114 xvec
->byteorder
= endian
;
4118 /* Use libopcodes to locate a suitable disassembler. */
4119 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
4120 bfd_big_endian (abfd
),
4121 bfd_get_mach (abfd
), abfd
);
4122 if (!aux
.disassemble_fn
)
4124 non_fatal (_("can't disassemble for architecture %s\n"),
4125 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
4130 disasm_info
.flavour
= bfd_get_flavour (abfd
);
4131 disasm_info
.arch
= bfd_get_arch (abfd
);
4132 disasm_info
.mach
= bfd_get_mach (abfd
);
4133 disasm_info
.disassembler_options
= disassembler_options
;
4134 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
4135 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
4136 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
4137 disasm_info
.disassembler_needs_relocs
= false;
4139 if (bfd_big_endian (abfd
))
4140 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
4141 else if (bfd_little_endian (abfd
))
4142 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
4144 /* ??? Aborting here seems too drastic. We could default to big or little
4146 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
4148 disasm_info
.endian_code
= disasm_info
.endian
;
4150 /* Allow the target to customize the info structure. */
4151 disassemble_init_for_target (& disasm_info
);
4153 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
4154 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4156 if (relsize
< 0 && dump_dynamic_reloc_info
)
4157 bfd_fatal (bfd_get_filename (abfd
));
4161 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
4162 disasm_info
.dynrelcount
4163 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
4164 if (disasm_info
.dynrelcount
< 0)
4165 bfd_fatal (bfd_get_filename (abfd
));
4167 /* Sort the relocs by address. */
4168 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
4172 disasm_info
.symtab
= sorted_syms
;
4173 disasm_info
.symtab_size
= sorted_symcount
;
4175 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
4177 free (disasm_info
.dynrelbuf
);
4178 disasm_info
.dynrelbuf
= NULL
;
4180 disassemble_free_target (&disasm_info
);
4184 load_specific_debug_section (enum dwarf_section_display_enum debug
,
4185 asection
*sec
, void *file
)
4187 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4188 bfd
*abfd
= (bfd
*) file
;
4194 if (section
->start
!= NULL
)
4196 /* If it is already loaded, do nothing. */
4197 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4199 free (section
->start
);
4202 section
->filename
= bfd_get_filename (abfd
);
4203 section
->reloc_info
= NULL
;
4204 section
->num_relocs
= 0;
4205 section
->address
= bfd_section_vma (sec
);
4206 section
->size
= bfd_section_size (sec
);
4207 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
4208 alloced
= amt
= section
->size
+ 1;
4209 if (alloced
!= amt
|| alloced
== 0)
4211 section
->start
= NULL
;
4212 free_debug_section (debug
);
4213 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
4214 sanitize_string (section
->name
),
4215 (unsigned long long) section
->size
);
4219 section
->start
= contents
= xmalloc (alloced
);
4220 /* Ensure any string section has a terminating NUL. */
4221 section
->start
[section
->size
] = 0;
4223 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4224 && debug_displays
[debug
].relocate
)
4226 ret
= bfd_simple_get_relocated_section_contents (abfd
,
4232 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
4239 relocs
= (arelent
**) xmalloc (reloc_size
);
4241 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
4242 if (reloc_count
<= 0)
4246 section
->reloc_info
= relocs
;
4247 section
->num_relocs
= reloc_count
;
4253 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
4257 free_debug_section (debug
);
4258 printf (_("\nCan't get contents for section '%s'.\n"),
4259 sanitize_string (section
->name
));
4267 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
4272 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
4275 relocs
= (arelent
**) dsec
->reloc_info
;
4277 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
4278 if (rp
->address
== offset
)
4285 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
4287 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4288 bfd
*abfd
= (bfd
*) file
;
4292 if (!dump_any_debugging
)
4295 /* If it is already loaded, do nothing. */
4296 if (section
->start
!= NULL
)
4298 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4301 /* Locate the debug section. */
4302 name
= section
->uncompressed_name
;
4303 sec
= bfd_get_section_by_name (abfd
, name
);
4306 name
= section
->compressed_name
;
4308 sec
= bfd_get_section_by_name (abfd
, name
);
4312 name
= section
->xcoff_name
;
4314 sec
= bfd_get_section_by_name (abfd
, name
);
4319 section
->name
= name
;
4320 return load_specific_debug_section (debug
, sec
, file
);
4324 free_debug_section (enum dwarf_section_display_enum debug
)
4326 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4328 free ((char *) section
->start
);
4329 section
->start
= NULL
;
4330 section
->address
= 0;
4332 free ((char*) section
->reloc_info
);
4333 section
->reloc_info
= NULL
;
4334 section
->num_relocs
= 0;
4338 close_debug_file (void * file
)
4340 bfd
* abfd
= (bfd
*) file
;
4346 open_debug_file (const char * pathname
)
4350 data
= bfd_openr (pathname
, NULL
);
4354 if (! bfd_check_format (data
, bfd_object
))
4361 dump_dwarf_section (bfd
*abfd
, asection
*section
,
4364 const char *name
= bfd_section_name (section
);
4367 bool is_mainfile
= *(bool *) arg
;
4372 if (!is_mainfile
&& !process_links
4373 && (section
->flags
& SEC_DEBUGGING
) == 0)
4376 if (startswith (name
, ".gnu.linkonce.wi."))
4377 match
= ".debug_info";
4381 for (i
= 0; i
< max
; i
++)
4382 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
4383 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
4384 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
4385 && debug_displays
[i
].enabled
!= NULL
4386 && *debug_displays
[i
].enabled
)
4388 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
4390 if (strcmp (sec
->uncompressed_name
, match
) == 0)
4391 sec
->name
= sec
->uncompressed_name
;
4392 else if (strcmp (sec
->compressed_name
, match
) == 0)
4393 sec
->name
= sec
->compressed_name
;
4395 sec
->name
= sec
->xcoff_name
;
4396 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
4399 debug_displays
[i
].display (sec
, abfd
);
4401 if (i
!= info
&& i
!= abbrev
)
4402 free_debug_section ((enum dwarf_section_display_enum
) i
);
4408 /* Dump the dwarf debugging information. */
4411 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4413 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4414 if (byte_get
== NULL
)
4416 warn (_("File %s does not contain any dwarf debug information\n"),
4417 bfd_get_filename (abfd
));
4421 switch (bfd_get_arch (abfd
))
4424 /* S12Z has a 24 bit address space. But the only known
4425 producer of dwarf_info encodes addresses into 32 bits. */
4430 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4434 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4435 bfd_get_mach (abfd
));
4437 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4440 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
4441 it. Return NULL on failure. */
4444 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4445 bfd_size_type
*entsize_ptr
)
4450 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
4451 if (stabsect
== NULL
)
4453 printf (_("No %s section present\n\n"),
4454 sanitize_string (sect_name
));
4458 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
4460 non_fatal (_("reading %s section of %s failed: %s"),
4461 sect_name
, bfd_get_filename (abfd
),
4462 bfd_errmsg (bfd_get_error ()));
4468 *size_ptr
= bfd_section_size (stabsect
);
4470 *entsize_ptr
= stabsect
->entsize
;
4475 /* Stabs entries use a 12 byte format:
4476 4 byte string table index
4478 1 byte stab other field
4479 2 byte stab desc field
4481 FIXME: This will have to change for a 64 bit object format. */
4483 #define STRDXOFF (0)
4485 #define OTHEROFF (5)
4488 #define STABSIZE (12)
4490 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4491 using string table section STRSECT_NAME (in `strtab'). */
4494 print_section_stabs (bfd
*abfd
,
4495 const char *stabsect_name
,
4496 unsigned *string_offset_ptr
)
4499 unsigned file_string_table_offset
= 0;
4500 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4501 bfd_byte
*stabp
, *stabs_end
;
4504 stabs_end
= stabp
+ stab_size
;
4506 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4507 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4509 /* Loop through all symbols and print them.
4511 We start the index at -1 because there is a dummy symbol on
4512 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4513 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
4517 unsigned char type
, other
;
4518 unsigned short desc
;
4521 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4522 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4523 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4524 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4525 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4527 printf ("\n%-6d ", i
);
4528 /* Either print the stab name, or, if unnamed, print its number
4529 again (makes consistent formatting for tools like awk). */
4530 name
= bfd_get_stab_name (type
);
4532 printf ("%-6s", sanitize_string (name
));
4533 else if (type
== N_UNDF
)
4536 printf ("%-6d", type
);
4537 printf (" %-6d %-6d ", other
, desc
);
4538 bfd_printf_vma (abfd
, value
);
4539 printf (" %-6lu", strx
);
4541 /* Symbols with type == 0 (N_UNDF) specify the length of the
4542 string table associated with this file. We use that info
4543 to know how to relocate the *next* file's string table indices. */
4546 file_string_table_offset
= next_file_string_table_offset
;
4547 next_file_string_table_offset
+= value
;
4551 bfd_size_type amt
= strx
+ file_string_table_offset
;
4553 /* Using the (possibly updated) string table offset, print the
4554 string (if any) associated with this symbol. */
4555 if (amt
< stabstr_size
)
4556 /* PR 17512: file: 079-79389-0.001:0.1.
4557 FIXME: May need to sanitize this string before displaying. */
4558 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4564 *string_offset_ptr
= next_file_string_table_offset
;
4569 const char * section_name
;
4570 const char * string_section_name
;
4571 unsigned string_offset
;
4576 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4579 stab_section_names
* sought
= (stab_section_names
*) names
;
4581 /* Check for section names for which stabsect_name is a prefix, to
4582 handle .stab.N, etc. */
4583 len
= strlen (sought
->section_name
);
4585 /* If the prefix matches, and the files section name ends with a
4586 nul or a digit, then we match. I.e., we want either an exact
4587 match or a section followed by a number. */
4588 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4589 && (section
->name
[len
] == 0
4590 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4593 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
4594 &stabstr_size
, NULL
);
4598 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
4600 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4606 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4608 stab_section_names s
;
4610 s
.section_name
= stabsect_name
;
4611 s
.string_section_name
= strsect_name
;
4612 s
.string_offset
= 0;
4614 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4620 /* Dump the any sections containing stabs debugging information. */
4623 dump_stabs (bfd
*abfd
)
4625 dump_stabs_section (abfd
, ".stab", ".stabstr");
4626 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4627 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4630 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4632 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4636 dump_bfd_header (bfd
*abfd
)
4640 printf (_("architecture: %s, "),
4641 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4642 bfd_get_mach (abfd
)));
4643 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4645 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4646 PF (HAS_RELOC
, "HAS_RELOC");
4647 PF (EXEC_P
, "EXEC_P");
4648 PF (HAS_LINENO
, "HAS_LINENO");
4649 PF (HAS_DEBUG
, "HAS_DEBUG");
4650 PF (HAS_SYMS
, "HAS_SYMS");
4651 PF (HAS_LOCALS
, "HAS_LOCALS");
4652 PF (DYNAMIC
, "DYNAMIC");
4653 PF (WP_TEXT
, "WP_TEXT");
4654 PF (D_PAGED
, "D_PAGED");
4655 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4656 printf (_("\nstart address 0x"));
4657 bfd_printf_vma (abfd
, abfd
->start_address
);
4662 #ifdef ENABLE_LIBCTF
4663 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4664 it is passed, or a pointer to newly-allocated storage, in which case
4665 dump_ctf() will free it when it no longer needs it. */
4668 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4671 const char *blanks
= arg
;
4674 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4679 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4681 make_ctfsect (const char *name
, bfd_byte
*data
,
4686 ctfsect
.cts_name
= name
;
4687 ctfsect
.cts_entsize
= 1;
4688 ctfsect
.cts_size
= size
;
4689 ctfsect
.cts_data
= data
;
4694 /* Dump CTF errors/warnings. */
4696 dump_ctf_errs (ctf_dict_t
*fp
)
4698 ctf_next_t
*it
= NULL
;
4703 /* Dump accumulated errors and warnings. */
4704 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4706 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4710 if (err
!= ECTF_NEXT_END
)
4712 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4717 /* Dump one CTF archive member. */
4720 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4723 const char *things
[] = {"Header", "Labels", "Data objects",
4724 "Function objects", "Variables", "Types", "Strings",
4729 /* Don't print out the name of the default-named archive member if it appears
4730 first in the list. The name .ctf appears everywhere, even for things that
4731 aren't really archives, so printing it out is liable to be confusing; also,
4732 the common case by far is for only one archive member to exist, and hiding
4733 it in that case seems worthwhile. */
4735 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4736 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4738 if (ctf_parent_name (ctf
) != NULL
)
4739 ctf_import (ctf
, parent
);
4741 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4743 ctf_dump_state_t
*s
= NULL
;
4746 printf ("\n %s:\n", *thing
);
4747 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4748 (void *) " ")) != NULL
)
4750 printf ("%s\n", item
);
4754 if (ctf_errno (ctf
))
4756 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4757 ctf_errmsg (ctf_errno (ctf
)));
4762 dump_ctf_errs (ctf
);
4765 /* Dump the CTF debugging information. */
4768 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4770 ctf_archive_t
*ctfa
= NULL
;
4771 bfd_byte
*ctfdata
= NULL
;
4772 bfd_size_type ctfsize
;
4776 ctf_next_t
*i
= NULL
;
4781 if (sect_name
== NULL
)
4784 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4785 bfd_fatal (bfd_get_filename (abfd
));
4787 /* Load the CTF file and dump it. Preload the parent dict, since it will
4788 need to be imported into every child in turn. */
4790 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4791 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4793 dump_ctf_errs (NULL
);
4794 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4795 bfd_fatal (bfd_get_filename (abfd
));
4798 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4800 dump_ctf_errs (NULL
);
4801 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4802 bfd_fatal (bfd_get_filename (abfd
));
4805 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4807 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4808 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4809 if (err
!= ECTF_NEXT_END
)
4811 dump_ctf_errs (NULL
);
4812 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4813 bfd_fatal (bfd_get_filename (abfd
));
4815 ctf_dict_close (parent
);
4821 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4822 const char *parent_name ATTRIBUTE_UNUSED
) {}
4826 read_section_sframe (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4827 bfd_vma
*sframe_vma
)
4829 asection
*sframe_sect
;
4832 sframe_sect
= bfd_get_section_by_name (abfd
, sect_name
);
4833 if (sframe_sect
== NULL
)
4835 printf (_("No %s section present\n\n"),
4836 sanitize_string (sect_name
));
4840 if (!bfd_malloc_and_get_section (abfd
, sframe_sect
, &contents
))
4842 non_fatal (_("reading %s section of %s failed: %s"),
4843 sect_name
, bfd_get_filename (abfd
),
4844 bfd_errmsg (bfd_get_error ()));
4850 *size_ptr
= bfd_section_size (sframe_sect
);
4851 *sframe_vma
= bfd_section_vma (sframe_sect
);
4857 dump_section_sframe (bfd
*abfd ATTRIBUTE_UNUSED
,
4858 const char * sect_name
)
4860 sframe_decoder_ctx
*sfd_ctx
= NULL
;
4861 bfd_size_type sf_size
;
4862 bfd_byte
*sframe_data
= NULL
;
4866 if (sect_name
== NULL
)
4867 sect_name
= ".sframe";
4869 sframe_data
= read_section_sframe (abfd
, sect_name
, &sf_size
, &sf_vma
);
4871 if (sframe_data
== NULL
)
4872 bfd_fatal (bfd_get_filename (abfd
));
4874 /* Decode the contents of the section. */
4875 sfd_ctx
= sframe_decode ((const char*)sframe_data
, sf_size
, &err
);
4877 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
);
4887 dump_bfd_private_header (bfd
*abfd
)
4889 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4890 non_fatal (_("warning: private headers incomplete: %s"),
4891 bfd_errmsg (bfd_get_error ()));
4895 dump_target_specific (bfd
*abfd
)
4897 const struct objdump_private_desc
* const *desc
;
4898 struct objdump_private_option
*opt
;
4901 /* Find the desc. */
4902 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4903 if ((*desc
)->filter (abfd
))
4908 non_fatal (_("option -P/--private not supported by this file"));
4912 /* Clear all options. */
4913 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4914 opt
->selected
= false;
4916 /* Decode options. */
4917 b
= dump_private_options
;
4920 e
= strchr (b
, ',');
4925 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4926 if (strcmp (opt
->name
, b
) == 0)
4928 opt
->selected
= true;
4931 if (opt
->name
== NULL
)
4932 non_fatal (_("target specific dump '%s' not supported"), b
);
4943 (*desc
)->dump (abfd
);
4946 /* Display a section in hexadecimal format with associated characters.
4947 Each line prefixed by the zero padded address. */
4950 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4952 bfd_byte
*data
= NULL
;
4953 bfd_size_type datasize
;
4954 bfd_vma addr_offset
;
4955 bfd_vma start_offset
;
4956 bfd_vma stop_offset
;
4957 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4958 /* Bytes per line. */
4959 const int onaline
= 16;
4964 if (! process_section_p (section
))
4967 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4970 if ((datasize
= bfd_section_size (section
)) == 0)
4973 /* Compute the address range to display. */
4974 if (start_address
== (bfd_vma
) -1
4975 || start_address
< section
->vma
)
4978 start_offset
= start_address
- section
->vma
;
4980 if (stop_address
== (bfd_vma
) -1)
4981 stop_offset
= datasize
/ opb
;
4984 if (stop_address
< section
->vma
)
4987 stop_offset
= stop_address
- section
->vma
;
4989 if (stop_offset
> datasize
/ opb
)
4990 stop_offset
= datasize
/ opb
;
4993 if (start_offset
>= stop_offset
)
4996 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4997 if (display_file_offsets
)
4998 printf (_(" (Starting at file offset: 0x%lx)"),
4999 (unsigned long) (section
->filepos
+ start_offset
));
5002 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
5004 non_fatal (_("Reading section %s failed because: %s"),
5005 section
->name
, bfd_errmsg (bfd_get_error ()));
5011 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
5012 if (strlen (buf
) >= sizeof (buf
))
5016 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5018 count
= strlen (buf
) - count
;
5022 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
5023 if (strlen (buf
) >= sizeof (buf
))
5027 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
5029 count
= strlen (buf
) - count
;
5033 for (addr_offset
= start_offset
;
5034 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
5038 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
5039 count
= strlen (buf
);
5040 if ((size_t) count
>= sizeof (buf
))
5044 while (count
< width
)
5049 fputs (buf
+ count
- width
, stdout
);
5052 for (j
= addr_offset
* opb
;
5053 j
< addr_offset
* opb
+ onaline
; j
++)
5055 if (j
< stop_offset
* opb
)
5056 printf ("%02x", (unsigned) (data
[j
]));
5064 for (j
= addr_offset
* opb
;
5065 j
< addr_offset
* opb
+ onaline
; j
++)
5067 if (j
>= stop_offset
* opb
)
5070 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
5077 /* Actually display the various requested regions. */
5080 dump_data (bfd
*abfd
)
5082 bfd_map_over_sections (abfd
, dump_section
, NULL
);
5085 /* Should perhaps share code and display with nm? */
5088 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
5097 max_count
= dynsymcount
;
5098 printf ("DYNAMIC SYMBOL TABLE:\n");
5103 max_count
= symcount
;
5104 printf ("SYMBOL TABLE:\n");
5108 printf (_("no symbols\n"));
5110 for (count
= 0; count
< max_count
; count
++)
5114 if (*current
== NULL
)
5115 printf (_("no information for symbol number %ld\n"), count
);
5117 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
5118 printf (_("could not determine the type of symbol number %ld\n"),
5121 else if (process_section_p ((* current
)->section
)
5122 && (dump_special_syms
5123 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
5125 const char *name
= (*current
)->name
;
5127 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
5131 /* If we want to demangle the name, we demangle it
5132 here, and temporarily clobber it while calling
5133 bfd_print_symbol. FIXME: This is a gross hack. */
5134 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
5136 (*current
)->name
= alloc
;
5137 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5138 bfd_print_symbol_all
);
5141 (*current
)->name
= name
;
5145 else if (unicode_display
!= unicode_default
5146 && name
!= NULL
&& *name
!= '\0')
5148 const char * sanitized_name
;
5150 /* If we want to sanitize the name, we do it here, and
5151 temporarily clobber it while calling bfd_print_symbol.
5152 FIXME: This is a gross hack. */
5153 sanitized_name
= sanitize_string (name
);
5154 if (sanitized_name
!= name
)
5155 (*current
)->name
= sanitized_name
;
5157 sanitized_name
= NULL
;
5158 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5159 bfd_print_symbol_all
);
5160 if (sanitized_name
!= NULL
)
5161 (*current
)->name
= name
;
5164 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5165 bfd_print_symbol_all
);
5175 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
5178 char *last_filename
, *last_functionname
;
5179 unsigned int last_line
;
5180 unsigned int last_discriminator
;
5182 /* Get column headers lined up reasonably. */
5190 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
5191 width
= strlen (buf
) - 7;
5193 printf ("OFFSET %*s TYPE %*s VALUE\n", width
, "", 12, "");
5196 last_filename
= NULL
;
5197 last_functionname
= NULL
;
5199 last_discriminator
= 0;
5201 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
5204 const char *filename
, *functionname
;
5205 unsigned int linenumber
;
5206 unsigned int discriminator
;
5207 const char *sym_name
;
5208 const char *section_name
;
5209 bfd_vma addend2
= 0;
5211 if (start_address
!= (bfd_vma
) -1
5212 && q
->address
< start_address
)
5214 if (stop_address
!= (bfd_vma
) -1
5215 && q
->address
> stop_address
)
5218 if (with_line_numbers
5220 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
5221 &filename
, &functionname
,
5222 &linenumber
, &discriminator
))
5224 if (functionname
!= NULL
5225 && (last_functionname
== NULL
5226 || strcmp (functionname
, last_functionname
) != 0))
5228 printf ("%s():\n", sanitize_string (functionname
));
5229 if (last_functionname
!= NULL
)
5230 free (last_functionname
);
5231 last_functionname
= xstrdup (functionname
);
5235 && (linenumber
!= last_line
5236 || (filename
!= NULL
5237 && last_filename
!= NULL
5238 && filename_cmp (filename
, last_filename
) != 0)
5239 || (discriminator
!= last_discriminator
)))
5241 if (discriminator
> 0)
5242 printf ("%s:%u\n", filename
== NULL
? "???" :
5243 sanitize_string (filename
), linenumber
);
5245 printf ("%s:%u (discriminator %u)\n",
5246 filename
== NULL
? "???" : sanitize_string (filename
),
5247 linenumber
, discriminator
);
5248 last_line
= linenumber
;
5249 last_discriminator
= discriminator
;
5250 if (last_filename
!= NULL
)
5251 free (last_filename
);
5252 if (filename
== NULL
)
5253 last_filename
= NULL
;
5255 last_filename
= xstrdup (filename
);
5259 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
5261 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
5262 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
5267 section_name
= NULL
;
5270 bfd_printf_vma (abfd
, q
->address
);
5271 if (q
->howto
== NULL
)
5272 printf (" *unknown* ");
5273 else if (q
->howto
->name
)
5275 const char *name
= q
->howto
->name
;
5277 /* R_SPARC_OLO10 relocations contain two addends.
5278 But because 'arelent' lacks enough storage to
5279 store them both, the 64-bit ELF Sparc backend
5280 records this as two relocations. One R_SPARC_LO10
5281 and one R_SPARC_13, both pointing to the same
5282 address. This is merely so that we have some
5283 place to store both addend fields.
5285 Undo this transformation, otherwise the output
5286 will be confusing. */
5287 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
5288 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
5290 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
5292 arelent
*q2
= *(p
+ 1);
5295 && q
->address
== q2
->address
5296 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
5298 name
= "R_SPARC_OLO10";
5299 addend2
= q2
->addend
;
5303 printf (" %-16s ", name
);
5306 printf (" %-16d ", q
->howto
->type
);
5310 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
5314 if (section_name
== NULL
)
5315 section_name
= "*unknown*";
5316 printf ("[%s]", sanitize_string (section_name
));
5321 bfd_signed_vma addend
= q
->addend
;
5329 bfd_printf_vma (abfd
, addend
);
5334 bfd_printf_vma (abfd
, addend2
);
5340 if (last_filename
!= NULL
)
5341 free (last_filename
);
5342 if (last_functionname
!= NULL
)
5343 free (last_functionname
);
5347 dump_relocs_in_section (bfd
*abfd
,
5349 void *dummy ATTRIBUTE_UNUSED
)
5351 arelent
**relpp
= NULL
;
5355 if ( bfd_is_abs_section (section
)
5356 || bfd_is_und_section (section
)
5357 || bfd_is_com_section (section
)
5358 || (! process_section_p (section
))
5359 || ((section
->flags
& SEC_RELOC
) == 0))
5362 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
5364 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
5367 printf (" (none)\n\n");
5375 relpp
= (arelent
**) xmalloc (relsize
);
5376 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
5382 non_fatal (_("failed to read relocs in: %s"),
5383 sanitize_string (bfd_get_filename (abfd
)));
5384 bfd_fatal (_("error message was"));
5386 else if (relcount
== 0)
5387 printf (" (none)\n\n");
5391 dump_reloc_set (abfd
, section
, relpp
, relcount
);
5398 dump_relocs (bfd
*abfd
)
5400 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
5404 dump_dynamic_relocs (bfd
*abfd
)
5410 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5412 bfd_fatal (bfd_get_filename (abfd
));
5414 printf ("DYNAMIC RELOCATION RECORDS");
5417 printf (" (none)\n\n");
5420 relpp
= (arelent
**) xmalloc (relsize
);
5421 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
5424 bfd_fatal (bfd_get_filename (abfd
));
5425 else if (relcount
== 0)
5426 printf (" (none)\n\n");
5430 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
5437 /* Creates a table of paths, to search for source files. */
5440 add_include_path (const char *path
)
5444 include_path_count
++;
5445 include_paths
= (const char **)
5446 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
5447 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5448 if (path
[1] == ':' && path
[2] == 0)
5449 path
= concat (path
, ".", (const char *) 0);
5451 include_paths
[include_path_count
- 1] = path
;
5455 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
5459 if ((section
->flags
& SEC_DEBUGGING
) == 0)
5461 bool *has_reloc_p
= (bool *) arg
;
5462 section
->vma
+= adjust_section_vma
;
5464 section
->lma
+= adjust_section_vma
;
5468 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5471 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5476 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5477 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5481 might_need_separate_debug_info (bool is_mainfile
)
5483 /* We do not follow links from debug info files. */
5487 /* Since do_follow_links might be enabled by default, only treat it as an
5488 indication that separate files should be loaded if setting it was a
5489 deliberate user action. */
5490 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
5493 if (process_links
|| dump_symtab
|| dump_debugging
5494 || dump_dwarf_section_info
|| with_source_code
)
5500 /* Dump selected contents of ABFD. */
5503 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5505 const struct elf_backend_data
* bed
;
5507 if (bfd_big_endian (abfd
))
5508 byte_get
= byte_get_big_endian
;
5509 else if (bfd_little_endian (abfd
))
5510 byte_get
= byte_get_little_endian
;
5514 /* Load any separate debug information files. */
5515 if (byte_get
!= NULL
&& might_need_separate_debug_info (is_mainfile
))
5517 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5519 /* If asked to do so, recursively dump the separate files. */
5520 if (do_follow_links
)
5524 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5525 dump_bfd (i
->handle
, false);
5529 /* Adjust user-specified start and stop limits for targets that use
5530 signed addresses. */
5531 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5532 && (bed
= get_elf_backend_data (abfd
)) != NULL
5533 && bed
->sign_extend_vma
)
5535 start_address
= sign_extend_address (abfd
, start_address
,
5537 stop_address
= sign_extend_address (abfd
, stop_address
,
5541 /* If we are adjusting section VMA's, change them all now. Changing
5542 the BFD information is a hack. However, we must do it, or
5543 bfd_find_nearest_line will not do the right thing. */
5544 if (adjust_section_vma
!= 0)
5546 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5547 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5550 if (is_mainfile
|| process_links
)
5552 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5553 printf (_("\n%s: file format %s\n"),
5554 sanitize_string (bfd_get_filename (abfd
)),
5557 print_arelt_descr (stdout
, abfd
, true, false);
5558 if (dump_file_header
)
5559 dump_bfd_header (abfd
);
5560 if (dump_private_headers
)
5561 dump_bfd_private_header (abfd
);
5562 if (dump_private_options
!= NULL
)
5563 dump_target_specific (abfd
);
5564 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5572 || dump_dwarf_section_info
)
5574 syms
= slurp_symtab (abfd
);
5576 /* If following links, load any symbol tables from the linked files as well. */
5577 if (do_follow_links
&& is_mainfile
)
5581 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5583 asymbol
** extra_syms
;
5584 long old_symcount
= symcount
;
5586 extra_syms
= slurp_symtab (i
->handle
);
5590 if (old_symcount
== 0)
5596 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5597 * sizeof (asymbol
*)));
5598 memcpy (syms
+ old_symcount
,
5600 (symcount
+ 1) * sizeof (asymbol
*));
5604 symcount
+= old_symcount
;
5609 if (is_mainfile
|| process_links
)
5611 if (dump_section_headers
)
5612 dump_headers (abfd
);
5614 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5615 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5616 dynsyms
= slurp_dynamic_symtab (abfd
);
5620 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5621 dynsymcount
, dynsyms
,
5628 dump_symbols (abfd
, false);
5629 if (dump_dynamic_symtab
)
5630 dump_symbols (abfd
, true);
5632 if (dump_dwarf_section_info
)
5633 dump_dwarf (abfd
, is_mainfile
);
5634 if (is_mainfile
|| process_links
)
5636 if (dump_ctf_section_info
)
5637 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5638 if (dump_sframe_section_info
)
5639 dump_section_sframe (abfd
, dump_sframe_section_name
);
5640 if (dump_stab_section_info
)
5642 if (dump_reloc_info
&& ! disassemble
)
5644 if (dump_dynamic_reloc_info
&& ! disassemble
)
5645 dump_dynamic_relocs (abfd
);
5646 if (dump_section_contents
)
5649 disassemble_data (abfd
);
5656 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5657 if (dhandle
!= NULL
)
5659 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5661 dump_debugging_tags
!= 0))
5663 non_fatal (_("%s: printing debugging information failed"),
5664 bfd_get_filename (abfd
));
5670 /* PR 6483: If there was no STABS debug info in the file, try
5672 else if (! dump_dwarf_section_info
)
5674 dwarf_select_sections_all ();
5675 dump_dwarf (abfd
, is_mainfile
);
5702 free_debug_memory ();
5706 display_object_bfd (bfd
*abfd
)
5710 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5712 dump_bfd (abfd
, true);
5716 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5718 nonfatal (bfd_get_filename (abfd
));
5719 list_matching_formats (matching
);
5723 if (bfd_get_error () != bfd_error_file_not_recognized
)
5725 nonfatal (bfd_get_filename (abfd
));
5729 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5731 dump_bfd (abfd
, true);
5735 nonfatal (bfd_get_filename (abfd
));
5737 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5738 list_matching_formats (matching
);
5742 display_any_bfd (bfd
*file
, int level
)
5744 /* Decompress sections unless dumping the section contents. */
5745 if (!dump_section_contents
)
5746 file
->flags
|= BFD_DECOMPRESS
;
5748 /* If the file is an archive, process all of its elements. */
5749 if (bfd_check_format (file
, bfd_archive
))
5752 bfd
*last_arfile
= NULL
;
5755 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5756 else if (level
> 100)
5758 /* Prevent corrupted files from spinning us into an
5759 infinite loop. 100 is an arbitrary heuristic. */
5760 fatal (_("Archive nesting is too deep"));
5764 printf (_("In nested archive %s:\n"),
5765 sanitize_string (bfd_get_filename (file
)));
5769 bfd_set_error (bfd_error_no_error
);
5771 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5774 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5775 nonfatal (bfd_get_filename (file
));
5779 display_any_bfd (arfile
, level
+ 1);
5781 if (last_arfile
!= NULL
)
5783 bfd_close (last_arfile
);
5784 /* PR 17512: file: ac585d01. */
5785 if (arfile
== last_arfile
)
5791 last_arfile
= arfile
;
5794 if (last_arfile
!= NULL
)
5795 bfd_close (last_arfile
);
5798 display_object_bfd (file
);
5802 display_file (char *filename
, char *target
, bool last_file
)
5806 if (get_file_size (filename
) < 1)
5812 file
= bfd_openr (filename
, target
);
5815 nonfatal (filename
);
5819 display_any_bfd (file
, 0);
5821 /* This is an optimization to improve the speed of objdump, especially when
5822 dumping a file with lots of associated debug informatiom. Calling
5823 bfd_close on such a file can take a non-trivial amount of time as there
5824 are lots of lists to walk and buffers to free. This is only really
5825 necessary however if we are about to load another file and we need the
5826 memory back. Otherwise, if we are about to exit, then we can save (a lot
5827 of) time by only doing a quick close, and allowing the OS to reclaim the
5832 bfd_close_all_done (file
);
5836 main (int argc
, char **argv
)
5839 char *target
= default_target
;
5840 bool seenflag
= false;
5842 #ifdef HAVE_LC_MESSAGES
5843 setlocale (LC_MESSAGES
, "");
5845 setlocale (LC_CTYPE
, "");
5847 bindtextdomain (PACKAGE
, LOCALEDIR
);
5848 textdomain (PACKAGE
);
5850 program_name
= *argv
;
5851 xmalloc_set_program_name (program_name
);
5852 bfd_set_error_program_name (program_name
);
5854 START_PROGRESS (program_name
, 0);
5856 expandargv (&argc
, &argv
);
5858 if (bfd_init () != BFD_INIT_MAGIC
)
5859 fatal (_("fatal error: libbfd ABI mismatch"));
5860 set_default_bfd_target ();
5862 while ((c
= getopt_long (argc
, argv
,
5863 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5864 long_options
, (int *) 0))
5870 break; /* We've been given a long option. */
5877 if (disassembler_options
)
5878 /* Ignore potential memory leak for now. */
5879 options
= concat (disassembler_options
, ",",
5880 optarg
, (const char *) NULL
);
5883 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5890 display_file_offsets
= true;
5893 with_line_numbers
= true;
5902 enum demangling_styles style
;
5904 style
= cplus_demangle_name_to_style (optarg
);
5905 if (style
== unknown_demangling
)
5906 fatal (_("unknown demangling style `%s'"),
5909 cplus_demangle_set_style (style
);
5912 case OPTION_RECURSE_LIMIT
:
5913 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5915 case OPTION_NO_RECURSE_LIMIT
:
5916 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5919 do_wide
= wide_output
= true;
5921 case OPTION_ADJUST_VMA
:
5922 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5924 case OPTION_START_ADDRESS
:
5925 start_address
= parse_vma (optarg
, "--start-address");
5926 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5927 fatal (_("error: the start address should be before the end address"));
5929 case OPTION_STOP_ADDRESS
:
5930 stop_address
= parse_vma (optarg
, "--stop-address");
5931 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5932 fatal (_("error: the stop address should be after the start address"));
5936 prefix_length
= strlen (prefix
);
5937 /* Remove an unnecessary trailing '/' */
5938 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5941 case OPTION_PREFIX_STRIP
:
5942 prefix_strip
= atoi (optarg
);
5943 if (prefix_strip
< 0)
5944 fatal (_("error: prefix strip must be non-negative"));
5946 case OPTION_INSN_WIDTH
:
5947 insn_width
= strtoul (optarg
, NULL
, 0);
5948 if (insn_width
<= 0)
5949 fatal (_("error: instruction width must be positive"));
5951 case OPTION_INLINES
:
5952 unwind_inlines
= true;
5954 case OPTION_VISUALIZE_JUMPS
:
5955 visualize_jumps
= true;
5956 color_output
= false;
5957 extended_color_output
= false;
5960 if (streq (optarg
, "color"))
5961 color_output
= true;
5962 else if (streq (optarg
, "extended-color"))
5964 color_output
= true;
5965 extended_color_output
= true;
5967 else if (streq (optarg
, "off"))
5968 visualize_jumps
= false;
5970 nonfatal (_("unrecognized argument to --visualize-option"));
5973 case OPTION_DISASSEMBLER_COLOR
:
5974 if (streq (optarg
, "off"))
5975 disassembler_color
= off
;
5976 else if (streq (optarg
, "terminal"))
5977 disassembler_color
= on_if_terminal_output
;
5978 else if (streq (optarg
, "color")
5979 || streq (optarg
, "colour")
5980 || streq (optarg
, "on"))
5981 disassembler_color
= on
;
5982 else if (streq (optarg
, "extended")
5983 || streq (optarg
, "extended-color")
5984 || streq (optarg
, "extended-colour"))
5985 disassembler_color
= extended
;
5987 nonfatal (_("unrecognized argument to --disassembler-color"));
5990 if (strcmp (optarg
, "B") == 0)
5991 endian
= BFD_ENDIAN_BIG
;
5992 else if (strcmp (optarg
, "L") == 0)
5993 endian
= BFD_ENDIAN_LITTLE
;
5996 nonfatal (_("unrecognized -E option"));
6001 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
6002 endian
= BFD_ENDIAN_BIG
;
6003 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
6004 endian
= BFD_ENDIAN_LITTLE
;
6007 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
6014 dump_file_header
= true;
6018 formats_info
= true;
6022 add_include_path (optarg
);
6025 dump_private_headers
= true;
6029 dump_private_options
= optarg
;
6033 dump_private_headers
= true;
6035 dump_reloc_info
= true;
6036 dump_file_header
= true;
6037 dump_ar_hdrs
= true;
6038 dump_section_headers
= true;
6046 dump_dynamic_symtab
= true;
6052 disasm_sym
= optarg
;
6055 disassemble_zeroes
= true;
6059 disassemble_all
= true;
6064 with_source_code
= true;
6067 case OPTION_SOURCE_COMMENT
:
6069 with_source_code
= true;
6072 source_comment
= xstrdup (sanitize_string (optarg
));
6074 source_comment
= xstrdup ("# ");
6082 dump_debugging_tags
= 1;
6087 process_links
= true;
6088 do_follow_links
= true;
6094 if (dwarf_select_sections_by_letters (optarg
))
6095 dump_dwarf_section_info
= true;
6099 dump_dwarf_section_info
= true;
6100 dwarf_select_sections_all ();
6107 if (dwarf_select_sections_by_names (optarg
))
6108 dump_dwarf_section_info
= true;
6112 dwarf_select_sections_all ();
6113 dump_dwarf_section_info
= true;
6116 case OPTION_DWARF_DEPTH
:
6119 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6122 case OPTION_DWARF_START
:
6125 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6126 suppress_bfd_header
= 1;
6129 case OPTION_DWARF_CHECK
:
6132 #ifdef ENABLE_LIBCTF
6134 dump_ctf_section_info
= true;
6136 dump_ctf_section_name
= xstrdup (optarg
);
6139 case OPTION_CTF_PARENT
:
6140 dump_ctf_parent_name
= xstrdup (optarg
);
6144 dump_sframe_section_info
= true;
6146 dump_sframe_section_name
= xstrdup (optarg
);
6150 dump_stab_section_info
= true;
6154 dump_section_contents
= true;
6158 dump_reloc_info
= true;
6162 dump_dynamic_reloc_info
= true;
6166 dump_ar_hdrs
= true;
6170 dump_section_headers
= true;
6175 show_version
= true;
6180 if (streq (optarg
, "default") || streq (optarg
, "d"))
6181 unicode_display
= unicode_default
;
6182 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6183 unicode_display
= unicode_locale
;
6184 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6185 unicode_display
= unicode_escape
;
6186 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6187 unicode_display
= unicode_invalid
;
6188 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6189 unicode_display
= unicode_hex
;
6190 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6191 unicode_display
= unicode_highlight
;
6193 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
6198 /* No need to set seenflag or to break - usage() does not return. */
6204 if (disassembler_color
== on_if_terminal_output
)
6205 disassembler_color
= isatty (1) ? on
: off
;
6208 print_version ("objdump");
6213 dump_any_debugging
= (dump_debugging
6214 || dump_dwarf_section_info
6216 || with_source_code
);
6219 exit_status
= display_info ();
6223 display_file ("a.out", target
, true);
6225 for (; optind
< argc
;)
6227 display_file (argv
[optind
], target
, optind
== argc
- 1);
6233 free (dump_ctf_section_name
);
6234 free (dump_ctf_parent_name
);
6235 free ((void *) source_comment
);
6237 END_PROGRESS (program_name
);