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"
62 #include "safe-ctype.h"
64 #include "libiberty.h"
66 #include "filenames.h"
75 #ifdef HAVE_LIBDEBUGINFOD
76 #include <elfutils/debuginfod.h>
79 /* Internal headers for the ELF .stab-dump code - sorry. */
80 #define BYTES_IN_WORD 32
81 #include "aout/aout64.h"
84 static int exit_status
= 0;
86 static char *default_target
= NULL
; /* Default at runtime. */
88 /* The following variables are set based on arguments passed on the
90 static int show_version
= 0; /* Show the version number. */
91 static int dump_section_contents
; /* -s */
92 static int dump_section_headers
; /* -h */
93 static bool dump_file_header
; /* -f */
94 static int dump_symtab
; /* -t */
95 static int dump_dynamic_symtab
; /* -T */
96 static int dump_reloc_info
; /* -r */
97 static int dump_dynamic_reloc_info
; /* -R */
98 static int dump_ar_hdrs
; /* -a */
99 static int dump_private_headers
; /* -p */
100 static char *dump_private_options
; /* -P */
101 static int no_addresses
; /* --no-addresses */
102 static int prefix_addresses
; /* --prefix-addresses */
103 static int with_line_numbers
; /* -l */
104 static bool with_source_code
; /* -S */
105 static int show_raw_insn
; /* --show-raw-insn */
106 static int dump_dwarf_section_info
; /* --dwarf */
107 static int dump_stab_section_info
; /* --stabs */
108 static int dump_ctf_section_info
; /* --ctf */
109 static char *dump_ctf_section_name
;
110 static char *dump_ctf_parent_name
; /* --ctf-parent */
111 static int do_demangle
; /* -C, --demangle */
112 static bool disassemble
; /* -d */
113 static bool disassemble_all
; /* -D */
114 static int disassemble_zeroes
; /* --disassemble-zeroes */
115 static bool formats_info
; /* -i */
116 static int wide_output
; /* -w */
117 static int insn_width
; /* --insn-width */
118 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
119 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
120 static int dump_debugging
; /* --debugging */
121 static int dump_debugging_tags
; /* --debugging-tags */
122 static int suppress_bfd_header
;
123 static int dump_special_syms
= 0; /* --special-syms */
124 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
125 static int file_start_context
= 0; /* --file-start-context */
126 static bool display_file_offsets
; /* -F */
127 static const char *prefix
; /* --prefix */
128 static int prefix_strip
; /* --prefix-strip */
129 static size_t prefix_length
;
130 static bool unwind_inlines
; /* --inlines. */
131 static const char * disasm_sym
; /* Disassembly start symbol. */
132 static const char * source_comment
; /* --source_comment. */
133 static bool visualize_jumps
= false; /* --visualize-jumps. */
134 static bool color_output
= false; /* --visualize-jumps=color. */
135 static bool extended_color_output
= false; /* --visualize-jumps=extended-color. */
136 static int process_links
= false; /* --process-links. */
138 static enum color_selection
140 on_if_terminal_output
,
141 on
, /* --disassembler-color=color. */
142 off
, /* --disassembler-color=off. */
143 extended
/* --disassembler-color=extended-color. */
144 } disassembler_color
= on_if_terminal_output
;
146 static int dump_any_debugging
;
147 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
149 /* This is reset to false each time we enter the disassembler, and set true
150 when the disassembler emits something in the dis_style_comment_start
151 style. Once this is true, all further output on that line is done in
152 the comment style. This only has an effect when disassembler coloring
154 static bool disassembler_in_comment
= false;
156 /* A structure to record the sections mentioned in -j switches. */
159 const char *name
; /* The name of the section. */
160 bool seen
; /* A flag to indicate that the section has been found in one or more input files. */
161 struct only
*next
; /* Pointer to the next structure in the list. */
163 /* Pointer to an array of 'only' structures.
164 This pointer is NULL if the -j switch has not been used. */
165 static struct only
* only_list
= NULL
;
167 /* Variables for handling include file path table. */
168 static const char **include_paths
;
169 static int include_path_count
;
171 /* Extra info to pass to the section disassembler and address printing
173 struct objdump_disasm_info
177 disassembler_ftype disassemble_fn
;
182 /* Architecture to disassemble for, or default if NULL. */
183 static char *machine
= NULL
;
185 /* Target specific options to the disassembler. */
186 static char *disassembler_options
= NULL
;
188 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
189 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
191 /* The symbol table. */
192 static asymbol
**syms
;
194 /* Number of symbols in `syms'. */
195 static long symcount
= 0;
197 /* The sorted symbol table. */
198 static asymbol
**sorted_syms
;
200 /* Number of symbols in `sorted_syms'. */
201 static long sorted_symcount
= 0;
203 /* The dynamic symbol table. */
204 static asymbol
**dynsyms
;
206 /* The synthetic symbol table. */
207 static asymbol
*synthsyms
;
208 static long synthcount
= 0;
210 /* Number of symbols in `dynsyms'. */
211 static long dynsymcount
= 0;
213 static bfd_byte
*stabs
;
214 static bfd_size_type stab_size
;
216 static bfd_byte
*strtab
;
217 static bfd_size_type stabstr_size
;
219 /* Handlers for -P/--private. */
220 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
222 OBJDUMP_PRIVATE_VECTORS
226 /* The list of detected jumps inside a function. */
227 static struct jump_info
*detected_jumps
= NULL
;
229 typedef enum unicode_display_type
237 } unicode_display_type
;
239 static unicode_display_type unicode_display
= unicode_default
;
241 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
243 usage (FILE *stream
, int status
)
245 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
246 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
247 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
248 fprintf (stream
, _("\
249 -a, --archive-headers Display archive header information\n"));
250 fprintf (stream
, _("\
251 -f, --file-headers Display the contents of the overall file header\n"));
252 fprintf (stream
, _("\
253 -p, --private-headers Display object format specific file header contents\n"));
254 fprintf (stream
, _("\
255 -P, --private=OPT,OPT... Display object format specific contents\n"));
256 fprintf (stream
, _("\
257 -h, --[section-]headers Display the contents of the section headers\n"));
258 fprintf (stream
, _("\
259 -x, --all-headers Display the contents of all headers\n"));
260 fprintf (stream
, _("\
261 -d, --disassemble Display assembler contents of executable sections\n"));
262 fprintf (stream
, _("\
263 -D, --disassemble-all Display assembler contents of all sections\n"));
264 fprintf (stream
, _("\
265 --disassemble=<sym> Display assembler contents from <sym>\n"));
266 fprintf (stream
, _("\
267 -S, --source Intermix source code with disassembly\n"));
268 fprintf (stream
, _("\
269 --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
270 fprintf (stream
, _("\
271 -s, --full-contents Display the full contents of all sections requested\n"));
272 fprintf (stream
, _("\
273 -g, --debugging Display debug information in object file\n"));
274 fprintf (stream
, _("\
275 -e, --debugging-tags Display debug information using ctags style\n"));
276 fprintf (stream
, _("\
277 -G, --stabs Display (in raw form) any STABS info in the file\n"));
278 fprintf (stream
, _("\
279 -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
280 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
281 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
282 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
284 Display the contents of DWARF debug sections\n"));
285 fprintf (stream
, _("\
286 -Wk,--dwarf=links Display the contents of sections that link to\n\
287 separate debuginfo files\n"));
288 #if DEFAULT_FOR_FOLLOW_LINKS
289 fprintf (stream
, _("\
290 -WK,--dwarf=follow-links\n\
291 Follow links to separate debug info files (default)\n"));
292 fprintf (stream
, _("\
293 -WN,--dwarf=no-follow-links\n\
294 Do not follow links to separate debug info files\n"));
296 fprintf (stream
, _("\
297 -WK,--dwarf=follow-links\n\
298 Follow links to separate debug info files\n"));
299 fprintf (stream
, _("\
300 -WN,--dwarf=no-follow-links\n\
301 Do not follow links to separate debug info files\n\
304 #if HAVE_LIBDEBUGINFOD
305 fprintf (stream
, _("\
306 -WD --dwarf=use-debuginfod\n\
307 When following links, also query debuginfod servers (default)\n"));
308 fprintf (stream
, _("\
309 -WE --dwarf=do-not-use-debuginfod\n\
310 When following links, do not query debuginfod servers\n"));
312 fprintf (stream
, _("\
313 -L, --process-links Display the contents of non-debug sections in\n\
314 separate debuginfo files. (Implies -WK)\n"));
316 fprintf (stream
, _("\
317 --ctf[=SECTION] Display CTF info from SECTION, (default `.ctf')\n"));
319 fprintf (stream
, _("\
320 -t, --syms Display the contents of the symbol table(s)\n"));
321 fprintf (stream
, _("\
322 -T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
323 fprintf (stream
, _("\
324 -r, --reloc Display the relocation entries in the file\n"));
325 fprintf (stream
, _("\
326 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
327 fprintf (stream
, _("\
328 @<file> Read options from <file>\n"));
329 fprintf (stream
, _("\
330 -v, --version Display this program's version number\n"));
331 fprintf (stream
, _("\
332 -i, --info List object formats and architectures supported\n"));
333 fprintf (stream
, _("\
334 -H, --help Display this information\n"));
338 const struct objdump_private_desc
* const *desc
;
340 fprintf (stream
, _("\n The following switches are optional:\n"));
341 fprintf (stream
, _("\
342 -b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
343 fprintf (stream
, _("\
344 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
345 fprintf (stream
, _("\
346 -j, --section=NAME Only display information for section NAME\n"));
347 fprintf (stream
, _("\
348 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
349 fprintf (stream
, _("\
350 -EB --endian=big Assume big endian format when disassembling\n"));
351 fprintf (stream
, _("\
352 -EL --endian=little Assume little endian format when disassembling\n"));
353 fprintf (stream
, _("\
354 --file-start-context Include context from start of file (with -S)\n"));
355 fprintf (stream
, _("\
356 -I, --include=DIR Add DIR to search list for source files\n"));
357 fprintf (stream
, _("\
358 -l, --line-numbers Include line numbers and filenames in output\n"));
359 fprintf (stream
, _("\
360 -F, --file-offsets Include file offsets when displaying information\n"));
361 fprintf (stream
, _("\
362 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n"));
363 display_demangler_styles (stream
, _("\
365 fprintf (stream
, _("\
366 --recurse-limit Enable a limit on recursion whilst demangling\n\
368 fprintf (stream
, _("\
369 --no-recurse-limit Disable a limit on recursion whilst demangling\n"));
370 fprintf (stream
, _("\
371 -w, --wide Format output for more than 80 columns\n"));
372 fprintf (stream
, _("\
373 -U[d|l|i|x|e|h] Controls the display of UTF-8 unicode characters\n\
374 --unicode=[default|locale|invalid|hex|escape|highlight]\n"));
375 fprintf (stream
, _("\
376 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
377 fprintf (stream
, _("\
378 --start-address=ADDR Only process data whose address is >= ADDR\n"));
379 fprintf (stream
, _("\
380 --stop-address=ADDR Only process data whose address is < ADDR\n"));
381 fprintf (stream
, _("\
382 --no-addresses Do not print address alongside disassembly\n"));
383 fprintf (stream
, _("\
384 --prefix-addresses Print complete address alongside disassembly\n"));
385 fprintf (stream
, _("\
386 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
387 fprintf (stream
, _("\
388 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
389 fprintf (stream
, _("\
390 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
391 fprintf (stream
, _("\
392 --special-syms Include special symbols in symbol dumps\n"));
393 fprintf (stream
, _("\
394 --inlines Print all inlines for source line (with -l)\n"));
395 fprintf (stream
, _("\
396 --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
397 fprintf (stream
, _("\
398 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
399 fprintf (stream
, _("\
400 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
401 fprintf (stream
, _("\
402 --dwarf-start=N Display DIEs starting at offset N\n"));
403 fprintf (stream
, _("\
404 --dwarf-check Make additional dwarf consistency checks.\n"));
406 fprintf (stream
, _("\
407 --ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
409 fprintf (stream
, _("\
410 --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
411 fprintf (stream
, _("\
412 --visualize-jumps=color Use colors in the ASCII art\n"));
413 fprintf (stream
, _("\
414 --visualize-jumps=extended-color\n\
415 Use extended 8-bit color codes\n"));
416 fprintf (stream
, _("\
417 --visualize-jumps=off Disable jump visualization\n\n"));
418 fprintf (stream
, _("\
419 --disassembler-color=off Disable disassembler color output.\n\n"));
420 fprintf (stream
, _("\
421 --disassembler-color=color Use basic colors in disassembler output.\n\n"));
422 fprintf (stream
, _("\
423 --disassembler-color=extended-color Use 8-bit colors in disassembler output.\n\n"));
425 list_supported_targets (program_name
, stream
);
426 list_supported_architectures (program_name
, stream
);
428 disassembler_usage (stream
);
430 if (objdump_private_vectors
[0] != NULL
)
433 _("\nOptions supported for -P/--private switch:\n"));
434 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
435 (*desc
)->help (stream
);
438 if (REPORT_BUGS_TO
[0] && status
== 0)
439 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
443 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
447 OPTION_START_ADDRESS
,
457 OPTION_RECURSE_LIMIT
,
458 OPTION_NO_RECURSE_LIMIT
,
460 OPTION_SOURCE_COMMENT
,
465 OPTION_VISUALIZE_JUMPS
,
466 OPTION_DISASSEMBLER_COLOR
469 static struct option long_options
[]=
471 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
472 {"all-headers", no_argument
, NULL
, 'x'},
473 {"architecture", required_argument
, NULL
, 'm'},
474 {"archive-headers", no_argument
, NULL
, 'a'},
476 {"ctf", optional_argument
, NULL
, OPTION_CTF
},
477 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
479 {"debugging", no_argument
, NULL
, 'g'},
480 {"debugging-tags", no_argument
, NULL
, 'e'},
481 {"demangle", optional_argument
, NULL
, 'C'},
482 {"disassemble", optional_argument
, NULL
, 'd'},
483 {"disassemble-all", no_argument
, NULL
, 'D'},
484 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
485 {"disassembler-options", required_argument
, NULL
, 'M'},
486 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
487 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
488 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
489 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
490 {"dynamic-reloc", no_argument
, NULL
, 'R'},
491 {"dynamic-syms", no_argument
, NULL
, 'T'},
492 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
493 {"file-headers", no_argument
, NULL
, 'f'},
494 {"file-offsets", no_argument
, NULL
, 'F'},
495 {"file-start-context", no_argument
, &file_start_context
, 1},
496 {"full-contents", no_argument
, NULL
, 's'},
497 {"headers", no_argument
, NULL
, 'h'},
498 {"help", no_argument
, NULL
, 'H'},
499 {"include", required_argument
, NULL
, 'I'},
500 {"info", no_argument
, NULL
, 'i'},
501 {"inlines", no_argument
, 0, OPTION_INLINES
},
502 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
503 {"line-numbers", no_argument
, NULL
, 'l'},
504 {"no-addresses", no_argument
, &no_addresses
, 1},
505 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
506 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
507 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
508 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
509 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
510 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
511 {"private", required_argument
, NULL
, 'P'},
512 {"private-headers", no_argument
, NULL
, 'p'},
513 {"process-links", no_argument
, &process_links
, true},
514 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
515 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
516 {"reloc", no_argument
, NULL
, 'r'},
517 {"section", required_argument
, NULL
, 'j'},
518 {"section-headers", no_argument
, NULL
, 'h'},
519 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
520 {"source", no_argument
, NULL
, 'S'},
521 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
522 {"special-syms", no_argument
, &dump_special_syms
, 1},
523 {"stabs", no_argument
, NULL
, 'G'},
524 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
525 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
526 {"syms", no_argument
, NULL
, 't'},
527 {"target", required_argument
, NULL
, 'b'},
528 {"unicode", required_argument
, NULL
, 'U'},
529 {"version", no_argument
, NULL
, 'V'},
530 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
531 {"wide", no_argument
, NULL
, 'w'},
532 {"disassembler-color", required_argument
, NULL
, OPTION_DISASSEMBLER_COLOR
},
533 {NULL
, no_argument
, NULL
, 0}
537 nonfatal (const char *msg
)
543 /* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
544 The conversion format is controlled by the unicode_display variable.
545 Returns the number of characters added to OUT.
546 Returns the number of bytes consumed from IN in CONSUMED.
547 Always consumes at least one byte and displays at least one character. */
550 display_utf8 (const unsigned char * in
, char * out
, unsigned int * consumed
)
552 char * orig_out
= out
;
553 unsigned int nchars
= 0;
556 if (unicode_display
== unicode_default
)
562 if ((in
[1] & 0xc0) != 0x80)
565 if ((in
[0] & 0x20) == 0)
571 if ((in
[2] & 0xc0) != 0x80)
574 if ((in
[0] & 0x10) == 0)
580 if ((in
[3] & 0xc0) != 0x80)
586 switch (unicode_display
)
589 /* Copy the bytes into the output buffer as is. */
590 memcpy (out
, in
, nchars
);
594 case unicode_invalid
:
596 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '<' : '{');
597 out
+= sprintf (out
, "0x");
598 for (j
= 0; j
< nchars
; j
++)
599 out
+= sprintf (out
, "%02x", in
[j
]);
600 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '>' : '}');
603 case unicode_highlight
:
605 out
+= sprintf (out
, "\x1B[31;47m"); /* Red. */
611 out
+= sprintf (out
, "\\u%02x%02x",
612 ((in
[0] & 0x1c) >> 2),
613 ((in
[0] & 0x03) << 6) | (in
[1] & 0x3f));
617 out
+= sprintf (out
, "\\u%02x%02x",
618 ((in
[0] & 0x0f) << 4) | ((in
[1] & 0x3c) >> 2),
619 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3f)));
623 out
+= sprintf (out
, "\\u%02x%02x%02x",
624 ((in
[0] & 0x07) << 6) | ((in
[1] & 0x3c) >> 2),
625 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3c) >> 2),
626 ((in
[2] & 0x03) << 6) | ((in
[3] & 0x3f)));
633 if (unicode_display
== unicode_highlight
&& isatty (1))
634 out
+= sprintf (out
, "\033[0m"); /* Default colour. */
643 return out
- orig_out
;
646 /* Not a valid UTF-8 sequence. */
652 /* Returns a version of IN with any control characters
653 replaced by escape sequences. Uses a static buffer
656 If unicode display is enabled, then also handles the
657 conversion of unicode characters. */
660 sanitize_string (const char * in
)
662 static char * buffer
= NULL
;
663 static size_t buffer_len
= 0;
664 const char * original
= in
;
671 /* See if any conversion is necessary. In the majority
672 of cases it will not be needed. */
675 unsigned char c
= *in
++;
683 if (unicode_display
!= unicode_default
&& c
>= 0xc0)
688 /* Copy the input, translating as needed. */
690 if (buffer_len
< (strlen (in
) * 9))
692 free ((void *) buffer
);
693 buffer_len
= strlen (in
) * 9;
694 buffer
= xmalloc (buffer_len
+ 1);
700 unsigned char c
= *in
++;
710 else if (unicode_display
!= unicode_default
&& c
>= 0xc0)
712 unsigned int num_consumed
;
714 out
+= display_utf8 ((const unsigned char *)(in
- 1), out
, & num_consumed
);
715 in
+= num_consumed
- 1;
727 /* Returns TRUE if the specified section should be dumped. */
730 process_section_p (asection
* section
)
734 if (only_list
== NULL
)
737 for (only
= only_list
; only
; only
= only
->next
)
738 if (strcmp (only
->name
, section
->name
) == 0)
747 /* Add an entry to the 'only' list. */
750 add_only (char * name
)
754 /* First check to make sure that we do not
755 already have an entry for this name. */
756 for (only
= only_list
; only
; only
= only
->next
)
757 if (strcmp (only
->name
, name
) == 0)
760 only
= xmalloc (sizeof * only
);
763 only
->next
= only_list
;
767 /* Release the memory used by the 'only' list.
768 PR 11225: Issue a warning message for unseen sections.
769 Only do this if none of the sections were seen. This is mainly to support
770 tools like the GAS testsuite where an object file is dumped with a list of
771 generic section names known to be present in a range of different file
775 free_only_list (void)
777 bool at_least_one_seen
= false;
781 if (only_list
== NULL
)
784 for (only
= only_list
; only
; only
= only
->next
)
787 at_least_one_seen
= true;
791 for (only
= only_list
; only
; only
= next
)
793 if (! at_least_one_seen
)
795 non_fatal (_("section '%s' mentioned in a -j option, "
796 "but not found in any input file"),
807 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
810 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
811 int longest_section_name
= *((int *) data
);
813 /* Ignore linker created section. See elfNN_ia64_object_p in
815 if (section
->flags
& SEC_LINKER_CREATED
)
818 /* PR 10413: Skip sections that we are ignoring. */
819 if (! process_section_p (section
))
822 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
823 sanitize_string (bfd_section_name (section
)),
824 (unsigned long) bfd_section_size (section
) / opb
);
825 bfd_printf_vma (abfd
, bfd_section_vma (section
));
827 bfd_printf_vma (abfd
, section
->lma
);
828 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
829 bfd_section_alignment (section
));
835 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
837 PF (SEC_HAS_CONTENTS
, "CONTENTS");
838 PF (SEC_ALLOC
, "ALLOC");
839 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
840 PF (SEC_LOAD
, "LOAD");
841 PF (SEC_RELOC
, "RELOC");
842 PF (SEC_READONLY
, "READONLY");
843 PF (SEC_CODE
, "CODE");
844 PF (SEC_DATA
, "DATA");
846 PF (SEC_DEBUGGING
, "DEBUGGING");
847 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
848 PF (SEC_EXCLUDE
, "EXCLUDE");
849 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
850 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
852 PF (SEC_TIC54X_BLOCK
, "BLOCK");
853 PF (SEC_TIC54X_CLINK
, "CLINK");
855 PF (SEC_SMALL_DATA
, "SMALL_DATA");
856 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
858 PF (SEC_COFF_SHARED
, "SHARED");
859 PF (SEC_COFF_NOREAD
, "NOREAD");
861 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
863 PF (SEC_ELF_OCTETS
, "OCTETS");
864 PF (SEC_ELF_PURECODE
, "PURECODE");
866 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
867 PF (SEC_GROUP
, "GROUP");
868 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
870 PF (SEC_MEP_VLIW
, "VLIW");
873 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
876 struct coff_comdat_info
*comdat
;
878 switch (section
->flags
& SEC_LINK_DUPLICATES
)
882 case SEC_LINK_DUPLICATES_DISCARD
:
883 ls
= "LINK_ONCE_DISCARD";
885 case SEC_LINK_DUPLICATES_ONE_ONLY
:
886 ls
= "LINK_ONCE_ONE_ONLY";
888 case SEC_LINK_DUPLICATES_SAME_SIZE
:
889 ls
= "LINK_ONCE_SAME_SIZE";
891 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
892 ls
= "LINK_ONCE_SAME_CONTENTS";
895 printf ("%s%s", comma
, ls
);
897 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
899 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
908 /* Called on each SECTION in ABFD, update the int variable pointed to by
909 DATA which contains the string length of the longest section name. */
912 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
913 asection
*section
, void *data
)
915 int *longest_so_far
= (int *) data
;
919 /* Ignore linker created section. */
920 if (section
->flags
& SEC_LINKER_CREATED
)
923 /* Skip sections that we are ignoring. */
924 if (! process_section_p (section
))
927 name
= bfd_section_name (section
);
928 len
= (int) strlen (name
);
929 if (len
> *longest_so_far
)
930 *longest_so_far
= len
;
934 dump_headers (bfd
*abfd
)
936 /* The default width of 13 is just an arbitrary choice. */
937 int max_section_name_length
= 13;
943 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
944 if (bfd_get_arch_size (abfd
) == 32)
950 printf (_("Sections:\n"));
953 bfd_map_over_sections (abfd
, find_longest_section_name
,
954 &max_section_name_length
);
956 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
957 max_section_name_length
, "Name",
958 bfd_vma_width
, "VMA",
959 bfd_vma_width
, "LMA");
962 printf (_(" Flags"));
965 bfd_map_over_sections (abfd
, dump_section_header
,
966 &max_section_name_length
);
970 slurp_symtab (bfd
*abfd
)
975 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
981 storage
= bfd_get_symtab_upper_bound (abfd
);
984 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
985 bfd_fatal (_("error message was"));
990 off_t filesize
= bfd_get_file_size (abfd
);
994 && filesize
< storage
995 /* The MMO file format supports its own special compression
996 technique, so its sections can be larger than the file size. */
997 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
999 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
1000 _("error: symbol table size (%#lx) "
1001 "is larger than filesize (%#lx)"),
1002 storage
, (long) filesize
);
1008 sy
= (asymbol
**) xmalloc (storage
);
1011 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1013 bfd_fatal (bfd_get_filename (abfd
));
1017 /* Read in the dynamic symbols. */
1020 slurp_dynamic_symtab (bfd
*abfd
)
1022 asymbol
**sy
= NULL
;
1025 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1028 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
1030 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
1036 bfd_fatal (bfd_get_filename (abfd
));
1040 sy
= (asymbol
**) xmalloc (storage
);
1042 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
1043 if (dynsymcount
< 0)
1044 bfd_fatal (bfd_get_filename (abfd
));
1048 /* Some symbol names are significant and should be kept in the
1049 table of sorted symbol names, even if they are marked as
1050 debugging/section symbols. */
1053 is_significant_symbol_name (const char * name
)
1055 return startswith (name
, ".plt") || startswith (name
, ".got");
1058 /* Filter out (in place) symbols that are useless for disassembly.
1059 COUNT is the number of elements in SYMBOLS.
1060 Return the number of useful symbols. */
1063 remove_useless_symbols (asymbol
**symbols
, long count
)
1065 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
1067 while (--count
>= 0)
1069 asymbol
*sym
= *in_ptr
++;
1071 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
1073 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
1074 && ! is_significant_symbol_name (sym
->name
))
1076 if (bfd_is_und_section (sym
->section
)
1077 || bfd_is_com_section (sym
->section
))
1082 return out_ptr
- symbols
;
1085 static const asection
*compare_section
;
1087 /* Sort symbols into value order. */
1090 compare_symbols (const void *ap
, const void *bp
)
1092 const asymbol
*a
= * (const asymbol
**) ap
;
1093 const asymbol
*b
= * (const asymbol
**) bp
;
1098 bool as
, af
, bs
, bf
;
1102 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
1104 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
1107 /* Prefer symbols from the section currently being disassembled.
1108 Don't sort symbols from other sections by section, since there
1109 isn't much reason to prefer one section over another otherwise.
1110 See sym_ok comment for why we compare by section name. */
1111 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
1112 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
1118 an
= bfd_asymbol_name (a
);
1119 bn
= bfd_asymbol_name (b
);
1123 /* The symbols gnu_compiled and gcc2_compiled convey no real
1124 information, so put them after other symbols with the same value. */
1125 af
= (strstr (an
, "gnu_compiled") != NULL
1126 || strstr (an
, "gcc2_compiled") != NULL
);
1127 bf
= (strstr (bn
, "gnu_compiled") != NULL
1128 || strstr (bn
, "gcc2_compiled") != NULL
);
1135 /* We use a heuristic for the file name, to try to sort it after
1136 more useful symbols. It may not work on non Unix systems, but it
1137 doesn't really matter; the only difference is precisely which
1138 symbol names get printed. */
1140 #define file_symbol(s, sn, snl) \
1141 (((s)->flags & BSF_FILE) != 0 \
1143 && (sn)[(snl) - 2] == '.' \
1144 && ((sn)[(snl) - 1] == 'o' \
1145 || (sn)[(snl) - 1] == 'a')))
1147 af
= file_symbol (a
, an
, anl
);
1148 bf
= file_symbol (b
, bn
, bnl
);
1155 /* Sort function and object symbols before global symbols before
1156 local symbols before section symbols before debugging symbols. */
1161 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
1163 if ((aflags
& BSF_DEBUGGING
) != 0)
1168 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
1170 if ((aflags
& BSF_SECTION_SYM
) != 0)
1175 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
1177 if ((aflags
& BSF_FUNCTION
) != 0)
1182 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
1184 if ((aflags
& BSF_OBJECT
) != 0)
1189 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
1191 if ((aflags
& BSF_LOCAL
) != 0)
1196 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
1198 if ((aflags
& BSF_GLOBAL
) != 0)
1204 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
1205 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1210 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1211 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1213 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1214 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1216 return asz
> bsz
? -1 : 1;
1219 /* Symbols that start with '.' might be section names, so sort them
1220 after symbols that don't start with '.'. */
1221 if (an
[0] == '.' && bn
[0] != '.')
1223 if (an
[0] != '.' && bn
[0] == '.')
1226 /* Finally, if we can't distinguish them in any other way, try to
1227 get consistent results by sorting the symbols by name. */
1228 return strcmp (an
, bn
);
1231 /* Sort relocs into address order. */
1234 compare_relocs (const void *ap
, const void *bp
)
1236 const arelent
*a
= * (const arelent
**) ap
;
1237 const arelent
*b
= * (const arelent
**) bp
;
1239 if (a
->address
> b
->address
)
1241 else if (a
->address
< b
->address
)
1244 /* So that associated relocations tied to the same address show up
1245 in the correct order, we don't do any further sorting. */
1254 /* Print an address (VMA) to the output stream in INFO.
1255 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1258 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1263 struct objdump_disasm_info
*aux
;
1265 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1266 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1271 for (p
= buf
; *p
== '0'; ++p
)
1276 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "%s", p
);
1279 /* Print the name of a symbol. */
1282 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1286 const char *name
, *version_string
= NULL
;
1287 bool hidden
= false;
1290 name
= bfd_asymbol_name (sym
);
1291 if (do_demangle
&& name
[0] != '\0')
1293 /* Demangle the name. */
1294 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1299 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1300 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1303 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1306 name
= sanitize_string (name
);
1310 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s", name
);
1311 if (version_string
&& *version_string
!= '\0')
1312 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
,
1313 hidden
? "@%s" : "@@%s",
1318 printf ("%s", name
);
1319 if (version_string
&& *version_string
!= '\0')
1320 printf (hidden
? "@%s" : "@@%s", version_string
);
1328 sym_ok (bool want_section
,
1329 bfd
*abfd ATTRIBUTE_UNUSED
,
1332 struct disassemble_info
*inf
)
1336 /* NB: An object file can have different sections with the same
1337 section name. Compare compare section pointers if they have
1339 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1340 && sorted_syms
[place
]->section
!= sec
)
1343 /* Note - we cannot just compare section pointers because they could
1344 be different, but the same... Ie the symbol that we are trying to
1345 find could have come from a separate debug info file. Under such
1346 circumstances the symbol will be associated with a section in the
1347 debug info file, whilst the section we want is in a normal file.
1348 So the section pointers will be different, but the section names
1349 will be the same. */
1350 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1351 bfd_section_name (sec
)) != 0)
1355 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1358 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1359 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1360 require the symbol to be in the section. Returns NULL if there is no
1361 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1362 of the symbol in sorted_syms. */
1365 find_symbol_for_address (bfd_vma vma
,
1366 struct disassemble_info
*inf
,
1369 /* @@ Would it speed things up to cache the last two symbols returned,
1370 and maybe their address ranges? For many processors, only one memory
1371 operand can be present at a time, so the 2-entry cache wouldn't be
1372 constantly churned by code doing heavy memory accesses. */
1374 /* Indices in `sorted_syms'. */
1376 long max_count
= sorted_symcount
;
1378 struct objdump_disasm_info
*aux
;
1385 if (sorted_symcount
< 1)
1388 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1391 opb
= inf
->octets_per_byte
;
1393 /* Perform a binary search looking for the closest symbol to the
1394 required value. We are searching the range (min, max_count]. */
1395 while (min
+ 1 < max_count
)
1399 thisplace
= (max_count
+ min
) / 2;
1400 sym
= sorted_syms
[thisplace
];
1402 if (bfd_asymbol_value (sym
) > vma
)
1403 max_count
= thisplace
;
1404 else if (bfd_asymbol_value (sym
) < vma
)
1413 /* The symbol we want is now in min, the low end of the range we
1414 were searching. If there are several symbols with the same
1415 value, we want the first one. */
1417 while (thisplace
> 0
1418 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1419 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1422 /* Prefer a symbol in the current section if we have multple symbols
1423 with the same value, as can occur with overlays or zero size
1426 while (min
< max_count
1427 && (bfd_asymbol_value (sorted_syms
[min
])
1428 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1430 if (sym_ok (true, abfd
, min
, sec
, inf
))
1437 return sorted_syms
[thisplace
];
1442 /* If the file is relocatable, and the symbol could be from this
1443 section, prefer a symbol from this section over symbols from
1444 others, even if the other symbol's value might be closer.
1446 Note that this may be wrong for some symbol references if the
1447 sections have overlapping memory ranges, but in that case there's
1448 no way to tell what's desired without looking at the relocation
1451 Also give the target a chance to reject symbols. */
1452 want_section
= (aux
->require_sec
1453 || ((abfd
->flags
& HAS_RELOC
) != 0
1454 && vma
>= bfd_section_vma (sec
)
1455 && vma
< (bfd_section_vma (sec
)
1456 + bfd_section_size (sec
) / opb
)));
1458 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1461 long newplace
= sorted_symcount
;
1463 for (i
= min
- 1; i
>= 0; i
--)
1465 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1467 if (newplace
== sorted_symcount
)
1470 if (bfd_asymbol_value (sorted_syms
[i
])
1471 != bfd_asymbol_value (sorted_syms
[newplace
]))
1474 /* Remember this symbol and keep searching until we reach
1475 an earlier address. */
1480 if (newplace
!= sorted_symcount
)
1481 thisplace
= newplace
;
1484 /* We didn't find a good symbol with a smaller value.
1485 Look for one with a larger value. */
1486 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1488 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1496 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1497 /* There is no suitable symbol. */
1501 /* If we have not found an exact match for the specified address
1502 and we have dynamic relocations available, then we can produce
1503 a better result by matching a relocation to the address and
1504 using the symbol associated with that relocation. */
1505 rel_count
= inf
->dynrelcount
;
1507 && sorted_syms
[thisplace
]->value
!= vma
1509 && inf
->dynrelbuf
!= NULL
1510 && inf
->dynrelbuf
[0]->address
<= vma
1511 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1512 /* If we have matched a synthetic symbol, then stick with that. */
1513 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1516 arelent
** rel_high
;
1518 rel_low
= inf
->dynrelbuf
;
1519 rel_high
= rel_low
+ rel_count
- 1;
1520 while (rel_low
<= rel_high
)
1522 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1523 arelent
* rel
= *rel_mid
;
1525 if (rel
->address
== vma
)
1527 /* Absolute relocations do not provide a more helpful
1528 symbolic address. Find a non-absolute relocation
1529 with the same address. */
1530 arelent
**rel_vma
= rel_mid
;
1532 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1536 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1540 if (rel
->sym_ptr_ptr
!= NULL
1541 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1544 * place
= thisplace
;
1545 return * rel
->sym_ptr_ptr
;
1551 if (vma
< rel
->address
)
1553 else if (vma
>= rel_mid
[1]->address
)
1554 rel_low
= rel_mid
+ 1;
1563 return sorted_syms
[thisplace
];
1566 /* Print an address and the offset to the nearest symbol. */
1569 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1570 bfd_vma vma
, struct disassemble_info
*inf
,
1575 objdump_print_value (vma
, inf
, skip_zeroes
);
1576 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, " ");
1583 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
,"<");
1584 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s",
1585 sanitize_string (bfd_section_name (sec
)));
1586 secaddr
= bfd_section_vma (sec
);
1589 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,
1591 objdump_print_value (secaddr
- vma
, inf
, true);
1593 else if (vma
> secaddr
)
1595 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1596 objdump_print_value (vma
- secaddr
, inf
, true);
1598 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1602 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, "<");
1604 objdump_print_symname (abfd
, inf
, sym
);
1606 if (bfd_asymbol_value (sym
) == vma
)
1608 /* Undefined symbols in an executables and dynamic objects do not have
1609 a value associated with them, so it does not make sense to display
1610 an offset relative to them. Normally we would not be provided with
1611 this kind of symbol, but the target backend might choose to do so,
1612 and the code in find_symbol_for_address might return an as yet
1613 unresolved symbol associated with a dynamic reloc. */
1614 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1615 && bfd_is_und_section (sym
->section
))
1617 else if (bfd_asymbol_value (sym
) > vma
)
1619 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,"-0x");
1620 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1622 else if (vma
> bfd_asymbol_value (sym
))
1624 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1625 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1628 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1631 if (display_file_offsets
)
1632 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1633 _(" (File Offset: 0x%lx)"),
1634 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1637 /* Print an address (VMA), symbolically if possible.
1638 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1641 objdump_print_addr (bfd_vma vma
,
1642 struct disassemble_info
*inf
,
1645 struct objdump_disasm_info
*aux
;
1646 asymbol
*sym
= NULL
;
1647 bool skip_find
= false;
1649 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1651 if (sorted_symcount
< 1)
1655 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "0x");
1656 objdump_print_value (vma
, inf
, skip_zeroes
);
1659 if (display_file_offsets
)
1660 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1661 _(" (File Offset: 0x%lx)"),
1662 (long int) (inf
->section
->filepos
1663 + (vma
- inf
->section
->vma
)));
1667 if (aux
->reloc
!= NULL
1668 && aux
->reloc
->sym_ptr_ptr
!= NULL
1669 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1671 sym
= * aux
->reloc
->sym_ptr_ptr
;
1673 /* Adjust the vma to the reloc. */
1674 vma
+= bfd_asymbol_value (sym
);
1676 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1681 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1683 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1687 /* Print VMA to INFO. This function is passed to the disassembler
1691 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1693 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1696 /* Determine if the given address has a symbol associated with it. */
1699 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1703 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1704 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1710 /* Hold the last function name and the last line number we displayed
1711 in a disassembly. */
1713 static char *prev_functionname
;
1714 static unsigned int prev_line
;
1715 static unsigned int prev_discriminator
;
1717 /* We keep a list of all files that we have seen when doing a
1718 disassembly with source, so that we know how much of the file to
1719 display. This can be important for inlined functions. */
1721 struct print_file_list
1723 struct print_file_list
*next
;
1724 const char *filename
;
1725 const char *modname
;
1728 const char **linemap
;
1731 unsigned max_printed
;
1735 static struct print_file_list
*print_files
;
1737 /* The number of preceding context lines to show when we start
1738 displaying a file for the first time. */
1740 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1742 #if HAVE_LIBDEBUGINFOD
1743 /* Return a hex string represention of the build-id. */
1746 get_build_id (void * data
)
1749 char * build_id_str
;
1750 bfd
* abfd
= (bfd
*) data
;
1751 const struct bfd_build_id
* build_id
;
1753 build_id
= abfd
->build_id
;
1754 if (build_id
== NULL
)
1757 build_id_str
= malloc (build_id
->size
* 2 + 1);
1758 if (build_id_str
== NULL
)
1761 for (i
= 0; i
< build_id
->size
; i
++)
1762 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
1763 build_id_str
[build_id
->size
* 2] = '\0';
1765 return (unsigned char *) build_id_str
;
1768 /* Search for a separate debug file matching ABFD's build-id. */
1771 find_separate_debug (const bfd
* abfd
)
1773 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1774 separate_info
* i
= first_separate_info
;
1776 if (build_id
== NULL
|| i
== NULL
)
1781 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1783 if (abfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1785 const unsigned char * data
= i_bfd
->build_id
->data
;
1786 size_t size
= i_bfd
->build_id
->size
;
1788 if (size
== build_id
->size
1789 && memcmp (data
, build_id
->data
, size
) == 0)
1790 return (bfd
*) i
->handle
;
1799 /* Search for a separate debug file matching ABFD's .gnu_debugaltlink
1803 find_alt_debug (const bfd
* abfd
)
1808 struct dwarf_section
* section
;
1809 const struct bfd_build_id
* build_id
= abfd
->build_id
;
1810 separate_info
* i
= first_separate_info
;
1814 || !load_debug_section (gnu_debugaltlink
, (void *) abfd
))
1817 section
= &debug_displays
[gnu_debugaltlink
].section
;
1818 if (section
== NULL
)
1821 name
= (const char *) section
->start
;
1822 namelen
= strnlen (name
, section
->size
) + 1;
1825 if (namelen
>= section
->size
)
1828 id_len
= section
->size
- namelen
;
1832 /* Compare the .gnu_debugaltlink build-id with the build-ids of the
1833 known separate_info files. */
1836 const bfd
* i_bfd
= (bfd
*) i
->handle
;
1838 if (i_bfd
!= NULL
&& i_bfd
->build_id
!= NULL
)
1840 const unsigned char * data
= i_bfd
->build_id
->data
;
1841 size_t size
= i_bfd
->build_id
->size
;
1844 && memcmp (section
->start
+ namelen
, data
, size
) == 0)
1845 return (bfd
*) i
->handle
;
1854 #endif /* HAVE_LIBDEBUGINFOD */
1856 /* Reads the contents of file FN into memory. Returns a pointer to the buffer.
1857 Also returns the size of the buffer in SIZE_RETURN and a filled out
1858 stat structure in FST_RETURN. Returns NULL upon failure. */
1861 slurp_file (const char * fn
,
1862 size_t * size_return
,
1863 struct stat
* fst_return
,
1864 bfd
* abfd ATTRIBUTE_UNUSED
)
1874 if (fn
== NULL
|| * fn
== 0 || size_return
== NULL
|| fst_return
== NULL
)
1877 fd
= open (fn
, O_RDONLY
| O_BINARY
);
1879 #if HAVE_LIBDEBUGINFOD
1880 if (fd
< 0 && use_debuginfod
&& fn
[0] == '/' && abfd
!= NULL
)
1882 unsigned char *build_id
= get_build_id (abfd
);
1886 debuginfod_client
*client
= debuginfod_begin ();
1890 fd
= debuginfod_find_source (client
, build_id
, 0, fn
, NULL
);
1891 debuginfod_end (client
);
1901 if (fstat (fd
, fst_return
) < 0)
1907 *size_return
= fst_return
->st_size
;
1910 ps
= getpagesize ();
1911 msize
= (*size_return
+ ps
- 1) & ~(ps
- 1);
1912 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1913 if (map
!= (char *) -1L)
1920 map
= (const char *) malloc (*size_return
);
1921 if (!map
|| (size_t) read (fd
, (char *) map
, *size_return
) != *size_return
)
1923 free ((void *) map
);
1930 #define line_map_decrease 5
1932 /* Precompute array of lines for a mapped file. */
1934 static const char **
1935 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1937 const char *p
, *lstart
, *end
;
1938 int chars_per_line
= 45; /* First iteration will use 40. */
1939 unsigned int lineno
;
1940 const char **linemap
= NULL
;
1941 unsigned long line_map_size
= 0;
1947 for (p
= map
; p
< end
; p
++)
1951 if (p
+ 1 < end
&& p
[1] == '\r')
1954 else if (*p
== '\r')
1956 if (p
+ 1 < end
&& p
[1] == '\n')
1962 /* End of line found. */
1964 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1966 unsigned long newsize
;
1968 chars_per_line
-= line_map_decrease
;
1969 if (chars_per_line
<= 1)
1971 line_map_size
= size
/ chars_per_line
+ 1;
1972 if (line_map_size
< lineno
+ 1)
1973 line_map_size
= lineno
+ 1;
1974 newsize
= line_map_size
* sizeof (char *);
1975 linemap
= (const char **) xrealloc (linemap
, newsize
);
1978 linemap
[lineno
++] = lstart
;
1986 /* Tries to open MODNAME, and if successful adds a node to print_files
1987 linked list and returns that node. Also fills in the stat structure
1988 pointed to by FST_RETURN. Returns NULL on failure. */
1990 static struct print_file_list
*
1991 try_print_file_open (const char * origname
,
1992 const char * modname
,
1993 struct stat
* fst_return
,
1996 struct print_file_list
*p
;
1998 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
2000 p
->map
= slurp_file (modname
, &p
->mapsize
, fst_return
, abfd
);
2007 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
2010 p
->filename
= origname
;
2011 p
->modname
= modname
;
2012 p
->next
= print_files
;
2018 /* If the source file, as described in the symtab, is not found
2019 try to locate it in one of the paths specified with -I
2020 If found, add location to print_files linked list. */
2022 static struct print_file_list
*
2023 update_source_path (const char *filename
, bfd
*abfd
)
2025 struct print_file_list
*p
;
2030 p
= try_print_file_open (filename
, filename
, &fst
, abfd
);
2033 if (include_path_count
== 0)
2036 /* Get the name of the file. */
2037 fname
= lbasename (filename
);
2039 /* If file exists under a new path, we need to add it to the list
2040 so that show_line knows about it. */
2041 for (i
= 0; i
< include_path_count
; i
++)
2043 char *modname
= concat (include_paths
[i
], "/", fname
,
2046 p
= try_print_file_open (filename
, modname
, &fst
, abfd
);
2056 long mtime
= bfd_get_mtime (abfd
);
2058 if (fst
.st_mtime
> mtime
)
2059 warn (_("source file %s is more recent than object file\n"),
2066 /* Print a source file line. */
2069 print_line (struct print_file_list
*p
, unsigned int linenum
)
2074 if (linenum
>= p
->maxline
)
2076 l
= p
->linemap
[linenum
];
2077 if (source_comment
!= NULL
&& strlen (l
) > 0)
2078 printf ("%s", source_comment
);
2079 len
= strcspn (l
, "\n\r");
2080 /* Test fwrite return value to quiet glibc warning. */
2081 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
2085 /* Print a range of source code lines. */
2088 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
2096 print_line (p
, start
);
2101 /* Show the line number, or the source line, in a disassembly
2105 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
2107 const char *filename
;
2108 const char *functionname
;
2109 unsigned int linenumber
;
2110 unsigned int discriminator
;
2114 if (! with_line_numbers
&& ! with_source_code
)
2117 #ifdef HAVE_LIBDEBUGINFOD
2120 const char *alt_filename
= NULL
;
2126 /* PR 29075: Check for separate debuginfo and .gnu_debugaltlink files.
2127 They need to be passed to bfd_find_nearest_line_with_alt in case they
2128 were downloaded from debuginfod. Otherwise libbfd will attempt to
2129 search for them and fail to locate them. */
2130 debug_bfd
= find_separate_debug (abfd
);
2131 if (debug_bfd
== NULL
)
2134 alt_bfd
= find_alt_debug (debug_bfd
);
2135 if (alt_bfd
!= NULL
)
2136 alt_filename
= bfd_get_filename (alt_bfd
);
2141 bfd_set_error (bfd_error_no_error
);
2142 if (! bfd_find_nearest_line_with_alt (debug_bfd
, alt_filename
,
2144 addr_offset
, &filename
,
2145 &functionname
, &linenumber
,
2148 if (bfd_get_error () == bfd_error_no_error
)
2150 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
,
2151 addr_offset
, &filename
,
2152 &functionname
, &linenumber
,
2158 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
2159 &filename
, &functionname
,
2160 &linenumber
, &discriminator
))
2164 if (filename
!= NULL
&& *filename
== '\0')
2166 if (functionname
!= NULL
&& *functionname
== '\0')
2167 functionname
= NULL
;
2170 && IS_ABSOLUTE_PATH (filename
)
2174 const char *fname
= filename
;
2176 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
2179 memcpy (path
, prefix
, prefix_length
);
2180 path_up
= path
+ prefix_length
;
2182 /* Build relocated filename, stripping off leading directories
2183 from the initial filename if requested. */
2184 if (prefix_strip
> 0)
2189 /* Skip selected directory levels. */
2190 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
2191 if (IS_DIR_SEPARATOR (*s
))
2198 /* Update complete filename. */
2199 strcpy (path_up
, fname
);
2207 if (with_line_numbers
)
2209 if (functionname
!= NULL
2210 && (prev_functionname
== NULL
2211 || strcmp (functionname
, prev_functionname
) != 0))
2213 char *demangle_alloc
= NULL
;
2214 if (do_demangle
&& functionname
[0] != '\0')
2216 /* Demangle the name. */
2217 demangle_alloc
= bfd_demangle (abfd
, functionname
,
2221 /* Demangling adds trailing parens, so don't print those. */
2222 if (demangle_alloc
!= NULL
)
2223 printf ("%s:\n", sanitize_string (demangle_alloc
));
2225 printf ("%s():\n", sanitize_string (functionname
));
2228 free (demangle_alloc
);
2231 && (linenumber
!= prev_line
2232 || discriminator
!= prev_discriminator
))
2234 if (discriminator
> 0)
2235 printf ("%s:%u (discriminator %u)\n",
2236 filename
== NULL
? "???" : sanitize_string (filename
),
2237 linenumber
, discriminator
);
2239 printf ("%s:%u\n", filename
== NULL
2240 ? "???" : sanitize_string (filename
),
2245 const char *filename2
;
2246 const char *functionname2
;
2249 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2252 printf ("inlined by %s:%u",
2253 sanitize_string (filename2
), line2
);
2254 printf (" (%s)\n", sanitize_string (functionname2
));
2259 if (with_source_code
2263 struct print_file_list
**pp
, *p
;
2266 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2267 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2274 filename
= xstrdup (filename
);
2275 p
= update_source_path (filename
, abfd
);
2278 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2280 if (file_start_context
&& p
->first
)
2284 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2285 if (l
>= linenumber
)
2287 if (p
->max_printed
>= l
)
2289 if (p
->max_printed
< linenumber
)
2290 l
= p
->max_printed
+ 1;
2295 dump_lines (p
, l
, linenumber
);
2296 if (p
->max_printed
< linenumber
)
2297 p
->max_printed
= linenumber
;
2298 p
->last_line
= linenumber
;
2303 if (functionname
!= NULL
2304 && (prev_functionname
== NULL
2305 || strcmp (functionname
, prev_functionname
) != 0))
2307 if (prev_functionname
!= NULL
)
2308 free (prev_functionname
);
2309 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2310 strcpy (prev_functionname
, functionname
);
2313 if (linenumber
> 0 && linenumber
!= prev_line
)
2314 prev_line
= linenumber
;
2316 if (discriminator
!= prev_discriminator
)
2317 prev_discriminator
= discriminator
;
2323 /* Pseudo FILE object for strings. */
2331 /* sprintf to a "stream". */
2333 static int ATTRIBUTE_PRINTF_2
2334 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2341 size_t space
= f
->alloc
- f
->pos
;
2343 va_start (args
, format
);
2344 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2350 f
->alloc
= (f
->alloc
+ n
) * 2;
2351 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2358 /* Return an integer greater than, or equal to zero, representing the color
2359 for STYLE, or -1 if no color should be used. */
2362 objdump_color_for_disassembler_style (enum disassembler_style style
)
2366 if (style
== dis_style_comment_start
)
2367 disassembler_in_comment
= true;
2369 if (disassembler_color
== on
)
2371 if (disassembler_in_comment
)
2376 case dis_style_symbol
:
2379 case dis_style_assembler_directive
:
2380 case dis_style_sub_mnemonic
:
2381 case dis_style_mnemonic
:
2384 case dis_style_register
:
2387 case dis_style_address
:
2388 case dis_style_address_offset
:
2389 case dis_style_immediate
:
2393 case dis_style_text
:
2398 else if (disassembler_color
== extended
)
2400 if (disassembler_in_comment
)
2405 case dis_style_symbol
:
2408 case dis_style_assembler_directive
:
2409 case dis_style_sub_mnemonic
:
2410 case dis_style_mnemonic
:
2413 case dis_style_register
:
2416 case dis_style_address
:
2417 case dis_style_address_offset
:
2418 case dis_style_immediate
:
2422 case dis_style_text
:
2427 else if (disassembler_color
!= off
)
2428 bfd_fatal (_("disassembly color not correctly selected"));
2433 /* Like objdump_sprintf, but add in escape sequences to highlight the
2434 content according to STYLE. */
2436 static int ATTRIBUTE_PRINTF_3
2437 objdump_styled_sprintf (SFILE
*f
, enum disassembler_style style
,
2438 const char *format
, ...)
2442 int color
= objdump_color_for_disassembler_style (style
);
2448 size_t space
= f
->alloc
- f
->pos
;
2450 if (disassembler_color
== on
)
2451 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[%dm", color
);
2453 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[38;5;%dm", color
);
2457 f
->alloc
= (f
->alloc
+ n
) * 2;
2458 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2465 size_t space
= f
->alloc
- f
->pos
;
2467 va_start (args
, format
);
2468 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2474 f
->alloc
= (f
->alloc
+ n
) * 2;
2475 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2483 size_t space
= f
->alloc
- f
->pos
;
2485 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[0m");
2490 f
->alloc
= (f
->alloc
+ n
) * 2;
2491 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2499 /* We discard the styling information here. This function is only used
2500 when objdump is printing auxiliary information, the symbol headers, and
2501 disassembly address, or the bytes of the disassembled instruction. We
2502 don't (currently) apply styling to any of this stuff, so, for now, just
2503 print the content with no additional style added. */
2505 static int ATTRIBUTE_PRINTF_3
2506 fprintf_styled (FILE *f
, enum disassembler_style style ATTRIBUTE_UNUSED
,
2507 const char *fmt
, ...)
2513 res
= vfprintf (f
, fmt
, ap
);
2519 /* Code for generating (colored) diagrams of control flow start and end
2522 /* Structure used to store the properties of a jump. */
2526 /* The next jump, or NULL if this is the last object. */
2527 struct jump_info
*next
;
2528 /* The previous jump, or NULL if this is the first object. */
2529 struct jump_info
*prev
;
2530 /* The start addresses of the jump. */
2533 /* The list of start addresses. */
2535 /* The number of elements. */
2537 /* The maximum number of elements that fit into the array. */
2540 /* The end address of the jump. */
2542 /* The drawing level of the jump. */
2546 /* Construct a jump object for a jump from start
2547 to end with the corresponding level. */
2549 static struct jump_info
*
2550 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2552 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2554 result
->next
= NULL
;
2555 result
->prev
= NULL
;
2556 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2557 result
->start
.addresses
[0] = start
;
2558 result
->start
.count
= 1;
2559 result
->start
.max_count
= 2;
2561 result
->level
= level
;
2566 /* Free a jump object and return the next object
2567 or NULL if this was the last one. */
2569 static struct jump_info
*
2570 jump_info_free (struct jump_info
*ji
)
2572 struct jump_info
*result
= NULL
;
2577 if (ji
->start
.addresses
)
2578 free (ji
->start
.addresses
);
2585 /* Get the smallest value of all start and end addresses. */
2588 jump_info_min_address (const struct jump_info
*ji
)
2590 bfd_vma min_address
= ji
->end
;
2593 for (i
= ji
->start
.count
; i
-- > 0;)
2594 if (ji
->start
.addresses
[i
] < min_address
)
2595 min_address
= ji
->start
.addresses
[i
];
2599 /* Get the largest value of all start and end addresses. */
2602 jump_info_max_address (const struct jump_info
*ji
)
2604 bfd_vma max_address
= ji
->end
;
2607 for (i
= ji
->start
.count
; i
-- > 0;)
2608 if (ji
->start
.addresses
[i
] > max_address
)
2609 max_address
= ji
->start
.addresses
[i
];
2613 /* Get the target address of a jump. */
2616 jump_info_end_address (const struct jump_info
*ji
)
2621 /* Test if an address is one of the start addresses of a jump. */
2624 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2626 bool result
= false;
2629 for (i
= ji
->start
.count
; i
-- > 0;)
2630 if (address
== ji
->start
.addresses
[i
])
2639 /* Test if an address is the target address of a jump. */
2642 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2644 return (address
== ji
->end
);
2647 /* Get the difference between the smallest and largest address of a jump. */
2650 jump_info_size (const struct jump_info
*ji
)
2652 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2655 /* Unlink a jump object from a list. */
2658 jump_info_unlink (struct jump_info
*node
,
2659 struct jump_info
**base
)
2662 node
->next
->prev
= node
->prev
;
2664 node
->prev
->next
= node
->next
;
2671 /* Insert unlinked jump info node into a list. */
2674 jump_info_insert (struct jump_info
*node
,
2675 struct jump_info
*target
,
2676 struct jump_info
**base
)
2678 node
->next
= target
;
2679 node
->prev
= target
->prev
;
2680 target
->prev
= node
;
2682 node
->prev
->next
= node
;
2687 /* Add unlinked node to the front of a list. */
2690 jump_info_add_front (struct jump_info
*node
,
2691 struct jump_info
**base
)
2695 node
->next
->prev
= node
;
2700 /* Move linked node to target position. */
2703 jump_info_move_linked (struct jump_info
*node
,
2704 struct jump_info
*target
,
2705 struct jump_info
**base
)
2708 jump_info_unlink (node
, base
);
2709 /* Insert node at target position. */
2710 jump_info_insert (node
, target
, base
);
2713 /* Test if two jumps intersect. */
2716 jump_info_intersect (const struct jump_info
*a
,
2717 const struct jump_info
*b
)
2719 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2720 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2723 /* Merge two compatible jump info objects. */
2726 jump_info_merge (struct jump_info
**base
)
2728 struct jump_info
*a
;
2730 for (a
= *base
; a
; a
= a
->next
)
2732 struct jump_info
*b
;
2734 for (b
= a
->next
; b
; b
= b
->next
)
2736 /* Merge both jumps into one. */
2737 if (a
->end
== b
->end
)
2739 /* Reallocate addresses. */
2740 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2743 if (needed_size
> a
->start
.max_count
)
2745 a
->start
.max_count
+= b
->start
.max_count
;
2746 a
->start
.addresses
=
2747 xrealloc (a
->start
.addresses
,
2748 a
->start
.max_count
* sizeof (bfd_vma
*));
2751 /* Append start addresses. */
2752 for (i
= 0; i
< b
->start
.count
; ++i
)
2753 a
->start
.addresses
[a
->start
.count
++] =
2754 b
->start
.addresses
[i
];
2756 /* Remove and delete jump. */
2757 struct jump_info
*tmp
= b
->prev
;
2758 jump_info_unlink (b
, base
);
2766 /* Sort jumps by their size and starting point using a stable
2767 minsort. This could be improved if sorting performance is
2768 an issue, for example by using mergesort. */
2771 jump_info_sort (struct jump_info
**base
)
2773 struct jump_info
*current_element
= *base
;
2775 while (current_element
)
2777 struct jump_info
*best_match
= current_element
;
2778 struct jump_info
*runner
= current_element
->next
;
2779 bfd_vma best_size
= jump_info_size (best_match
);
2783 bfd_vma runner_size
= jump_info_size (runner
);
2785 if ((runner_size
< best_size
)
2786 || ((runner_size
== best_size
)
2787 && (jump_info_min_address (runner
)
2788 < jump_info_min_address (best_match
))))
2790 best_match
= runner
;
2791 best_size
= runner_size
;
2794 runner
= runner
->next
;
2797 if (best_match
== current_element
)
2798 current_element
= current_element
->next
;
2800 jump_info_move_linked (best_match
, current_element
, base
);
2804 /* Visualize all jumps at a given address. */
2807 jump_info_visualize_address (bfd_vma address
,
2810 uint8_t *color_buffer
)
2812 struct jump_info
*ji
= detected_jumps
;
2813 size_t len
= (max_level
+ 1) * 3;
2815 /* Clear line buffer. */
2816 memset (line_buffer
, ' ', len
);
2817 memset (color_buffer
, 0, len
);
2819 /* Iterate over jumps and add their ASCII art. */
2822 /* Discard jumps that are never needed again. */
2823 if (jump_info_max_address (ji
) < address
)
2825 struct jump_info
*tmp
= ji
;
2828 jump_info_unlink (tmp
, &detected_jumps
);
2829 jump_info_free (tmp
);
2833 /* This jump intersects with the current address. */
2834 if (jump_info_min_address (ji
) <= address
)
2836 /* Hash target address to get an even
2837 distribution between all values. */
2838 bfd_vma hash_address
= jump_info_end_address (ji
);
2839 uint8_t color
= iterative_hash_object (hash_address
, 0);
2840 /* Fetch line offset. */
2841 int offset
= (max_level
- ji
->level
) * 3;
2843 /* Draw start line. */
2844 if (jump_info_is_start_address (ji
, address
))
2846 size_t i
= offset
+ 1;
2848 for (; i
< len
- 1; ++i
)
2849 if (line_buffer
[i
] == ' ')
2851 line_buffer
[i
] = '-';
2852 color_buffer
[i
] = color
;
2855 if (line_buffer
[i
] == ' ')
2857 line_buffer
[i
] = '-';
2858 color_buffer
[i
] = color
;
2860 else if (line_buffer
[i
] == '>')
2862 line_buffer
[i
] = 'X';
2863 color_buffer
[i
] = color
;
2866 if (line_buffer
[offset
] == ' ')
2868 if (address
<= ji
->end
)
2869 line_buffer
[offset
] =
2870 (jump_info_min_address (ji
) == address
) ? '/': '+';
2872 line_buffer
[offset
] =
2873 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2874 color_buffer
[offset
] = color
;
2877 /* Draw jump target. */
2878 else if (jump_info_is_end_address (ji
, address
))
2880 size_t i
= offset
+ 1;
2882 for (; i
< len
- 1; ++i
)
2883 if (line_buffer
[i
] == ' ')
2885 line_buffer
[i
] = '-';
2886 color_buffer
[i
] = color
;
2889 if (line_buffer
[i
] == ' ')
2891 line_buffer
[i
] = '>';
2892 color_buffer
[i
] = color
;
2894 else if (line_buffer
[i
] == '-')
2896 line_buffer
[i
] = 'X';
2897 color_buffer
[i
] = color
;
2900 if (line_buffer
[offset
] == ' ')
2902 if (jump_info_min_address (ji
) < address
)
2903 line_buffer
[offset
] =
2904 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2906 line_buffer
[offset
] = '/';
2907 color_buffer
[offset
] = color
;
2910 /* Draw intermediate line segment. */
2911 else if (line_buffer
[offset
] == ' ')
2913 line_buffer
[offset
] = '|';
2914 color_buffer
[offset
] = color
;
2922 /* Clone of disassemble_bytes to detect jumps inside a function. */
2923 /* FIXME: is this correct? Can we strip it down even further? */
2925 static struct jump_info
*
2926 disassemble_jumps (struct disassemble_info
* inf
,
2927 disassembler_ftype disassemble_fn
,
2928 bfd_vma start_offset
,
2929 bfd_vma stop_offset
,
2932 arelent
** relppend
)
2934 struct objdump_disasm_info
*aux
;
2935 struct jump_info
*jumps
= NULL
;
2937 bfd_vma addr_offset
;
2938 unsigned int opb
= inf
->octets_per_byte
;
2942 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2943 section
= inf
->section
;
2946 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2949 inf
->insn_info_valid
= 0;
2950 disassemble_set_printf (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
2951 (fprintf_styled_ftype
) objdump_styled_sprintf
);
2953 addr_offset
= start_offset
;
2954 while (addr_offset
< stop_offset
)
2956 int previous_octets
;
2958 /* Remember the length of the previous instruction. */
2959 previous_octets
= octets
;
2963 inf
->bytes_per_line
= 0;
2964 inf
->bytes_per_chunk
= 0;
2965 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2966 | (wide_output
? WIDE_OUTPUT
: 0));
2968 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2970 if (inf
->disassembler_needs_relocs
2971 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2972 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2973 && *relppp
< relppend
)
2975 bfd_signed_vma distance_to_rel
;
2977 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2979 /* Check to see if the current reloc is associated with
2980 the instruction that we are about to disassemble. */
2981 if (distance_to_rel
== 0
2982 /* FIXME: This is wrong. We are trying to catch
2983 relocs that are addressed part way through the
2984 current instruction, as might happen with a packed
2985 VLIW instruction. Unfortunately we do not know the
2986 length of the current instruction since we have not
2987 disassembled it yet. Instead we take a guess based
2988 upon the length of the previous instruction. The
2989 proper solution is to have a new target-specific
2990 disassembler function which just returns the length
2991 of an instruction at a given address without trying
2992 to display its disassembly. */
2993 || (distance_to_rel
> 0
2994 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2996 inf
->flags
|= INSN_HAS_RELOC
;
3000 if (! disassemble_all
3001 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3002 == (SEC_CODE
| SEC_HAS_CONTENTS
))
3003 /* Set a stop_vma so that the disassembler will not read
3004 beyond the next symbol. We assume that symbols appear on
3005 the boundaries between instructions. We only do this when
3006 disassembling code of course, and when -D is in effect. */
3007 inf
->stop_vma
= section
->vma
+ stop_offset
;
3009 inf
->stop_offset
= stop_offset
;
3011 /* Extract jump information. */
3012 inf
->insn_info_valid
= 0;
3013 disassembler_in_comment
= false;
3014 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3015 /* Test if a jump was detected. */
3016 if (inf
->insn_info_valid
3017 && ((inf
->insn_type
== dis_branch
)
3018 || (inf
->insn_type
== dis_condbranch
)
3019 || (inf
->insn_type
== dis_jsr
)
3020 || (inf
->insn_type
== dis_condjsr
))
3021 && (inf
->target
>= section
->vma
+ start_offset
)
3022 && (inf
->target
< section
->vma
+ stop_offset
))
3024 struct jump_info
*ji
=
3025 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
3026 jump_info_add_front (ji
, &jumps
);
3031 addr_offset
+= octets
/ opb
;
3034 disassemble_set_printf (inf
, (void *) stdout
, (fprintf_ftype
) fprintf
,
3035 (fprintf_styled_ftype
) fprintf_styled
);
3036 free (sfile
.buffer
);
3039 jump_info_merge (&jumps
);
3040 /* Process jumps. */
3041 jump_info_sort (&jumps
);
3043 /* Group jumps by level. */
3044 struct jump_info
*last_jump
= jumps
;
3049 /* The last jump is part of the next group. */
3050 struct jump_info
*base
= last_jump
;
3051 /* Increment level. */
3052 base
->level
= ++max_level
;
3054 /* Find jumps that can be combined on the same
3055 level, with the largest jumps tested first.
3056 This has the advantage that large jumps are on
3057 lower levels and do not intersect with small
3058 jumps that get grouped on higher levels. */
3059 struct jump_info
*exchange_item
= last_jump
->next
;
3060 struct jump_info
*it
= exchange_item
;
3062 for (; it
; it
= it
->next
)
3064 /* Test if the jump intersects with any
3065 jump from current group. */
3067 struct jump_info
*it_collision
;
3069 for (it_collision
= base
;
3070 it_collision
!= exchange_item
;
3071 it_collision
= it_collision
->next
)
3073 /* This jump intersects so we leave it out. */
3074 if (jump_info_intersect (it_collision
, it
))
3081 /* Add jump to group. */
3084 /* Move current element to the front. */
3085 if (it
!= exchange_item
)
3087 struct jump_info
*save
= it
->prev
;
3088 jump_info_move_linked (it
, exchange_item
, &jumps
);
3094 last_jump
= exchange_item
;
3095 exchange_item
= exchange_item
->next
;
3097 last_jump
->level
= max_level
;
3101 /* Move to next group. */
3102 last_jump
= exchange_item
;
3108 /* The number of zeroes we want to see before we start skipping them.
3109 The number is arbitrarily chosen. */
3111 #define DEFAULT_SKIP_ZEROES 8
3113 /* The number of zeroes to skip at the end of a section. If the
3114 number of zeroes at the end is between SKIP_ZEROES_AT_END and
3115 SKIP_ZEROES, they will be disassembled. If there are fewer than
3116 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
3117 attempt to avoid disassembling zeroes inserted by section
3120 #define DEFAULT_SKIP_ZEROES_AT_END 3
3123 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
3128 /* Like null_print, but takes the extra STYLE argument. As this is not
3129 going to print anything, the extra argument is just ignored. */
3132 null_styled_print (const void * stream ATTRIBUTE_UNUSED
,
3133 enum disassembler_style style ATTRIBUTE_UNUSED
,
3134 const char * format ATTRIBUTE_UNUSED
, ...)
3139 /* Print out jump visualization. */
3142 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
3143 uint8_t *color_buffer
)
3148 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
3150 size_t line_buffer_size
= strlen (line_buffer
);
3151 char last_color
= 0;
3154 for (i
= 0; i
<= line_buffer_size
; ++i
)
3158 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
3160 if (color
!= last_color
)
3163 if (extended_color_output
)
3164 /* Use extended 8bit color, but
3165 do not choose dark colors. */
3166 printf ("\033[38;5;%dm", 124 + (color
% 108));
3168 /* Use simple terminal colors. */
3169 printf ("\033[%dm", 31 + (color
% 7));
3176 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
3180 /* Disassemble some data in memory between given values. */
3183 disassemble_bytes (struct disassemble_info
*inf
,
3184 disassembler_ftype disassemble_fn
,
3187 bfd_vma start_offset
,
3188 bfd_vma stop_offset
,
3193 struct objdump_disasm_info
*aux
;
3195 unsigned int octets_per_line
;
3196 unsigned int skip_addr_chars
;
3197 bfd_vma addr_offset
;
3198 unsigned int opb
= inf
->octets_per_byte
;
3199 unsigned int skip_zeroes
= inf
->skip_zeroes
;
3200 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
3204 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
3205 section
= inf
->section
;
3208 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
3212 octets_per_line
= insn_width
;
3214 octets_per_line
= 4;
3216 octets_per_line
= 16;
3218 /* Figure out how many characters to skip at the start of an
3219 address, to make the disassembly look nicer. We discard leading
3220 zeroes in chunks of 4, ensuring that there is always a leading
3222 skip_addr_chars
= 0;
3223 if (!no_addresses
&& !prefix_addresses
)
3227 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
3229 while (buf
[skip_addr_chars
] == '0')
3232 /* Don't discard zeros on overflow. */
3233 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
3234 skip_addr_chars
= 0;
3236 if (skip_addr_chars
!= 0)
3237 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
3240 inf
->insn_info_valid
= 0;
3242 /* Determine maximum level. */
3243 uint8_t *color_buffer
= NULL
;
3244 char *line_buffer
= NULL
;
3247 /* Some jumps were detected. */
3250 struct jump_info
*ji
;
3252 /* Find maximum jump level. */
3253 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
3255 if (ji
->level
> max_level
)
3256 max_level
= ji
->level
;
3259 /* Allocate buffers. */
3260 size_t len
= (max_level
+ 1) * 3 + 1;
3261 line_buffer
= xmalloc (len
);
3262 line_buffer
[len
- 1] = 0;
3263 color_buffer
= xmalloc (len
);
3264 color_buffer
[len
- 1] = 0;
3267 addr_offset
= start_offset
;
3268 while (addr_offset
< stop_offset
)
3270 bool need_nl
= false;
3274 /* Make sure we don't use relocs from previous instructions. */
3277 /* If we see more than SKIP_ZEROES octets of zeroes, we just
3279 if (! disassemble_zeroes
)
3280 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
3281 if (data
[addr_offset
* opb
+ octets
] != 0)
3283 if (! disassemble_zeroes
3284 && (inf
->insn_info_valid
== 0
3285 || inf
->branch_delay_insns
== 0)
3286 && (octets
>= skip_zeroes
3287 || (addr_offset
* opb
+ octets
== stop_offset
* opb
3288 && octets
< skip_zeroes_at_end
)))
3290 /* If there are more nonzero octets to follow, we only skip
3291 zeroes in multiples of 4, to try to avoid running over
3292 the start of an instruction which happens to start with
3294 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
3297 /* If we are going to display more data, and we are displaying
3298 file offsets, then tell the user how many zeroes we skip
3299 and the file offset from where we resume dumping. */
3300 if (display_file_offsets
3301 && addr_offset
+ octets
/ opb
< stop_offset
)
3302 printf (_("\t... (skipping %lu zeroes, "
3303 "resuming at file offset: 0x%lx)\n"),
3304 (unsigned long) (octets
/ opb
),
3305 (unsigned long) (section
->filepos
3306 + addr_offset
+ octets
/ opb
));
3313 unsigned int bpc
= 0;
3314 unsigned int pb
= 0;
3316 if (with_line_numbers
|| with_source_code
)
3317 show_line (aux
->abfd
, section
, addr_offset
);
3321 else if (!prefix_addresses
)
3325 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
3326 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3330 printf ("%s:\t", buf
+ skip_addr_chars
);
3334 aux
->require_sec
= true;
3335 objdump_print_address (section
->vma
+ addr_offset
, inf
);
3336 aux
->require_sec
= false;
3340 print_jump_visualisation (section
->vma
+ addr_offset
,
3341 max_level
, line_buffer
,
3349 disassemble_set_printf
3350 (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
3351 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3352 inf
->bytes_per_line
= 0;
3353 inf
->bytes_per_chunk
= 0;
3354 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
3355 | (wide_output
? WIDE_OUTPUT
: 0));
3357 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
3359 if (inf
->disassembler_needs_relocs
3360 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
3361 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
3362 && *relppp
< relppend
)
3364 bfd_signed_vma distance_to_rel
;
3365 int max_reloc_offset
3366 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
3368 distance_to_rel
= ((**relppp
)->address
- rel_offset
3372 if (distance_to_rel
> 0
3373 && (max_reloc_offset
< 0
3374 || distance_to_rel
<= max_reloc_offset
))
3376 /* This reloc *might* apply to the current insn,
3377 starting somewhere inside it. Discover the length
3378 of the current insn so that the check below will
3381 insn_size
= insn_width
;
3384 /* We find the length by calling the dissassembler
3385 function with a dummy print handler. This should
3386 work unless the disassembler is not expecting to
3387 be called multiple times for the same address.
3389 This does mean disassembling the instruction
3390 twice, but we only do this when there is a high
3391 probability that there is a reloc that will
3392 affect the instruction. */
3393 disassemble_set_printf
3394 (inf
, inf
->stream
, (fprintf_ftype
) null_print
,
3395 (fprintf_styled_ftype
) null_styled_print
);
3396 insn_size
= disassemble_fn (section
->vma
3397 + addr_offset
, inf
);
3398 disassemble_set_printf
3400 (fprintf_ftype
) objdump_sprintf
,
3401 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3405 /* Check to see if the current reloc is associated with
3406 the instruction that we are about to disassemble. */
3407 if (distance_to_rel
== 0
3408 || (distance_to_rel
> 0
3409 && distance_to_rel
< insn_size
/ (int) opb
))
3411 inf
->flags
|= INSN_HAS_RELOC
;
3412 aux
->reloc
= **relppp
;
3416 if (! disassemble_all
3417 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3418 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3419 /* Set a stop_vma so that the disassembler will not read
3420 beyond the next symbol. We assume that symbols appear on
3421 the boundaries between instructions. We only do this when
3422 disassembling code of course, and when -D is in effect. */
3423 inf
->stop_vma
= section
->vma
+ stop_offset
;
3425 inf
->stop_offset
= stop_offset
;
3426 disassembler_in_comment
= false;
3427 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3431 disassemble_set_printf (inf
, stdout
, (fprintf_ftype
) fprintf
,
3432 (fprintf_styled_ftype
) fprintf_styled
);
3433 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3434 octets_per_line
= inf
->bytes_per_line
;
3435 if (insn_size
< (int) opb
)
3438 printf ("%s\n", sfile
.buffer
);
3441 non_fatal (_("disassemble_fn returned length %d"),
3452 octets
= octets_per_line
;
3453 if (addr_offset
+ octets
/ opb
> stop_offset
)
3454 octets
= (stop_offset
- addr_offset
) * opb
;
3456 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3458 if (ISPRINT (data
[j
]))
3459 buf
[j
- addr_offset
* opb
] = data
[j
];
3461 buf
[j
- addr_offset
* opb
] = '.';
3463 buf
[j
- addr_offset
* opb
] = '\0';
3466 if (prefix_addresses
3468 : show_raw_insn
>= 0)
3472 /* If ! prefix_addresses and ! wide_output, we print
3473 octets_per_line octets per line. */
3475 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3476 pb
= octets_per_line
;
3478 if (inf
->bytes_per_chunk
)
3479 bpc
= inf
->bytes_per_chunk
;
3483 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3485 /* PR 21580: Check for a buffer ending early. */
3486 if (j
+ bpc
<= stop_offset
* opb
)
3490 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3492 for (k
= bpc
; k
-- != 0; )
3493 printf ("%02x", (unsigned) data
[j
+ k
]);
3497 for (k
= 0; k
< bpc
; k
++)
3498 printf ("%02x", (unsigned) data
[j
+ k
]);
3504 for (; pb
< octets_per_line
; pb
+= bpc
)
3508 for (k
= 0; k
< bpc
; k
++)
3513 /* Separate raw data from instruction by extra space. */
3523 printf ("%s", sfile
.buffer
);
3525 if (prefix_addresses
3527 : show_raw_insn
>= 0)
3535 j
= addr_offset
* opb
+ pb
;
3541 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3542 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3546 printf ("%s:\t", buf
+ skip_addr_chars
);
3549 print_jump_visualisation (section
->vma
+ j
/ opb
,
3550 max_level
, line_buffer
,
3553 pb
+= octets_per_line
;
3556 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3558 /* PR 21619: Check for a buffer ending early. */
3559 if (j
+ bpc
<= stop_offset
* opb
)
3563 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3565 for (k
= bpc
; k
-- != 0; )
3566 printf ("%02x", (unsigned) data
[j
+ k
]);
3570 for (k
= 0; k
< bpc
; k
++)
3571 printf ("%02x", (unsigned) data
[j
+ k
]);
3585 while ((*relppp
) < relppend
3586 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3588 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3601 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3606 if (q
->howto
== NULL
)
3607 printf ("*unknown*\t");
3608 else if (q
->howto
->name
)
3609 printf ("%s\t", q
->howto
->name
);
3611 printf ("%d\t", q
->howto
->type
);
3613 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3614 printf ("*unknown*");
3617 const char *sym_name
;
3619 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3620 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3621 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3626 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3627 sym_name
= bfd_section_name (sym_sec
);
3628 if (sym_name
== NULL
|| *sym_name
== '\0')
3629 sym_name
= "*unknown*";
3630 printf ("%s", sanitize_string (sym_name
));
3636 bfd_vma addend
= q
->addend
;
3637 if ((bfd_signed_vma
) addend
< 0)
3644 objdump_print_value (addend
, inf
, true);
3656 addr_offset
+= octets
/ opb
;
3659 free (sfile
.buffer
);
3661 free (color_buffer
);
3665 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3667 const struct elf_backend_data
*bed
;
3668 bfd_vma sign_adjust
= 0;
3669 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3670 struct objdump_disasm_info
*paux
;
3671 unsigned int opb
= pinfo
->octets_per_byte
;
3672 bfd_byte
*data
= NULL
;
3673 bfd_size_type datasize
= 0;
3674 arelent
**rel_pp
= NULL
;
3675 arelent
**rel_ppstart
= NULL
;
3676 arelent
**rel_ppend
;
3677 bfd_vma stop_offset
;
3678 asymbol
*sym
= NULL
;
3682 unsigned long addr_offset
;
3686 stop_offset_reached
,
3691 /* Sections that do not contain machine
3692 code are not normally disassembled. */
3693 if (! disassemble_all
3694 && only_list
== NULL
3695 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3696 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3699 if (! process_section_p (section
))
3702 datasize
= bfd_section_size (section
);
3706 if (start_address
== (bfd_vma
) -1
3707 || start_address
< section
->vma
)
3710 addr_offset
= start_address
- section
->vma
;
3712 if (stop_address
== (bfd_vma
) -1)
3713 stop_offset
= datasize
/ opb
;
3716 if (stop_address
< section
->vma
)
3719 stop_offset
= stop_address
- section
->vma
;
3720 if (stop_offset
> datasize
/ opb
)
3721 stop_offset
= datasize
/ opb
;
3724 if (addr_offset
>= stop_offset
)
3727 /* Decide which set of relocs to use. Load them if necessary. */
3728 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3729 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3731 rel_pp
= pinfo
->dynrelbuf
;
3732 rel_count
= pinfo
->dynrelcount
;
3733 /* Dynamic reloc addresses are absolute, non-dynamic are section
3734 relative. REL_OFFSET specifies the reloc address corresponding
3735 to the start of this section. */
3736 rel_offset
= section
->vma
;
3744 if ((section
->flags
& SEC_RELOC
) != 0
3745 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3749 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3751 bfd_fatal (bfd_get_filename (abfd
));
3755 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3756 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3758 bfd_fatal (bfd_get_filename (abfd
));
3760 /* Sort the relocs by address. */
3761 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3765 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3767 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3769 non_fatal (_("Reading section %s failed because: %s"),
3770 section
->name
, bfd_errmsg (bfd_get_error ()));
3774 pinfo
->buffer
= data
;
3775 pinfo
->buffer_vma
= section
->vma
;
3776 pinfo
->buffer_length
= datasize
;
3777 pinfo
->section
= section
;
3779 /* Sort the symbols into value and section order. */
3780 compare_section
= section
;
3781 if (sorted_symcount
> 1)
3782 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3784 /* Skip over the relocs belonging to addresses below the
3786 while (rel_pp
< rel_ppend
3787 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3790 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3792 /* Find the nearest symbol forwards from our current position. */
3793 paux
->require_sec
= true;
3794 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3795 (struct disassemble_info
*) inf
,
3797 paux
->require_sec
= false;
3799 /* PR 9774: If the target used signed addresses then we must make
3800 sure that we sign extend the value that we calculate for 'addr'
3801 in the loop below. */
3802 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3803 && (bed
= get_elf_backend_data (abfd
)) != NULL
3804 && bed
->sign_extend_vma
)
3805 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3807 /* Disassemble a block of instructions up to the address associated with
3808 the symbol we have just found. Then print the symbol and find the
3809 next symbol on. Repeat until we have disassembled the entire section
3810 or we have reached the end of the address range we are interested in. */
3811 do_print
= paux
->symbol
== NULL
;
3812 loop_until
= stop_offset_reached
;
3814 while (addr_offset
< stop_offset
)
3818 bfd_vma nextstop_offset
;
3821 addr
= section
->vma
+ addr_offset
;
3822 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3824 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3829 (x
< sorted_symcount
3830 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3834 pinfo
->symbols
= sorted_syms
+ place
;
3835 pinfo
->num_symbols
= x
- place
;
3836 pinfo
->symtab_pos
= place
;
3840 pinfo
->symbols
= NULL
;
3841 pinfo
->num_symbols
= 0;
3842 pinfo
->symtab_pos
= -1;
3845 /* If we are only disassembling from a specific symbol,
3846 check to see if we should start or stop displaying. */
3847 if (sym
&& paux
->symbol
)
3851 /* See if we should stop printing. */
3855 if (sym
->flags
& BSF_FUNCTION
)
3859 case stop_offset_reached
:
3860 /* Handled by the while loop. */
3864 /* FIXME: There is an implicit assumption here
3865 that the name of sym is different from
3867 if (! bfd_is_local_label (abfd
, sym
))
3874 const char * name
= bfd_asymbol_name (sym
);
3875 char * alloc
= NULL
;
3877 if (do_demangle
&& name
[0] != '\0')
3879 /* Demangle the name. */
3880 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3885 /* We are not currently printing. Check to see
3886 if the current symbol matches the requested symbol. */
3887 if (streq (name
, paux
->symbol
))
3891 if (sym
->flags
& BSF_FUNCTION
)
3893 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3894 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3896 /* Sym is a function symbol with a size associated
3897 with it. Turn on automatic disassembly for the
3898 next VALUE bytes. */
3899 stop_offset
= addr_offset
3900 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3901 loop_until
= stop_offset_reached
;
3905 /* Otherwise we need to tell the loop heuristic to
3906 loop until the next function symbol is encountered. */
3907 loop_until
= function_sym
;
3912 /* Otherwise loop until the next symbol is encountered. */
3913 loop_until
= next_sym
;
3921 if (! prefix_addresses
&& do_print
)
3923 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3924 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3926 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3929 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3931 else if (sym
== NULL
)
3935 #define is_valid_next_sym(SYM) \
3936 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3937 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3938 && pinfo->symbol_is_valid (SYM, pinfo))
3940 /* Search forward for the next appropriate symbol in
3941 SECTION. Note that all the symbols are sorted
3942 together into one big array, and that some sections
3943 may have overlapping addresses. */
3944 while (place
< sorted_symcount
3945 && ! is_valid_next_sym (sorted_syms
[place
]))
3948 if (place
>= sorted_symcount
)
3951 nextsym
= sorted_syms
[place
];
3954 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3955 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3956 else if (nextsym
== NULL
)
3957 nextstop_offset
= stop_offset
;
3959 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3961 if (nextstop_offset
> stop_offset
3962 || nextstop_offset
<= addr_offset
)
3963 nextstop_offset
= stop_offset
;
3965 /* If a symbol is explicitly marked as being an object
3966 rather than a function, just dump the bytes without
3967 disassembling them. */
3970 || sym
->section
!= section
3971 || bfd_asymbol_value (sym
) > addr
3972 || ((sym
->flags
& BSF_OBJECT
) == 0
3973 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3975 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3977 || (sym
->flags
& BSF_FUNCTION
) != 0)
3984 /* Resolve symbol name. */
3985 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3987 struct disassemble_info di
;
3990 sf
.alloc
= strlen (sym
->name
) + 40;
3991 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3993 disassemble_set_printf
3994 (&di
, &sf
, (fprintf_ftype
) objdump_sprintf
,
3995 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3997 objdump_print_symname (abfd
, &di
, sym
);
3999 /* Fetch jump information. */
4000 detected_jumps
= disassemble_jumps
4001 (pinfo
, paux
->disassemble_fn
,
4002 addr_offset
, nextstop_offset
,
4003 rel_offset
, &rel_pp
, rel_ppend
);
4005 /* Free symbol name. */
4009 /* Add jumps to output. */
4010 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
4011 addr_offset
, nextstop_offset
,
4012 rel_offset
, &rel_pp
, rel_ppend
);
4015 while (detected_jumps
)
4017 detected_jumps
= jump_info_free (detected_jumps
);
4021 addr_offset
= nextstop_offset
;
4027 if (rel_ppstart
!= NULL
)
4031 /* Disassemble the contents of an object file. */
4034 disassemble_data (bfd
*abfd
)
4036 struct disassemble_info disasm_info
;
4037 struct objdump_disasm_info aux
;
4041 prev_functionname
= NULL
;
4043 prev_discriminator
= 0;
4045 /* We make a copy of syms to sort. We don't want to sort syms
4046 because that will screw up the relocs. */
4047 sorted_symcount
= symcount
? symcount
: dynsymcount
;
4048 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
4049 * sizeof (asymbol
*));
4050 if (sorted_symcount
!= 0)
4052 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
4053 sorted_symcount
* sizeof (asymbol
*));
4055 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
4058 for (i
= 0; i
< synthcount
; ++i
)
4060 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
4064 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
,
4065 (fprintf_styled_ftype
) fprintf_styled
);
4066 disasm_info
.application_data
= (void *) &aux
;
4068 aux
.require_sec
= false;
4069 disasm_info
.dynrelbuf
= NULL
;
4070 disasm_info
.dynrelcount
= 0;
4072 aux
.symbol
= disasm_sym
;
4074 disasm_info
.print_address_func
= objdump_print_address
;
4075 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
4077 if (machine
!= NULL
)
4079 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
4082 fatal (_("can't use supplied machine %s"), machine
);
4084 abfd
->arch_info
= inf
;
4087 if (endian
!= BFD_ENDIAN_UNKNOWN
)
4089 struct bfd_target
*xvec
;
4091 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
4092 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
4093 xvec
->byteorder
= endian
;
4097 /* Use libopcodes to locate a suitable disassembler. */
4098 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
4099 bfd_big_endian (abfd
),
4100 bfd_get_mach (abfd
), abfd
);
4101 if (!aux
.disassemble_fn
)
4103 non_fatal (_("can't disassemble for architecture %s\n"),
4104 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
4109 disasm_info
.flavour
= bfd_get_flavour (abfd
);
4110 disasm_info
.arch
= bfd_get_arch (abfd
);
4111 disasm_info
.mach
= bfd_get_mach (abfd
);
4112 disasm_info
.disassembler_options
= disassembler_options
;
4113 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
4114 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
4115 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
4116 disasm_info
.disassembler_needs_relocs
= false;
4118 if (bfd_big_endian (abfd
))
4119 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
4120 else if (bfd_little_endian (abfd
))
4121 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
4123 /* ??? Aborting here seems too drastic. We could default to big or little
4125 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
4127 disasm_info
.endian_code
= disasm_info
.endian
;
4129 /* Allow the target to customize the info structure. */
4130 disassemble_init_for_target (& disasm_info
);
4132 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
4133 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4135 if (relsize
< 0 && dump_dynamic_reloc_info
)
4136 bfd_fatal (bfd_get_filename (abfd
));
4140 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
4141 disasm_info
.dynrelcount
4142 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
4143 if (disasm_info
.dynrelcount
< 0)
4144 bfd_fatal (bfd_get_filename (abfd
));
4146 /* Sort the relocs by address. */
4147 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
4151 disasm_info
.symtab
= sorted_syms
;
4152 disasm_info
.symtab_size
= sorted_symcount
;
4154 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
4156 free (disasm_info
.dynrelbuf
);
4157 disasm_info
.dynrelbuf
= NULL
;
4159 disassemble_free_target (&disasm_info
);
4163 load_specific_debug_section (enum dwarf_section_display_enum debug
,
4164 asection
*sec
, void *file
)
4166 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4167 bfd
*abfd
= (bfd
*) file
;
4173 if (section
->start
!= NULL
)
4175 /* If it is already loaded, do nothing. */
4176 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4178 free (section
->start
);
4181 section
->filename
= bfd_get_filename (abfd
);
4182 section
->reloc_info
= NULL
;
4183 section
->num_relocs
= 0;
4184 section
->address
= bfd_section_vma (sec
);
4185 section
->size
= bfd_section_size (sec
);
4186 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
4187 alloced
= amt
= section
->size
+ 1;
4188 if (alloced
!= amt
|| alloced
== 0)
4190 section
->start
= NULL
;
4191 free_debug_section (debug
);
4192 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
4193 sanitize_string (section
->name
),
4194 (unsigned long long) section
->size
);
4198 section
->start
= contents
= xmalloc (alloced
);
4199 /* Ensure any string section has a terminating NUL. */
4200 section
->start
[section
->size
] = 0;
4202 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4203 && debug_displays
[debug
].relocate
)
4205 ret
= bfd_simple_get_relocated_section_contents (abfd
,
4211 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
4218 relocs
= (arelent
**) xmalloc (reloc_size
);
4220 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
4221 if (reloc_count
<= 0)
4225 section
->reloc_info
= relocs
;
4226 section
->num_relocs
= reloc_count
;
4232 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
4236 free_debug_section (debug
);
4237 printf (_("\nCan't get contents for section '%s'.\n"),
4238 sanitize_string (section
->name
));
4246 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
4251 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
4254 relocs
= (arelent
**) dsec
->reloc_info
;
4256 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
4257 if (rp
->address
== offset
)
4264 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
4266 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4267 bfd
*abfd
= (bfd
*) file
;
4271 if (!dump_any_debugging
)
4274 /* If it is already loaded, do nothing. */
4275 if (section
->start
!= NULL
)
4277 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4280 /* Locate the debug section. */
4281 name
= section
->uncompressed_name
;
4282 sec
= bfd_get_section_by_name (abfd
, name
);
4285 name
= section
->compressed_name
;
4287 sec
= bfd_get_section_by_name (abfd
, name
);
4291 name
= section
->xcoff_name
;
4293 sec
= bfd_get_section_by_name (abfd
, name
);
4298 section
->name
= name
;
4299 return load_specific_debug_section (debug
, sec
, file
);
4303 free_debug_section (enum dwarf_section_display_enum debug
)
4305 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4307 free ((char *) section
->start
);
4308 section
->start
= NULL
;
4309 section
->address
= 0;
4311 free ((char*) section
->reloc_info
);
4312 section
->reloc_info
= NULL
;
4313 section
->num_relocs
= 0;
4317 close_debug_file (void * file
)
4319 bfd
* abfd
= (bfd
*) file
;
4325 open_debug_file (const char * pathname
)
4329 data
= bfd_openr (pathname
, NULL
);
4333 if (! bfd_check_format (data
, bfd_object
))
4340 dump_dwarf_section (bfd
*abfd
, asection
*section
,
4343 const char *name
= bfd_section_name (section
);
4346 bool is_mainfile
= *(bool *) arg
;
4351 if (!is_mainfile
&& !process_links
4352 && (section
->flags
& SEC_DEBUGGING
) == 0)
4355 if (startswith (name
, ".gnu.linkonce.wi."))
4356 match
= ".debug_info";
4360 for (i
= 0; i
< max
; i
++)
4361 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
4362 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
4363 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
4364 && debug_displays
[i
].enabled
!= NULL
4365 && *debug_displays
[i
].enabled
)
4367 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
4369 if (strcmp (sec
->uncompressed_name
, match
) == 0)
4370 sec
->name
= sec
->uncompressed_name
;
4371 else if (strcmp (sec
->compressed_name
, match
) == 0)
4372 sec
->name
= sec
->compressed_name
;
4374 sec
->name
= sec
->xcoff_name
;
4375 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
4378 debug_displays
[i
].display (sec
, abfd
);
4380 if (i
!= info
&& i
!= abbrev
)
4381 free_debug_section ((enum dwarf_section_display_enum
) i
);
4387 /* Dump the dwarf debugging information. */
4390 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4392 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4393 if (byte_get
== NULL
)
4395 warn (_("File %s does not contain any dwarf debug information\n"),
4396 bfd_get_filename (abfd
));
4400 switch (bfd_get_arch (abfd
))
4403 /* S12Z has a 24 bit address space. But the only known
4404 producer of dwarf_info encodes addresses into 32 bits. */
4409 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4413 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4414 bfd_get_mach (abfd
));
4416 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4419 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
4420 it. Return NULL on failure. */
4423 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4424 bfd_size_type
*entsize_ptr
)
4429 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
4430 if (stabsect
== NULL
)
4432 printf (_("No %s section present\n\n"),
4433 sanitize_string (sect_name
));
4437 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
4439 non_fatal (_("reading %s section of %s failed: %s"),
4440 sect_name
, bfd_get_filename (abfd
),
4441 bfd_errmsg (bfd_get_error ()));
4447 *size_ptr
= bfd_section_size (stabsect
);
4449 *entsize_ptr
= stabsect
->entsize
;
4454 /* Stabs entries use a 12 byte format:
4455 4 byte string table index
4457 1 byte stab other field
4458 2 byte stab desc field
4460 FIXME: This will have to change for a 64 bit object format. */
4462 #define STRDXOFF (0)
4464 #define OTHEROFF (5)
4467 #define STABSIZE (12)
4469 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4470 using string table section STRSECT_NAME (in `strtab'). */
4473 print_section_stabs (bfd
*abfd
,
4474 const char *stabsect_name
,
4475 unsigned *string_offset_ptr
)
4478 unsigned file_string_table_offset
= 0;
4479 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4480 bfd_byte
*stabp
, *stabs_end
;
4483 stabs_end
= stabp
+ stab_size
;
4485 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4486 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4488 /* Loop through all symbols and print them.
4490 We start the index at -1 because there is a dummy symbol on
4491 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4492 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
4496 unsigned char type
, other
;
4497 unsigned short desc
;
4500 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4501 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4502 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4503 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4504 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4506 printf ("\n%-6d ", i
);
4507 /* Either print the stab name, or, if unnamed, print its number
4508 again (makes consistent formatting for tools like awk). */
4509 name
= bfd_get_stab_name (type
);
4511 printf ("%-6s", sanitize_string (name
));
4512 else if (type
== N_UNDF
)
4515 printf ("%-6d", type
);
4516 printf (" %-6d %-6d ", other
, desc
);
4517 bfd_printf_vma (abfd
, value
);
4518 printf (" %-6lu", strx
);
4520 /* Symbols with type == 0 (N_UNDF) specify the length of the
4521 string table associated with this file. We use that info
4522 to know how to relocate the *next* file's string table indices. */
4525 file_string_table_offset
= next_file_string_table_offset
;
4526 next_file_string_table_offset
+= value
;
4530 bfd_size_type amt
= strx
+ file_string_table_offset
;
4532 /* Using the (possibly updated) string table offset, print the
4533 string (if any) associated with this symbol. */
4534 if (amt
< stabstr_size
)
4535 /* PR 17512: file: 079-79389-0.001:0.1.
4536 FIXME: May need to sanitize this string before displaying. */
4537 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4543 *string_offset_ptr
= next_file_string_table_offset
;
4548 const char * section_name
;
4549 const char * string_section_name
;
4550 unsigned string_offset
;
4555 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4558 stab_section_names
* sought
= (stab_section_names
*) names
;
4560 /* Check for section names for which stabsect_name is a prefix, to
4561 handle .stab.N, etc. */
4562 len
= strlen (sought
->section_name
);
4564 /* If the prefix matches, and the files section name ends with a
4565 nul or a digit, then we match. I.e., we want either an exact
4566 match or a section followed by a number. */
4567 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4568 && (section
->name
[len
] == 0
4569 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4572 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
4573 &stabstr_size
, NULL
);
4577 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
4579 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4585 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4587 stab_section_names s
;
4589 s
.section_name
= stabsect_name
;
4590 s
.string_section_name
= strsect_name
;
4591 s
.string_offset
= 0;
4593 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4599 /* Dump the any sections containing stabs debugging information. */
4602 dump_stabs (bfd
*abfd
)
4604 dump_stabs_section (abfd
, ".stab", ".stabstr");
4605 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4606 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4609 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4611 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4615 dump_bfd_header (bfd
*abfd
)
4619 printf (_("architecture: %s, "),
4620 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4621 bfd_get_mach (abfd
)));
4622 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4624 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4625 PF (HAS_RELOC
, "HAS_RELOC");
4626 PF (EXEC_P
, "EXEC_P");
4627 PF (HAS_LINENO
, "HAS_LINENO");
4628 PF (HAS_DEBUG
, "HAS_DEBUG");
4629 PF (HAS_SYMS
, "HAS_SYMS");
4630 PF (HAS_LOCALS
, "HAS_LOCALS");
4631 PF (DYNAMIC
, "DYNAMIC");
4632 PF (WP_TEXT
, "WP_TEXT");
4633 PF (D_PAGED
, "D_PAGED");
4634 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4635 printf (_("\nstart address 0x"));
4636 bfd_printf_vma (abfd
, abfd
->start_address
);
4641 #ifdef ENABLE_LIBCTF
4642 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4643 it is passed, or a pointer to newly-allocated storage, in which case
4644 dump_ctf() will free it when it no longer needs it. */
4647 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4650 const char *blanks
= arg
;
4653 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4658 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4660 make_ctfsect (const char *name
, bfd_byte
*data
,
4665 ctfsect
.cts_name
= name
;
4666 ctfsect
.cts_entsize
= 1;
4667 ctfsect
.cts_size
= size
;
4668 ctfsect
.cts_data
= data
;
4673 /* Dump CTF errors/warnings. */
4675 dump_ctf_errs (ctf_dict_t
*fp
)
4677 ctf_next_t
*it
= NULL
;
4682 /* Dump accumulated errors and warnings. */
4683 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4685 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4689 if (err
!= ECTF_NEXT_END
)
4691 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4696 /* Dump one CTF archive member. */
4699 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4702 const char *things
[] = {"Header", "Labels", "Data objects",
4703 "Function objects", "Variables", "Types", "Strings",
4708 /* Don't print out the name of the default-named archive member if it appears
4709 first in the list. The name .ctf appears everywhere, even for things that
4710 aren't really archives, so printing it out is liable to be confusing; also,
4711 the common case by far is for only one archive member to exist, and hiding
4712 it in that case seems worthwhile. */
4714 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4715 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4717 if (ctf_parent_name (ctf
) != NULL
)
4718 ctf_import (ctf
, parent
);
4720 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4722 ctf_dump_state_t
*s
= NULL
;
4725 printf ("\n %s:\n", *thing
);
4726 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4727 (void *) " ")) != NULL
)
4729 printf ("%s\n", item
);
4733 if (ctf_errno (ctf
))
4735 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4736 ctf_errmsg (ctf_errno (ctf
)));
4741 dump_ctf_errs (ctf
);
4744 /* Dump the CTF debugging information. */
4747 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4749 ctf_archive_t
*ctfa
= NULL
;
4750 bfd_byte
*ctfdata
= NULL
;
4751 bfd_size_type ctfsize
;
4755 ctf_next_t
*i
= NULL
;
4760 if (sect_name
== NULL
)
4763 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4764 bfd_fatal (bfd_get_filename (abfd
));
4766 /* Load the CTF file and dump it. Preload the parent dict, since it will
4767 need to be imported into every child in turn. */
4769 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4770 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4772 dump_ctf_errs (NULL
);
4773 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4774 bfd_fatal (bfd_get_filename (abfd
));
4777 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4779 dump_ctf_errs (NULL
);
4780 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4781 bfd_fatal (bfd_get_filename (abfd
));
4784 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4786 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4787 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4788 if (err
!= ECTF_NEXT_END
)
4790 dump_ctf_errs (NULL
);
4791 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4792 bfd_fatal (bfd_get_filename (abfd
));
4794 ctf_dict_close (parent
);
4800 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4801 const char *parent_name ATTRIBUTE_UNUSED
) {}
4806 dump_bfd_private_header (bfd
*abfd
)
4808 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4809 non_fatal (_("warning: private headers incomplete: %s"),
4810 bfd_errmsg (bfd_get_error ()));
4814 dump_target_specific (bfd
*abfd
)
4816 const struct objdump_private_desc
* const *desc
;
4817 struct objdump_private_option
*opt
;
4820 /* Find the desc. */
4821 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4822 if ((*desc
)->filter (abfd
))
4827 non_fatal (_("option -P/--private not supported by this file"));
4831 /* Clear all options. */
4832 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4833 opt
->selected
= false;
4835 /* Decode options. */
4836 b
= dump_private_options
;
4839 e
= strchr (b
, ',');
4844 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4845 if (strcmp (opt
->name
, b
) == 0)
4847 opt
->selected
= true;
4850 if (opt
->name
== NULL
)
4851 non_fatal (_("target specific dump '%s' not supported"), b
);
4862 (*desc
)->dump (abfd
);
4865 /* Display a section in hexadecimal format with associated characters.
4866 Each line prefixed by the zero padded address. */
4869 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4871 bfd_byte
*data
= NULL
;
4872 bfd_size_type datasize
;
4873 bfd_vma addr_offset
;
4874 bfd_vma start_offset
;
4875 bfd_vma stop_offset
;
4876 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4877 /* Bytes per line. */
4878 const int onaline
= 16;
4883 if (! process_section_p (section
))
4886 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4889 if ((datasize
= bfd_section_size (section
)) == 0)
4892 /* Compute the address range to display. */
4893 if (start_address
== (bfd_vma
) -1
4894 || start_address
< section
->vma
)
4897 start_offset
= start_address
- section
->vma
;
4899 if (stop_address
== (bfd_vma
) -1)
4900 stop_offset
= datasize
/ opb
;
4903 if (stop_address
< section
->vma
)
4906 stop_offset
= stop_address
- section
->vma
;
4908 if (stop_offset
> datasize
/ opb
)
4909 stop_offset
= datasize
/ opb
;
4912 if (start_offset
>= stop_offset
)
4915 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4916 if (display_file_offsets
)
4917 printf (_(" (Starting at file offset: 0x%lx)"),
4918 (unsigned long) (section
->filepos
+ start_offset
));
4921 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4923 non_fatal (_("Reading section %s failed because: %s"),
4924 section
->name
, bfd_errmsg (bfd_get_error ()));
4930 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4931 if (strlen (buf
) >= sizeof (buf
))
4935 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4937 count
= strlen (buf
) - count
;
4941 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4942 if (strlen (buf
) >= sizeof (buf
))
4946 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4948 count
= strlen (buf
) - count
;
4952 for (addr_offset
= start_offset
;
4953 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4957 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4958 count
= strlen (buf
);
4959 if ((size_t) count
>= sizeof (buf
))
4963 while (count
< width
)
4968 fputs (buf
+ count
- width
, stdout
);
4971 for (j
= addr_offset
* opb
;
4972 j
< addr_offset
* opb
+ onaline
; j
++)
4974 if (j
< stop_offset
* opb
)
4975 printf ("%02x", (unsigned) (data
[j
]));
4983 for (j
= addr_offset
* opb
;
4984 j
< addr_offset
* opb
+ onaline
; j
++)
4986 if (j
>= stop_offset
* opb
)
4989 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4996 /* Actually display the various requested regions. */
4999 dump_data (bfd
*abfd
)
5001 bfd_map_over_sections (abfd
, dump_section
, NULL
);
5004 /* Should perhaps share code and display with nm? */
5007 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
5016 max_count
= dynsymcount
;
5017 printf ("DYNAMIC SYMBOL TABLE:\n");
5022 max_count
= symcount
;
5023 printf ("SYMBOL TABLE:\n");
5027 printf (_("no symbols\n"));
5029 for (count
= 0; count
< max_count
; count
++)
5033 if (*current
== NULL
)
5034 printf (_("no information for symbol number %ld\n"), count
);
5036 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
5037 printf (_("could not determine the type of symbol number %ld\n"),
5040 else if (process_section_p ((* current
)->section
)
5041 && (dump_special_syms
5042 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
5044 const char *name
= (*current
)->name
;
5046 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
5050 /* If we want to demangle the name, we demangle it
5051 here, and temporarily clobber it while calling
5052 bfd_print_symbol. FIXME: This is a gross hack. */
5053 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
5055 (*current
)->name
= alloc
;
5056 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5057 bfd_print_symbol_all
);
5060 (*current
)->name
= name
;
5064 else if (unicode_display
!= unicode_default
5065 && name
!= NULL
&& *name
!= '\0')
5067 const char * sanitized_name
;
5069 /* If we want to sanitize the name, we do it here, and
5070 temporarily clobber it while calling bfd_print_symbol.
5071 FIXME: This is a gross hack. */
5072 sanitized_name
= sanitize_string (name
);
5073 if (sanitized_name
!= name
)
5074 (*current
)->name
= sanitized_name
;
5076 sanitized_name
= NULL
;
5077 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5078 bfd_print_symbol_all
);
5079 if (sanitized_name
!= NULL
)
5080 (*current
)->name
= name
;
5083 bfd_print_symbol (cur_bfd
, stdout
, *current
,
5084 bfd_print_symbol_all
);
5094 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
5097 char *last_filename
, *last_functionname
;
5098 unsigned int last_line
;
5099 unsigned int last_discriminator
;
5101 /* Get column headers lined up reasonably. */
5109 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
5110 width
= strlen (buf
) - 7;
5112 printf ("OFFSET %*s TYPE %*s VALUE\n", width
, "", 12, "");
5115 last_filename
= NULL
;
5116 last_functionname
= NULL
;
5118 last_discriminator
= 0;
5120 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
5123 const char *filename
, *functionname
;
5124 unsigned int linenumber
;
5125 unsigned int discriminator
;
5126 const char *sym_name
;
5127 const char *section_name
;
5128 bfd_vma addend2
= 0;
5130 if (start_address
!= (bfd_vma
) -1
5131 && q
->address
< start_address
)
5133 if (stop_address
!= (bfd_vma
) -1
5134 && q
->address
> stop_address
)
5137 if (with_line_numbers
5139 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
5140 &filename
, &functionname
,
5141 &linenumber
, &discriminator
))
5143 if (functionname
!= NULL
5144 && (last_functionname
== NULL
5145 || strcmp (functionname
, last_functionname
) != 0))
5147 printf ("%s():\n", sanitize_string (functionname
));
5148 if (last_functionname
!= NULL
)
5149 free (last_functionname
);
5150 last_functionname
= xstrdup (functionname
);
5154 && (linenumber
!= last_line
5155 || (filename
!= NULL
5156 && last_filename
!= NULL
5157 && filename_cmp (filename
, last_filename
) != 0)
5158 || (discriminator
!= last_discriminator
)))
5160 if (discriminator
> 0)
5161 printf ("%s:%u\n", filename
== NULL
? "???" :
5162 sanitize_string (filename
), linenumber
);
5164 printf ("%s:%u (discriminator %u)\n",
5165 filename
== NULL
? "???" : sanitize_string (filename
),
5166 linenumber
, discriminator
);
5167 last_line
= linenumber
;
5168 last_discriminator
= discriminator
;
5169 if (last_filename
!= NULL
)
5170 free (last_filename
);
5171 if (filename
== NULL
)
5172 last_filename
= NULL
;
5174 last_filename
= xstrdup (filename
);
5178 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
5180 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
5181 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
5186 section_name
= NULL
;
5189 bfd_printf_vma (abfd
, q
->address
);
5190 if (q
->howto
== NULL
)
5191 printf (" *unknown* ");
5192 else if (q
->howto
->name
)
5194 const char *name
= q
->howto
->name
;
5196 /* R_SPARC_OLO10 relocations contain two addends.
5197 But because 'arelent' lacks enough storage to
5198 store them both, the 64-bit ELF Sparc backend
5199 records this as two relocations. One R_SPARC_LO10
5200 and one R_SPARC_13, both pointing to the same
5201 address. This is merely so that we have some
5202 place to store both addend fields.
5204 Undo this transformation, otherwise the output
5205 will be confusing. */
5206 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
5207 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
5209 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
5211 arelent
*q2
= *(p
+ 1);
5214 && q
->address
== q2
->address
5215 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
5217 name
= "R_SPARC_OLO10";
5218 addend2
= q2
->addend
;
5222 printf (" %-16s ", name
);
5225 printf (" %-16d ", q
->howto
->type
);
5229 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
5233 if (section_name
== NULL
)
5234 section_name
= "*unknown*";
5235 printf ("[%s]", sanitize_string (section_name
));
5240 bfd_signed_vma addend
= q
->addend
;
5248 bfd_printf_vma (abfd
, addend
);
5253 bfd_printf_vma (abfd
, addend2
);
5259 if (last_filename
!= NULL
)
5260 free (last_filename
);
5261 if (last_functionname
!= NULL
)
5262 free (last_functionname
);
5266 dump_relocs_in_section (bfd
*abfd
,
5268 void *dummy ATTRIBUTE_UNUSED
)
5270 arelent
**relpp
= NULL
;
5274 if ( bfd_is_abs_section (section
)
5275 || bfd_is_und_section (section
)
5276 || bfd_is_com_section (section
)
5277 || (! process_section_p (section
))
5278 || ((section
->flags
& SEC_RELOC
) == 0))
5281 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
5283 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
5286 printf (" (none)\n\n");
5294 relpp
= (arelent
**) xmalloc (relsize
);
5295 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
5301 non_fatal (_("failed to read relocs in: %s"),
5302 sanitize_string (bfd_get_filename (abfd
)));
5303 bfd_fatal (_("error message was"));
5305 else if (relcount
== 0)
5306 printf (" (none)\n\n");
5310 dump_reloc_set (abfd
, section
, relpp
, relcount
);
5317 dump_relocs (bfd
*abfd
)
5319 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
5323 dump_dynamic_relocs (bfd
*abfd
)
5329 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5331 bfd_fatal (bfd_get_filename (abfd
));
5333 printf ("DYNAMIC RELOCATION RECORDS");
5336 printf (" (none)\n\n");
5339 relpp
= (arelent
**) xmalloc (relsize
);
5340 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
5343 bfd_fatal (bfd_get_filename (abfd
));
5344 else if (relcount
== 0)
5345 printf (" (none)\n\n");
5349 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
5356 /* Creates a table of paths, to search for source files. */
5359 add_include_path (const char *path
)
5363 include_path_count
++;
5364 include_paths
= (const char **)
5365 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
5366 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5367 if (path
[1] == ':' && path
[2] == 0)
5368 path
= concat (path
, ".", (const char *) 0);
5370 include_paths
[include_path_count
- 1] = path
;
5374 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
5378 if ((section
->flags
& SEC_DEBUGGING
) == 0)
5380 bool *has_reloc_p
= (bool *) arg
;
5381 section
->vma
+= adjust_section_vma
;
5383 section
->lma
+= adjust_section_vma
;
5387 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5390 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5395 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5396 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5400 might_need_separate_debug_info (bool is_mainfile
)
5402 /* We do not follow links from debug info files. */
5406 /* Since do_follow_links might be enabled by default, only treat it as an
5407 indication that separate files should be loaded if setting it was a
5408 deliberate user action. */
5409 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
5412 if (process_links
|| dump_symtab
|| dump_debugging
5413 || dump_dwarf_section_info
|| with_source_code
)
5419 /* Dump selected contents of ABFD. */
5422 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5424 const struct elf_backend_data
* bed
;
5426 if (bfd_big_endian (abfd
))
5427 byte_get
= byte_get_big_endian
;
5428 else if (bfd_little_endian (abfd
))
5429 byte_get
= byte_get_little_endian
;
5433 /* Load any separate debug information files. */
5434 if (byte_get
!= NULL
&& might_need_separate_debug_info (is_mainfile
))
5436 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5438 /* If asked to do so, recursively dump the separate files. */
5439 if (do_follow_links
)
5443 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5444 dump_bfd (i
->handle
, false);
5448 /* Adjust user-specified start and stop limits for targets that use
5449 signed addresses. */
5450 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5451 && (bed
= get_elf_backend_data (abfd
)) != NULL
5452 && bed
->sign_extend_vma
)
5454 start_address
= sign_extend_address (abfd
, start_address
,
5456 stop_address
= sign_extend_address (abfd
, stop_address
,
5460 /* If we are adjusting section VMA's, change them all now. Changing
5461 the BFD information is a hack. However, we must do it, or
5462 bfd_find_nearest_line will not do the right thing. */
5463 if (adjust_section_vma
!= 0)
5465 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5466 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5469 if (is_mainfile
|| process_links
)
5471 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5472 printf (_("\n%s: file format %s\n"),
5473 sanitize_string (bfd_get_filename (abfd
)),
5476 print_arelt_descr (stdout
, abfd
, true, false);
5477 if (dump_file_header
)
5478 dump_bfd_header (abfd
);
5479 if (dump_private_headers
)
5480 dump_bfd_private_header (abfd
);
5481 if (dump_private_options
!= NULL
)
5482 dump_target_specific (abfd
);
5483 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5491 || dump_dwarf_section_info
)
5493 syms
= slurp_symtab (abfd
);
5495 /* If following links, load any symbol tables from the linked files as well. */
5496 if (do_follow_links
&& is_mainfile
)
5500 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5502 asymbol
** extra_syms
;
5503 long old_symcount
= symcount
;
5505 extra_syms
= slurp_symtab (i
->handle
);
5509 if (old_symcount
== 0)
5515 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5516 * sizeof (asymbol
*)));
5517 memcpy (syms
+ old_symcount
,
5519 (symcount
+ 1) * sizeof (asymbol
*));
5523 symcount
+= old_symcount
;
5528 if (is_mainfile
|| process_links
)
5530 if (dump_section_headers
)
5531 dump_headers (abfd
);
5533 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5534 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5535 dynsyms
= slurp_dynamic_symtab (abfd
);
5539 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5540 dynsymcount
, dynsyms
,
5547 dump_symbols (abfd
, false);
5548 if (dump_dynamic_symtab
)
5549 dump_symbols (abfd
, true);
5551 if (dump_dwarf_section_info
)
5552 dump_dwarf (abfd
, is_mainfile
);
5553 if (is_mainfile
|| process_links
)
5555 if (dump_ctf_section_info
)
5556 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5557 if (dump_stab_section_info
)
5559 if (dump_reloc_info
&& ! disassemble
)
5561 if (dump_dynamic_reloc_info
&& ! disassemble
)
5562 dump_dynamic_relocs (abfd
);
5563 if (dump_section_contents
)
5566 disassemble_data (abfd
);
5573 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5574 if (dhandle
!= NULL
)
5576 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5578 dump_debugging_tags
!= 0))
5580 non_fatal (_("%s: printing debugging information failed"),
5581 bfd_get_filename (abfd
));
5587 /* PR 6483: If there was no STABS debug info in the file, try
5589 else if (! dump_dwarf_section_info
)
5591 dwarf_select_sections_all ();
5592 dump_dwarf (abfd
, is_mainfile
);
5619 free_debug_memory ();
5623 display_object_bfd (bfd
*abfd
)
5627 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5629 dump_bfd (abfd
, true);
5633 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5635 nonfatal (bfd_get_filename (abfd
));
5636 list_matching_formats (matching
);
5640 if (bfd_get_error () != bfd_error_file_not_recognized
)
5642 nonfatal (bfd_get_filename (abfd
));
5646 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5648 dump_bfd (abfd
, true);
5652 nonfatal (bfd_get_filename (abfd
));
5654 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5655 list_matching_formats (matching
);
5659 display_any_bfd (bfd
*file
, int level
)
5661 /* Decompress sections unless dumping the section contents. */
5662 if (!dump_section_contents
)
5663 file
->flags
|= BFD_DECOMPRESS
;
5665 /* If the file is an archive, process all of its elements. */
5666 if (bfd_check_format (file
, bfd_archive
))
5669 bfd
*last_arfile
= NULL
;
5672 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5673 else if (level
> 100)
5675 /* Prevent corrupted files from spinning us into an
5676 infinite loop. 100 is an arbitrary heuristic. */
5677 fatal (_("Archive nesting is too deep"));
5681 printf (_("In nested archive %s:\n"),
5682 sanitize_string (bfd_get_filename (file
)));
5686 bfd_set_error (bfd_error_no_error
);
5688 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5691 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5692 nonfatal (bfd_get_filename (file
));
5696 display_any_bfd (arfile
, level
+ 1);
5698 if (last_arfile
!= NULL
)
5700 bfd_close (last_arfile
);
5701 /* PR 17512: file: ac585d01. */
5702 if (arfile
== last_arfile
)
5708 last_arfile
= arfile
;
5711 if (last_arfile
!= NULL
)
5712 bfd_close (last_arfile
);
5715 display_object_bfd (file
);
5719 display_file (char *filename
, char *target
, bool last_file
)
5723 if (get_file_size (filename
) < 1)
5729 file
= bfd_openr (filename
, target
);
5732 nonfatal (filename
);
5736 display_any_bfd (file
, 0);
5738 /* This is an optimization to improve the speed of objdump, especially when
5739 dumping a file with lots of associated debug informatiom. Calling
5740 bfd_close on such a file can take a non-trivial amount of time as there
5741 are lots of lists to walk and buffers to free. This is only really
5742 necessary however if we are about to load another file and we need the
5743 memory back. Otherwise, if we are about to exit, then we can save (a lot
5744 of) time by only doing a quick close, and allowing the OS to reclaim the
5749 bfd_close_all_done (file
);
5753 main (int argc
, char **argv
)
5756 char *target
= default_target
;
5757 bool seenflag
= false;
5759 #ifdef HAVE_LC_MESSAGES
5760 setlocale (LC_MESSAGES
, "");
5762 setlocale (LC_CTYPE
, "");
5764 bindtextdomain (PACKAGE
, LOCALEDIR
);
5765 textdomain (PACKAGE
);
5767 program_name
= *argv
;
5768 xmalloc_set_program_name (program_name
);
5769 bfd_set_error_program_name (program_name
);
5771 START_PROGRESS (program_name
, 0);
5773 expandargv (&argc
, &argv
);
5775 if (bfd_init () != BFD_INIT_MAGIC
)
5776 fatal (_("fatal error: libbfd ABI mismatch"));
5777 set_default_bfd_target ();
5779 while ((c
= getopt_long (argc
, argv
,
5780 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5781 long_options
, (int *) 0))
5787 break; /* We've been given a long option. */
5794 if (disassembler_options
)
5795 /* Ignore potential memory leak for now. */
5796 options
= concat (disassembler_options
, ",",
5797 optarg
, (const char *) NULL
);
5800 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5807 display_file_offsets
= true;
5810 with_line_numbers
= true;
5819 enum demangling_styles style
;
5821 style
= cplus_demangle_name_to_style (optarg
);
5822 if (style
== unknown_demangling
)
5823 fatal (_("unknown demangling style `%s'"),
5826 cplus_demangle_set_style (style
);
5829 case OPTION_RECURSE_LIMIT
:
5830 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5832 case OPTION_NO_RECURSE_LIMIT
:
5833 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5836 do_wide
= wide_output
= true;
5838 case OPTION_ADJUST_VMA
:
5839 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5841 case OPTION_START_ADDRESS
:
5842 start_address
= parse_vma (optarg
, "--start-address");
5843 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5844 fatal (_("error: the start address should be before the end address"));
5846 case OPTION_STOP_ADDRESS
:
5847 stop_address
= parse_vma (optarg
, "--stop-address");
5848 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5849 fatal (_("error: the stop address should be after the start address"));
5853 prefix_length
= strlen (prefix
);
5854 /* Remove an unnecessary trailing '/' */
5855 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5858 case OPTION_PREFIX_STRIP
:
5859 prefix_strip
= atoi (optarg
);
5860 if (prefix_strip
< 0)
5861 fatal (_("error: prefix strip must be non-negative"));
5863 case OPTION_INSN_WIDTH
:
5864 insn_width
= strtoul (optarg
, NULL
, 0);
5865 if (insn_width
<= 0)
5866 fatal (_("error: instruction width must be positive"));
5868 case OPTION_INLINES
:
5869 unwind_inlines
= true;
5871 case OPTION_VISUALIZE_JUMPS
:
5872 visualize_jumps
= true;
5873 color_output
= false;
5874 extended_color_output
= false;
5877 if (streq (optarg
, "color"))
5878 color_output
= true;
5879 else if (streq (optarg
, "extended-color"))
5881 color_output
= true;
5882 extended_color_output
= true;
5884 else if (streq (optarg
, "off"))
5885 visualize_jumps
= false;
5887 nonfatal (_("unrecognized argument to --visualize-option"));
5890 case OPTION_DISASSEMBLER_COLOR
:
5891 if (streq (optarg
, "off"))
5892 disassembler_color
= off
;
5893 else if (streq (optarg
, "color"))
5894 disassembler_color
= on
;
5895 else if (streq (optarg
, "extended-color"))
5896 disassembler_color
= extended
;
5898 nonfatal (_("unrecognized argument to --disassembler-color"));
5901 if (strcmp (optarg
, "B") == 0)
5902 endian
= BFD_ENDIAN_BIG
;
5903 else if (strcmp (optarg
, "L") == 0)
5904 endian
= BFD_ENDIAN_LITTLE
;
5907 nonfatal (_("unrecognized -E option"));
5912 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5913 endian
= BFD_ENDIAN_BIG
;
5914 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5915 endian
= BFD_ENDIAN_LITTLE
;
5918 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5925 dump_file_header
= true;
5929 formats_info
= true;
5933 add_include_path (optarg
);
5936 dump_private_headers
= true;
5940 dump_private_options
= optarg
;
5944 dump_private_headers
= true;
5946 dump_reloc_info
= true;
5947 dump_file_header
= true;
5948 dump_ar_hdrs
= true;
5949 dump_section_headers
= true;
5957 dump_dynamic_symtab
= true;
5963 disasm_sym
= optarg
;
5966 disassemble_zeroes
= true;
5970 disassemble_all
= true;
5975 with_source_code
= true;
5978 case OPTION_SOURCE_COMMENT
:
5980 with_source_code
= true;
5983 source_comment
= xstrdup (sanitize_string (optarg
));
5985 source_comment
= xstrdup ("# ");
5993 dump_debugging_tags
= 1;
5998 process_links
= true;
5999 do_follow_links
= true;
6005 if (dwarf_select_sections_by_letters (optarg
))
6006 dump_dwarf_section_info
= true;
6010 dump_dwarf_section_info
= true;
6011 dwarf_select_sections_all ();
6018 if (dwarf_select_sections_by_names (optarg
))
6019 dump_dwarf_section_info
= true;
6023 dwarf_select_sections_all ();
6024 dump_dwarf_section_info
= true;
6027 case OPTION_DWARF_DEPTH
:
6030 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6033 case OPTION_DWARF_START
:
6036 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6037 suppress_bfd_header
= 1;
6040 case OPTION_DWARF_CHECK
:
6043 #ifdef ENABLE_LIBCTF
6045 dump_ctf_section_info
= true;
6047 dump_ctf_section_name
= xstrdup (optarg
);
6050 case OPTION_CTF_PARENT
:
6051 dump_ctf_parent_name
= xstrdup (optarg
);
6055 dump_stab_section_info
= true;
6059 dump_section_contents
= true;
6063 dump_reloc_info
= true;
6067 dump_dynamic_reloc_info
= true;
6071 dump_ar_hdrs
= true;
6075 dump_section_headers
= true;
6080 show_version
= true;
6085 if (streq (optarg
, "default") || streq (optarg
, "d"))
6086 unicode_display
= unicode_default
;
6087 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6088 unicode_display
= unicode_locale
;
6089 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6090 unicode_display
= unicode_escape
;
6091 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6092 unicode_display
= unicode_invalid
;
6093 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6094 unicode_display
= unicode_hex
;
6095 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6096 unicode_display
= unicode_highlight
;
6098 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
6103 /* No need to set seenflag or to break - usage() does not return. */
6109 if (disassembler_color
== on_if_terminal_output
)
6110 disassembler_color
= isatty (1) ? on
: off
;
6113 print_version ("objdump");
6118 dump_any_debugging
= (dump_debugging
6119 || dump_dwarf_section_info
6121 || with_source_code
);
6124 exit_status
= display_info ();
6128 display_file ("a.out", target
, true);
6130 for (; optind
< argc
;)
6132 display_file (argv
[optind
], target
, optind
== argc
- 1);
6138 free (dump_ctf_section_name
);
6139 free (dump_ctf_parent_name
);
6140 free ((void *) source_comment
);
6142 END_PROGRESS (program_name
);