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 /* Internal headers for the ELF .stab-dump code - sorry. */
76 #define BYTES_IN_WORD 32
77 #include "aout/aout64.h"
80 static int exit_status
= 0;
82 static char *default_target
= NULL
; /* Default at runtime. */
84 /* The following variables are set based on arguments passed on the
86 static int show_version
= 0; /* Show the version number. */
87 static int dump_section_contents
; /* -s */
88 static int dump_section_headers
; /* -h */
89 static bool dump_file_header
; /* -f */
90 static int dump_symtab
; /* -t */
91 static int dump_dynamic_symtab
; /* -T */
92 static int dump_reloc_info
; /* -r */
93 static int dump_dynamic_reloc_info
; /* -R */
94 static int dump_ar_hdrs
; /* -a */
95 static int dump_private_headers
; /* -p */
96 static char *dump_private_options
; /* -P */
97 static int no_addresses
; /* --no-addresses */
98 static int prefix_addresses
; /* --prefix-addresses */
99 static int with_line_numbers
; /* -l */
100 static bool with_source_code
; /* -S */
101 static int show_raw_insn
; /* --show-raw-insn */
102 static int dump_dwarf_section_info
; /* --dwarf */
103 static int dump_stab_section_info
; /* --stabs */
104 static int dump_ctf_section_info
; /* --ctf */
105 static char *dump_ctf_section_name
;
106 static char *dump_ctf_parent_name
; /* --ctf-parent */
107 static int do_demangle
; /* -C, --demangle */
108 static bool disassemble
; /* -d */
109 static bool disassemble_all
; /* -D */
110 static int disassemble_zeroes
; /* --disassemble-zeroes */
111 static bool formats_info
; /* -i */
112 static int wide_output
; /* -w */
113 static int insn_width
; /* --insn-width */
114 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
115 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
116 static int dump_debugging
; /* --debugging */
117 static int dump_debugging_tags
; /* --debugging-tags */
118 static int suppress_bfd_header
;
119 static int dump_special_syms
= 0; /* --special-syms */
120 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
121 static int file_start_context
= 0; /* --file-start-context */
122 static bool display_file_offsets
; /* -F */
123 static const char *prefix
; /* --prefix */
124 static int prefix_strip
; /* --prefix-strip */
125 static size_t prefix_length
;
126 static bool unwind_inlines
; /* --inlines. */
127 static const char * disasm_sym
; /* Disassembly start symbol. */
128 static const char * source_comment
; /* --source_comment. */
129 static bool visualize_jumps
= false; /* --visualize-jumps. */
130 static bool color_output
= false; /* --visualize-jumps=color. */
131 static bool extended_color_output
= false; /* --visualize-jumps=extended-color. */
132 static int process_links
= false; /* --process-links. */
133 static bool disassembler_color
= false; /* --disassembler-color=color. */
134 static bool disassembler_extended_color
= false; /* --disassembler-color=extended-color. */
136 static int dump_any_debugging
;
137 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
139 /* This is reset to false each time we enter the disassembler, and set true
140 when the disassembler emits something in the dis_style_comment_start
141 style. Once this is true, all further output on that line is done in
142 the comment style. This only has an effect when disassembler coloring
144 static bool disassembler_in_comment
= false;
146 /* A structure to record the sections mentioned in -j switches. */
149 const char *name
; /* The name of the section. */
150 bool seen
; /* A flag to indicate that the section has been found in one or more input files. */
151 struct only
*next
; /* Pointer to the next structure in the list. */
153 /* Pointer to an array of 'only' structures.
154 This pointer is NULL if the -j switch has not been used. */
155 static struct only
* only_list
= NULL
;
157 /* Variables for handling include file path table. */
158 static const char **include_paths
;
159 static int include_path_count
;
161 /* Extra info to pass to the section disassembler and address printing
163 struct objdump_disasm_info
167 disassembler_ftype disassemble_fn
;
172 /* Architecture to disassemble for, or default if NULL. */
173 static char *machine
= NULL
;
175 /* Target specific options to the disassembler. */
176 static char *disassembler_options
= NULL
;
178 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
179 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
181 /* The symbol table. */
182 static asymbol
**syms
;
184 /* Number of symbols in `syms'. */
185 static long symcount
= 0;
187 /* The sorted symbol table. */
188 static asymbol
**sorted_syms
;
190 /* Number of symbols in `sorted_syms'. */
191 static long sorted_symcount
= 0;
193 /* The dynamic symbol table. */
194 static asymbol
**dynsyms
;
196 /* The synthetic symbol table. */
197 static asymbol
*synthsyms
;
198 static long synthcount
= 0;
200 /* Number of symbols in `dynsyms'. */
201 static long dynsymcount
= 0;
203 static bfd_byte
*stabs
;
204 static bfd_size_type stab_size
;
206 static bfd_byte
*strtab
;
207 static bfd_size_type stabstr_size
;
209 /* Handlers for -P/--private. */
210 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
212 OBJDUMP_PRIVATE_VECTORS
216 /* The list of detected jumps inside a function. */
217 static struct jump_info
*detected_jumps
= NULL
;
219 typedef enum unicode_display_type
227 } unicode_display_type
;
229 static unicode_display_type unicode_display
= unicode_default
;
231 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
233 usage (FILE *stream
, int status
)
235 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
236 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
237 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
238 fprintf (stream
, _("\
239 -a, --archive-headers Display archive header information\n"));
240 fprintf (stream
, _("\
241 -f, --file-headers Display the contents of the overall file header\n"));
242 fprintf (stream
, _("\
243 -p, --private-headers Display object format specific file header contents\n"));
244 fprintf (stream
, _("\
245 -P, --private=OPT,OPT... Display object format specific contents\n"));
246 fprintf (stream
, _("\
247 -h, --[section-]headers Display the contents of the section headers\n"));
248 fprintf (stream
, _("\
249 -x, --all-headers Display the contents of all headers\n"));
250 fprintf (stream
, _("\
251 -d, --disassemble Display assembler contents of executable sections\n"));
252 fprintf (stream
, _("\
253 -D, --disassemble-all Display assembler contents of all sections\n"));
254 fprintf (stream
, _("\
255 --disassemble=<sym> Display assembler contents from <sym>\n"));
256 fprintf (stream
, _("\
257 -S, --source Intermix source code with disassembly\n"));
258 fprintf (stream
, _("\
259 --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
260 fprintf (stream
, _("\
261 -s, --full-contents Display the full contents of all sections requested\n"));
262 fprintf (stream
, _("\
263 -g, --debugging Display debug information in object file\n"));
264 fprintf (stream
, _("\
265 -e, --debugging-tags Display debug information using ctags style\n"));
266 fprintf (stream
, _("\
267 -G, --stabs Display (in raw form) any STABS info in the file\n"));
268 fprintf (stream
, _("\
269 -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
270 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
271 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
272 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
274 Display the contents of DWARF debug sections\n"));
275 fprintf (stream
, _("\
276 -Wk,--dwarf=links Display the contents of sections that link to\n\
277 separate debuginfo files\n"));
278 #if DEFAULT_FOR_FOLLOW_LINKS
279 fprintf (stream
, _("\
280 -WK,--dwarf=follow-links\n\
281 Follow links to separate debug info files (default)\n"));
282 fprintf (stream
, _("\
283 -WN,--dwarf=no-follow-links\n\
284 Do not follow links to separate debug info files\n"));
286 fprintf (stream
, _("\
287 -WK,--dwarf=follow-links\n\
288 Follow links to separate debug info files\n"));
289 fprintf (stream
, _("\
290 -WN,--dwarf=no-follow-links\n\
291 Do not follow links to separate debug info files\n\
294 #if HAVE_LIBDEBUGINFOD
295 fprintf (stream
, _("\
296 -WD --dwarf=use-debuginfod\n\
297 When following links, also query debuginfod servers (default)\n"));
298 fprintf (stream
, _("\
299 -WE --dwarf=do-not-use-debuginfod\n\
300 When following links, do not query debuginfod servers\n"));
302 fprintf (stream
, _("\
303 -L, --process-links Display the contents of non-debug sections in\n\
304 separate debuginfo files. (Implies -WK)\n"));
306 fprintf (stream
, _("\
307 --ctf[=SECTION] Display CTF info from SECTION, (default `.ctf')\n"));
309 fprintf (stream
, _("\
310 -t, --syms Display the contents of the symbol table(s)\n"));
311 fprintf (stream
, _("\
312 -T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
313 fprintf (stream
, _("\
314 -r, --reloc Display the relocation entries in the file\n"));
315 fprintf (stream
, _("\
316 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
317 fprintf (stream
, _("\
318 @<file> Read options from <file>\n"));
319 fprintf (stream
, _("\
320 -v, --version Display this program's version number\n"));
321 fprintf (stream
, _("\
322 -i, --info List object formats and architectures supported\n"));
323 fprintf (stream
, _("\
324 -H, --help Display this information\n"));
328 const struct objdump_private_desc
* const *desc
;
330 fprintf (stream
, _("\n The following switches are optional:\n"));
331 fprintf (stream
, _("\
332 -b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
333 fprintf (stream
, _("\
334 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
335 fprintf (stream
, _("\
336 -j, --section=NAME Only display information for section NAME\n"));
337 fprintf (stream
, _("\
338 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
339 fprintf (stream
, _("\
340 -EB --endian=big Assume big endian format when disassembling\n"));
341 fprintf (stream
, _("\
342 -EL --endian=little Assume little endian format when disassembling\n"));
343 fprintf (stream
, _("\
344 --file-start-context Include context from start of file (with -S)\n"));
345 fprintf (stream
, _("\
346 -I, --include=DIR Add DIR to search list for source files\n"));
347 fprintf (stream
, _("\
348 -l, --line-numbers Include line numbers and filenames in output\n"));
349 fprintf (stream
, _("\
350 -F, --file-offsets Include file offsets when displaying information\n"));
351 fprintf (stream
, _("\
352 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n"));
353 display_demangler_styles (stream
, _("\
355 fprintf (stream
, _("\
356 --recurse-limit Enable a limit on recursion whilst demangling\n\
358 fprintf (stream
, _("\
359 --no-recurse-limit Disable a limit on recursion whilst demangling\n"));
360 fprintf (stream
, _("\
361 -w, --wide Format output for more than 80 columns\n"));
362 fprintf (stream
, _("\
363 -U[d|l|i|x|e|h] Controls the display of UTF-8 unicode characters\n\
364 --unicode=[default|locale|invalid|hex|escape|highlight]\n"));
365 fprintf (stream
, _("\
366 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
367 fprintf (stream
, _("\
368 --start-address=ADDR Only process data whose address is >= ADDR\n"));
369 fprintf (stream
, _("\
370 --stop-address=ADDR Only process data whose address is < ADDR\n"));
371 fprintf (stream
, _("\
372 --no-addresses Do not print address alongside disassembly\n"));
373 fprintf (stream
, _("\
374 --prefix-addresses Print complete address alongside disassembly\n"));
375 fprintf (stream
, _("\
376 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
377 fprintf (stream
, _("\
378 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
379 fprintf (stream
, _("\
380 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
381 fprintf (stream
, _("\
382 --special-syms Include special symbols in symbol dumps\n"));
383 fprintf (stream
, _("\
384 --inlines Print all inlines for source line (with -l)\n"));
385 fprintf (stream
, _("\
386 --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
387 fprintf (stream
, _("\
388 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
389 fprintf (stream
, _("\
390 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
391 fprintf (stream
, _("\
392 --dwarf-start=N Display DIEs starting at offset N\n"));
393 fprintf (stream
, _("\
394 --dwarf-check Make additional dwarf consistency checks.\n"));
396 fprintf (stream
, _("\
397 --ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
399 fprintf (stream
, _("\
400 --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
401 fprintf (stream
, _("\
402 --visualize-jumps=color Use colors in the ASCII art\n"));
403 fprintf (stream
, _("\
404 --visualize-jumps=extended-color\n\
405 Use extended 8-bit color codes\n"));
406 fprintf (stream
, _("\
407 --visualize-jumps=off Disable jump visualization\n\n"));
408 fprintf (stream
, _("\
409 --disassembler-color=off Disable disassembler color output.\n\n"));
410 fprintf (stream
, _("\
411 --disassembler-color=color Use basic colors in disassembler output.\n\n"));
413 list_supported_targets (program_name
, stream
);
414 list_supported_architectures (program_name
, stream
);
416 disassembler_usage (stream
);
418 if (objdump_private_vectors
[0] != NULL
)
421 _("\nOptions supported for -P/--private switch:\n"));
422 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
423 (*desc
)->help (stream
);
426 if (REPORT_BUGS_TO
[0] && status
== 0)
427 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
431 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
435 OPTION_START_ADDRESS
,
445 OPTION_RECURSE_LIMIT
,
446 OPTION_NO_RECURSE_LIMIT
,
448 OPTION_SOURCE_COMMENT
,
453 OPTION_VISUALIZE_JUMPS
,
454 OPTION_DISASSEMBLER_COLOR
457 static struct option long_options
[]=
459 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
460 {"all-headers", no_argument
, NULL
, 'x'},
461 {"architecture", required_argument
, NULL
, 'm'},
462 {"archive-headers", no_argument
, NULL
, 'a'},
464 {"ctf", optional_argument
, NULL
, OPTION_CTF
},
465 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
467 {"debugging", no_argument
, NULL
, 'g'},
468 {"debugging-tags", no_argument
, NULL
, 'e'},
469 {"demangle", optional_argument
, NULL
, 'C'},
470 {"disassemble", optional_argument
, NULL
, 'd'},
471 {"disassemble-all", no_argument
, NULL
, 'D'},
472 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
473 {"disassembler-options", required_argument
, NULL
, 'M'},
474 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
475 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
476 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
477 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
478 {"dynamic-reloc", no_argument
, NULL
, 'R'},
479 {"dynamic-syms", no_argument
, NULL
, 'T'},
480 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
481 {"file-headers", no_argument
, NULL
, 'f'},
482 {"file-offsets", no_argument
, NULL
, 'F'},
483 {"file-start-context", no_argument
, &file_start_context
, 1},
484 {"full-contents", no_argument
, NULL
, 's'},
485 {"headers", no_argument
, NULL
, 'h'},
486 {"help", no_argument
, NULL
, 'H'},
487 {"include", required_argument
, NULL
, 'I'},
488 {"info", no_argument
, NULL
, 'i'},
489 {"inlines", no_argument
, 0, OPTION_INLINES
},
490 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
491 {"line-numbers", no_argument
, NULL
, 'l'},
492 {"no-addresses", no_argument
, &no_addresses
, 1},
493 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
494 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
495 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
496 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
497 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
498 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
499 {"private", required_argument
, NULL
, 'P'},
500 {"private-headers", no_argument
, NULL
, 'p'},
501 {"process-links", no_argument
, &process_links
, true},
502 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
503 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
504 {"reloc", no_argument
, NULL
, 'r'},
505 {"section", required_argument
, NULL
, 'j'},
506 {"section-headers", no_argument
, NULL
, 'h'},
507 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
508 {"source", no_argument
, NULL
, 'S'},
509 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
510 {"special-syms", no_argument
, &dump_special_syms
, 1},
511 {"stabs", no_argument
, NULL
, 'G'},
512 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
513 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
514 {"syms", no_argument
, NULL
, 't'},
515 {"target", required_argument
, NULL
, 'b'},
516 {"unicode", required_argument
, NULL
, 'U'},
517 {"version", no_argument
, NULL
, 'V'},
518 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
519 {"wide", no_argument
, NULL
, 'w'},
520 {"disassembler-color", required_argument
, NULL
, OPTION_DISASSEMBLER_COLOR
},
521 {NULL
, no_argument
, NULL
, 0}
525 nonfatal (const char *msg
)
531 /* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
532 The conversion format is controlled by the unicode_display variable.
533 Returns the number of characters added to OUT.
534 Returns the number of bytes consumed from IN in CONSUMED.
535 Always consumes at least one byte and displays at least one character. */
538 display_utf8 (const unsigned char * in
, char * out
, unsigned int * consumed
)
540 char * orig_out
= out
;
541 unsigned int nchars
= 0;
544 if (unicode_display
== unicode_default
)
550 if ((in
[1] & 0xc0) != 0x80)
553 if ((in
[0] & 0x20) == 0)
559 if ((in
[2] & 0xc0) != 0x80)
562 if ((in
[0] & 0x10) == 0)
568 if ((in
[3] & 0xc0) != 0x80)
574 switch (unicode_display
)
577 /* Copy the bytes into the output buffer as is. */
578 memcpy (out
, in
, nchars
);
582 case unicode_invalid
:
584 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '<' : '{');
585 out
+= sprintf (out
, "0x");
586 for (j
= 0; j
< nchars
; j
++)
587 out
+= sprintf (out
, "%02x", in
[j
]);
588 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '>' : '}');
591 case unicode_highlight
:
593 out
+= sprintf (out
, "\x1B[31;47m"); /* Red. */
599 out
+= sprintf (out
, "\\u%02x%02x",
600 ((in
[0] & 0x1c) >> 2),
601 ((in
[0] & 0x03) << 6) | (in
[1] & 0x3f));
605 out
+= sprintf (out
, "\\u%02x%02x",
606 ((in
[0] & 0x0f) << 4) | ((in
[1] & 0x3c) >> 2),
607 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3f)));
611 out
+= sprintf (out
, "\\u%02x%02x%02x",
612 ((in
[0] & 0x07) << 6) | ((in
[1] & 0x3c) >> 2),
613 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3c) >> 2),
614 ((in
[2] & 0x03) << 6) | ((in
[3] & 0x3f)));
621 if (unicode_display
== unicode_highlight
&& isatty (1))
622 out
+= sprintf (out
, "\033[0m"); /* Default colour. */
631 return out
- orig_out
;
634 /* Not a valid UTF-8 sequence. */
640 /* Returns a version of IN with any control characters
641 replaced by escape sequences. Uses a static buffer
644 If unicode display is enabled, then also handles the
645 conversion of unicode characters. */
648 sanitize_string (const char * in
)
650 static char * buffer
= NULL
;
651 static size_t buffer_len
= 0;
652 const char * original
= in
;
659 /* See if any conversion is necessary. In the majority
660 of cases it will not be needed. */
663 unsigned char c
= *in
++;
671 if (unicode_display
!= unicode_default
&& c
>= 0xc0)
676 /* Copy the input, translating as needed. */
678 if (buffer_len
< (strlen (in
) * 9))
680 free ((void *) buffer
);
681 buffer_len
= strlen (in
) * 9;
682 buffer
= xmalloc (buffer_len
+ 1);
688 unsigned char c
= *in
++;
698 else if (unicode_display
!= unicode_default
&& c
>= 0xc0)
700 unsigned int num_consumed
;
702 out
+= display_utf8 ((const unsigned char *)(in
- 1), out
, & num_consumed
);
703 in
+= num_consumed
- 1;
715 /* Returns TRUE if the specified section should be dumped. */
718 process_section_p (asection
* section
)
722 if (only_list
== NULL
)
725 for (only
= only_list
; only
; only
= only
->next
)
726 if (strcmp (only
->name
, section
->name
) == 0)
735 /* Add an entry to the 'only' list. */
738 add_only (char * name
)
742 /* First check to make sure that we do not
743 already have an entry for this name. */
744 for (only
= only_list
; only
; only
= only
->next
)
745 if (strcmp (only
->name
, name
) == 0)
748 only
= xmalloc (sizeof * only
);
751 only
->next
= only_list
;
755 /* Release the memory used by the 'only' list.
756 PR 11225: Issue a warning message for unseen sections.
757 Only do this if none of the sections were seen. This is mainly to support
758 tools like the GAS testsuite where an object file is dumped with a list of
759 generic section names known to be present in a range of different file
763 free_only_list (void)
765 bool at_least_one_seen
= false;
769 if (only_list
== NULL
)
772 for (only
= only_list
; only
; only
= only
->next
)
775 at_least_one_seen
= true;
779 for (only
= only_list
; only
; only
= next
)
781 if (! at_least_one_seen
)
783 non_fatal (_("section '%s' mentioned in a -j option, "
784 "but not found in any input file"),
795 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
798 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
799 int longest_section_name
= *((int *) data
);
801 /* Ignore linker created section. See elfNN_ia64_object_p in
803 if (section
->flags
& SEC_LINKER_CREATED
)
806 /* PR 10413: Skip sections that we are ignoring. */
807 if (! process_section_p (section
))
810 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
811 sanitize_string (bfd_section_name (section
)),
812 (unsigned long) bfd_section_size (section
) / opb
);
813 bfd_printf_vma (abfd
, bfd_section_vma (section
));
815 bfd_printf_vma (abfd
, section
->lma
);
816 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
817 bfd_section_alignment (section
));
823 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
825 PF (SEC_HAS_CONTENTS
, "CONTENTS");
826 PF (SEC_ALLOC
, "ALLOC");
827 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
828 PF (SEC_LOAD
, "LOAD");
829 PF (SEC_RELOC
, "RELOC");
830 PF (SEC_READONLY
, "READONLY");
831 PF (SEC_CODE
, "CODE");
832 PF (SEC_DATA
, "DATA");
834 PF (SEC_DEBUGGING
, "DEBUGGING");
835 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
836 PF (SEC_EXCLUDE
, "EXCLUDE");
837 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
838 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
840 PF (SEC_TIC54X_BLOCK
, "BLOCK");
841 PF (SEC_TIC54X_CLINK
, "CLINK");
843 PF (SEC_SMALL_DATA
, "SMALL_DATA");
844 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
846 PF (SEC_COFF_SHARED
, "SHARED");
847 PF (SEC_COFF_NOREAD
, "NOREAD");
849 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
851 PF (SEC_ELF_OCTETS
, "OCTETS");
852 PF (SEC_ELF_PURECODE
, "PURECODE");
854 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
855 PF (SEC_GROUP
, "GROUP");
856 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
858 PF (SEC_MEP_VLIW
, "VLIW");
861 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
864 struct coff_comdat_info
*comdat
;
866 switch (section
->flags
& SEC_LINK_DUPLICATES
)
870 case SEC_LINK_DUPLICATES_DISCARD
:
871 ls
= "LINK_ONCE_DISCARD";
873 case SEC_LINK_DUPLICATES_ONE_ONLY
:
874 ls
= "LINK_ONCE_ONE_ONLY";
876 case SEC_LINK_DUPLICATES_SAME_SIZE
:
877 ls
= "LINK_ONCE_SAME_SIZE";
879 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
880 ls
= "LINK_ONCE_SAME_CONTENTS";
883 printf ("%s%s", comma
, ls
);
885 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
887 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
896 /* Called on each SECTION in ABFD, update the int variable pointed to by
897 DATA which contains the string length of the longest section name. */
900 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
901 asection
*section
, void *data
)
903 int *longest_so_far
= (int *) data
;
907 /* Ignore linker created section. */
908 if (section
->flags
& SEC_LINKER_CREATED
)
911 /* Skip sections that we are ignoring. */
912 if (! process_section_p (section
))
915 name
= bfd_section_name (section
);
916 len
= (int) strlen (name
);
917 if (len
> *longest_so_far
)
918 *longest_so_far
= len
;
922 dump_headers (bfd
*abfd
)
924 /* The default width of 13 is just an arbitrary choice. */
925 int max_section_name_length
= 13;
931 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
932 if (bfd_get_arch_size (abfd
) == 32)
938 printf (_("Sections:\n"));
941 bfd_map_over_sections (abfd
, find_longest_section_name
,
942 &max_section_name_length
);
944 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
945 max_section_name_length
, "Name",
946 bfd_vma_width
, "VMA",
947 bfd_vma_width
, "LMA");
950 printf (_(" Flags"));
953 bfd_map_over_sections (abfd
, dump_section_header
,
954 &max_section_name_length
);
958 slurp_symtab (bfd
*abfd
)
963 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
969 storage
= bfd_get_symtab_upper_bound (abfd
);
972 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
973 bfd_fatal (_("error message was"));
978 off_t filesize
= bfd_get_file_size (abfd
);
982 && filesize
< storage
983 /* The MMO file format supports its own special compression
984 technique, so its sections can be larger than the file size. */
985 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
987 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
988 _("error: symbol table size (%#lx) "
989 "is larger than filesize (%#lx)"),
990 storage
, (long) filesize
);
996 sy
= (asymbol
**) xmalloc (storage
);
999 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1001 bfd_fatal (bfd_get_filename (abfd
));
1005 /* Read in the dynamic symbols. */
1008 slurp_dynamic_symtab (bfd
*abfd
)
1010 asymbol
**sy
= NULL
;
1013 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1016 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
1018 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
1024 bfd_fatal (bfd_get_filename (abfd
));
1028 sy
= (asymbol
**) xmalloc (storage
);
1030 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
1031 if (dynsymcount
< 0)
1032 bfd_fatal (bfd_get_filename (abfd
));
1036 /* Some symbol names are significant and should be kept in the
1037 table of sorted symbol names, even if they are marked as
1038 debugging/section symbols. */
1041 is_significant_symbol_name (const char * name
)
1043 return startswith (name
, ".plt") || startswith (name
, ".got");
1046 /* Filter out (in place) symbols that are useless for disassembly.
1047 COUNT is the number of elements in SYMBOLS.
1048 Return the number of useful symbols. */
1051 remove_useless_symbols (asymbol
**symbols
, long count
)
1053 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
1055 while (--count
>= 0)
1057 asymbol
*sym
= *in_ptr
++;
1059 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
1061 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
1062 && ! is_significant_symbol_name (sym
->name
))
1064 if (bfd_is_und_section (sym
->section
)
1065 || bfd_is_com_section (sym
->section
))
1070 return out_ptr
- symbols
;
1073 static const asection
*compare_section
;
1075 /* Sort symbols into value order. */
1078 compare_symbols (const void *ap
, const void *bp
)
1080 const asymbol
*a
= * (const asymbol
**) ap
;
1081 const asymbol
*b
= * (const asymbol
**) bp
;
1086 bool as
, af
, bs
, bf
;
1090 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
1092 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
1095 /* Prefer symbols from the section currently being disassembled.
1096 Don't sort symbols from other sections by section, since there
1097 isn't much reason to prefer one section over another otherwise.
1098 See sym_ok comment for why we compare by section name. */
1099 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
1100 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
1106 an
= bfd_asymbol_name (a
);
1107 bn
= bfd_asymbol_name (b
);
1111 /* The symbols gnu_compiled and gcc2_compiled convey no real
1112 information, so put them after other symbols with the same value. */
1113 af
= (strstr (an
, "gnu_compiled") != NULL
1114 || strstr (an
, "gcc2_compiled") != NULL
);
1115 bf
= (strstr (bn
, "gnu_compiled") != NULL
1116 || strstr (bn
, "gcc2_compiled") != NULL
);
1123 /* We use a heuristic for the file name, to try to sort it after
1124 more useful symbols. It may not work on non Unix systems, but it
1125 doesn't really matter; the only difference is precisely which
1126 symbol names get printed. */
1128 #define file_symbol(s, sn, snl) \
1129 (((s)->flags & BSF_FILE) != 0 \
1131 && (sn)[(snl) - 2] == '.' \
1132 && ((sn)[(snl) - 1] == 'o' \
1133 || (sn)[(snl) - 1] == 'a')))
1135 af
= file_symbol (a
, an
, anl
);
1136 bf
= file_symbol (b
, bn
, bnl
);
1143 /* Sort function and object symbols before global symbols before
1144 local symbols before section symbols before debugging symbols. */
1149 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
1151 if ((aflags
& BSF_DEBUGGING
) != 0)
1156 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
1158 if ((aflags
& BSF_SECTION_SYM
) != 0)
1163 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
1165 if ((aflags
& BSF_FUNCTION
) != 0)
1170 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
1172 if ((aflags
& BSF_OBJECT
) != 0)
1177 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
1179 if ((aflags
& BSF_LOCAL
) != 0)
1184 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
1186 if ((aflags
& BSF_GLOBAL
) != 0)
1192 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
1193 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1198 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1199 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1201 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1202 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1204 return asz
> bsz
? -1 : 1;
1207 /* Symbols that start with '.' might be section names, so sort them
1208 after symbols that don't start with '.'. */
1209 if (an
[0] == '.' && bn
[0] != '.')
1211 if (an
[0] != '.' && bn
[0] == '.')
1214 /* Finally, if we can't distinguish them in any other way, try to
1215 get consistent results by sorting the symbols by name. */
1216 return strcmp (an
, bn
);
1219 /* Sort relocs into address order. */
1222 compare_relocs (const void *ap
, const void *bp
)
1224 const arelent
*a
= * (const arelent
**) ap
;
1225 const arelent
*b
= * (const arelent
**) bp
;
1227 if (a
->address
> b
->address
)
1229 else if (a
->address
< b
->address
)
1232 /* So that associated relocations tied to the same address show up
1233 in the correct order, we don't do any further sorting. */
1242 /* Print an address (VMA) to the output stream in INFO.
1243 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1246 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1251 struct objdump_disasm_info
*aux
;
1253 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1254 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1259 for (p
= buf
; *p
== '0'; ++p
)
1264 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "%s", p
);
1267 /* Print the name of a symbol. */
1270 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1274 const char *name
, *version_string
= NULL
;
1275 bool hidden
= false;
1278 name
= bfd_asymbol_name (sym
);
1279 if (do_demangle
&& name
[0] != '\0')
1281 /* Demangle the name. */
1282 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1287 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1288 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1291 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1294 name
= sanitize_string (name
);
1298 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s", name
);
1299 if (version_string
&& *version_string
!= '\0')
1300 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
,
1301 hidden
? "@%s" : "@@%s",
1306 printf ("%s", name
);
1307 if (version_string
&& *version_string
!= '\0')
1308 printf (hidden
? "@%s" : "@@%s", version_string
);
1316 sym_ok (bool want_section
,
1317 bfd
*abfd ATTRIBUTE_UNUSED
,
1320 struct disassemble_info
*inf
)
1324 /* NB: An object file can have different sections with the same
1325 section name. Compare compare section pointers if they have
1327 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1328 && sorted_syms
[place
]->section
!= sec
)
1331 /* Note - we cannot just compare section pointers because they could
1332 be different, but the same... Ie the symbol that we are trying to
1333 find could have come from a separate debug info file. Under such
1334 circumstances the symbol will be associated with a section in the
1335 debug info file, whilst the section we want is in a normal file.
1336 So the section pointers will be different, but the section names
1337 will be the same. */
1338 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1339 bfd_section_name (sec
)) != 0)
1343 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1346 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1347 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1348 require the symbol to be in the section. Returns NULL if there is no
1349 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1350 of the symbol in sorted_syms. */
1353 find_symbol_for_address (bfd_vma vma
,
1354 struct disassemble_info
*inf
,
1357 /* @@ Would it speed things up to cache the last two symbols returned,
1358 and maybe their address ranges? For many processors, only one memory
1359 operand can be present at a time, so the 2-entry cache wouldn't be
1360 constantly churned by code doing heavy memory accesses. */
1362 /* Indices in `sorted_syms'. */
1364 long max_count
= sorted_symcount
;
1366 struct objdump_disasm_info
*aux
;
1373 if (sorted_symcount
< 1)
1376 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1379 opb
= inf
->octets_per_byte
;
1381 /* Perform a binary search looking for the closest symbol to the
1382 required value. We are searching the range (min, max_count]. */
1383 while (min
+ 1 < max_count
)
1387 thisplace
= (max_count
+ min
) / 2;
1388 sym
= sorted_syms
[thisplace
];
1390 if (bfd_asymbol_value (sym
) > vma
)
1391 max_count
= thisplace
;
1392 else if (bfd_asymbol_value (sym
) < vma
)
1401 /* The symbol we want is now in min, the low end of the range we
1402 were searching. If there are several symbols with the same
1403 value, we want the first one. */
1405 while (thisplace
> 0
1406 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1407 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1410 /* Prefer a symbol in the current section if we have multple symbols
1411 with the same value, as can occur with overlays or zero size
1414 while (min
< max_count
1415 && (bfd_asymbol_value (sorted_syms
[min
])
1416 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1418 if (sym_ok (true, abfd
, min
, sec
, inf
))
1425 return sorted_syms
[thisplace
];
1430 /* If the file is relocatable, and the symbol could be from this
1431 section, prefer a symbol from this section over symbols from
1432 others, even if the other symbol's value might be closer.
1434 Note that this may be wrong for some symbol references if the
1435 sections have overlapping memory ranges, but in that case there's
1436 no way to tell what's desired without looking at the relocation
1439 Also give the target a chance to reject symbols. */
1440 want_section
= (aux
->require_sec
1441 || ((abfd
->flags
& HAS_RELOC
) != 0
1442 && vma
>= bfd_section_vma (sec
)
1443 && vma
< (bfd_section_vma (sec
)
1444 + bfd_section_size (sec
) / opb
)));
1446 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1449 long newplace
= sorted_symcount
;
1451 for (i
= min
- 1; i
>= 0; i
--)
1453 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1455 if (newplace
== sorted_symcount
)
1458 if (bfd_asymbol_value (sorted_syms
[i
])
1459 != bfd_asymbol_value (sorted_syms
[newplace
]))
1462 /* Remember this symbol and keep searching until we reach
1463 an earlier address. */
1468 if (newplace
!= sorted_symcount
)
1469 thisplace
= newplace
;
1472 /* We didn't find a good symbol with a smaller value.
1473 Look for one with a larger value. */
1474 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1476 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1484 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1485 /* There is no suitable symbol. */
1489 /* If we have not found an exact match for the specified address
1490 and we have dynamic relocations available, then we can produce
1491 a better result by matching a relocation to the address and
1492 using the symbol associated with that relocation. */
1493 rel_count
= inf
->dynrelcount
;
1495 && sorted_syms
[thisplace
]->value
!= vma
1497 && inf
->dynrelbuf
!= NULL
1498 && inf
->dynrelbuf
[0]->address
<= vma
1499 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1500 /* If we have matched a synthetic symbol, then stick with that. */
1501 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1504 arelent
** rel_high
;
1506 rel_low
= inf
->dynrelbuf
;
1507 rel_high
= rel_low
+ rel_count
- 1;
1508 while (rel_low
<= rel_high
)
1510 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1511 arelent
* rel
= *rel_mid
;
1513 if (rel
->address
== vma
)
1515 /* Absolute relocations do not provide a more helpful
1516 symbolic address. Find a non-absolute relocation
1517 with the same address. */
1518 arelent
**rel_vma
= rel_mid
;
1520 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1524 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1528 if (rel
->sym_ptr_ptr
!= NULL
1529 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1532 * place
= thisplace
;
1533 return * rel
->sym_ptr_ptr
;
1539 if (vma
< rel
->address
)
1541 else if (vma
>= rel_mid
[1]->address
)
1542 rel_low
= rel_mid
+ 1;
1551 return sorted_syms
[thisplace
];
1554 /* Print an address and the offset to the nearest symbol. */
1557 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1558 bfd_vma vma
, struct disassemble_info
*inf
,
1563 objdump_print_value (vma
, inf
, skip_zeroes
);
1564 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, " ");
1571 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
,"<");
1572 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_symbol
, "%s",
1573 sanitize_string (bfd_section_name (sec
)));
1574 secaddr
= bfd_section_vma (sec
);
1577 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,
1579 objdump_print_value (secaddr
- vma
, inf
, true);
1581 else if (vma
> secaddr
)
1583 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1584 objdump_print_value (vma
- secaddr
, inf
, true);
1586 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1590 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, "<");
1592 objdump_print_symname (abfd
, inf
, sym
);
1594 if (bfd_asymbol_value (sym
) == vma
)
1596 /* Undefined symbols in an executables and dynamic objects do not have
1597 a value associated with them, so it does not make sense to display
1598 an offset relative to them. Normally we would not be provided with
1599 this kind of symbol, but the target backend might choose to do so,
1600 and the code in find_symbol_for_address might return an as yet
1601 unresolved symbol associated with a dynamic reloc. */
1602 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1603 && bfd_is_und_section (sym
->section
))
1605 else if (bfd_asymbol_value (sym
) > vma
)
1607 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
,"-0x");
1608 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1610 else if (vma
> bfd_asymbol_value (sym
))
1612 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_immediate
, "+0x");
1613 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1616 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_text
, ">");
1619 if (display_file_offsets
)
1620 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1621 _(" (File Offset: 0x%lx)"),
1622 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1625 /* Print an address (VMA), symbolically if possible.
1626 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1629 objdump_print_addr (bfd_vma vma
,
1630 struct disassemble_info
*inf
,
1633 struct objdump_disasm_info
*aux
;
1634 asymbol
*sym
= NULL
;
1635 bool skip_find
= false;
1637 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1639 if (sorted_symcount
< 1)
1643 (*inf
->fprintf_styled_func
) (inf
->stream
, dis_style_address
, "0x");
1644 objdump_print_value (vma
, inf
, skip_zeroes
);
1647 if (display_file_offsets
)
1648 inf
->fprintf_styled_func (inf
->stream
, dis_style_text
,
1649 _(" (File Offset: 0x%lx)"),
1650 (long int) (inf
->section
->filepos
1651 + (vma
- inf
->section
->vma
)));
1655 if (aux
->reloc
!= NULL
1656 && aux
->reloc
->sym_ptr_ptr
!= NULL
1657 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1659 sym
= * aux
->reloc
->sym_ptr_ptr
;
1661 /* Adjust the vma to the reloc. */
1662 vma
+= bfd_asymbol_value (sym
);
1664 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1669 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1671 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1675 /* Print VMA to INFO. This function is passed to the disassembler
1679 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1681 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1684 /* Determine if the given address has a symbol associated with it. */
1687 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1691 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1692 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1698 /* Hold the last function name and the last line number we displayed
1699 in a disassembly. */
1701 static char *prev_functionname
;
1702 static unsigned int prev_line
;
1703 static unsigned int prev_discriminator
;
1705 /* We keep a list of all files that we have seen when doing a
1706 disassembly with source, so that we know how much of the file to
1707 display. This can be important for inlined functions. */
1709 struct print_file_list
1711 struct print_file_list
*next
;
1712 const char *filename
;
1713 const char *modname
;
1716 const char **linemap
;
1719 unsigned max_printed
;
1723 static struct print_file_list
*print_files
;
1725 /* The number of preceding context lines to show when we start
1726 displaying a file for the first time. */
1728 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1730 /* Read a complete file into memory. */
1733 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1736 int ps
= getpagesize ();
1740 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1744 if (fstat (fd
, fst
) < 0)
1749 *size
= fst
->st_size
;
1751 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1752 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1753 if (map
!= (char *) -1L)
1759 map
= (const char *) malloc (*size
);
1760 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1762 free ((void *) map
);
1769 #define line_map_decrease 5
1771 /* Precompute array of lines for a mapped file. */
1773 static const char **
1774 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1776 const char *p
, *lstart
, *end
;
1777 int chars_per_line
= 45; /* First iteration will use 40. */
1778 unsigned int lineno
;
1779 const char **linemap
= NULL
;
1780 unsigned long line_map_size
= 0;
1786 for (p
= map
; p
< end
; p
++)
1790 if (p
+ 1 < end
&& p
[1] == '\r')
1793 else if (*p
== '\r')
1795 if (p
+ 1 < end
&& p
[1] == '\n')
1801 /* End of line found. */
1803 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1805 unsigned long newsize
;
1807 chars_per_line
-= line_map_decrease
;
1808 if (chars_per_line
<= 1)
1810 line_map_size
= size
/ chars_per_line
+ 1;
1811 if (line_map_size
< lineno
+ 1)
1812 line_map_size
= lineno
+ 1;
1813 newsize
= line_map_size
* sizeof (char *);
1814 linemap
= (const char **) xrealloc (linemap
, newsize
);
1817 linemap
[lineno
++] = lstart
;
1825 /* Tries to open MODNAME, and if successful adds a node to print_files
1826 linked list and returns that node. Returns NULL on failure. */
1828 static struct print_file_list
*
1829 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1831 struct print_file_list
*p
;
1833 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1835 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1842 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1845 p
->filename
= origname
;
1846 p
->modname
= modname
;
1847 p
->next
= print_files
;
1853 /* If the source file, as described in the symtab, is not found
1854 try to locate it in one of the paths specified with -I
1855 If found, add location to print_files linked list. */
1857 static struct print_file_list
*
1858 update_source_path (const char *filename
, bfd
*abfd
)
1860 struct print_file_list
*p
;
1865 p
= try_print_file_open (filename
, filename
, &fst
);
1868 if (include_path_count
== 0)
1871 /* Get the name of the file. */
1872 fname
= lbasename (filename
);
1874 /* If file exists under a new path, we need to add it to the list
1875 so that show_line knows about it. */
1876 for (i
= 0; i
< include_path_count
; i
++)
1878 char *modname
= concat (include_paths
[i
], "/", fname
,
1881 p
= try_print_file_open (filename
, modname
, &fst
);
1891 long mtime
= bfd_get_mtime (abfd
);
1893 if (fst
.st_mtime
> mtime
)
1894 warn (_("source file %s is more recent than object file\n"),
1901 /* Print a source file line. */
1904 print_line (struct print_file_list
*p
, unsigned int linenum
)
1910 if (linenum
>= p
->maxline
)
1912 l
= p
->linemap
[linenum
];
1913 if (source_comment
!= NULL
&& strlen (l
) > 0)
1914 printf ("%s", source_comment
);
1915 len
= strcspn (l
, "\n\r");
1916 /* Test fwrite return value to quiet glibc warning. */
1917 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1921 /* Print a range of source code lines. */
1924 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1928 while (start
<= end
)
1930 print_line (p
, start
);
1935 /* Show the line number, or the source line, in a disassembly
1939 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1941 const char *filename
;
1942 const char *functionname
;
1943 unsigned int linenumber
;
1944 unsigned int discriminator
;
1948 if (! with_line_numbers
&& ! with_source_code
)
1951 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1952 &filename
, &functionname
,
1953 &linenumber
, &discriminator
))
1956 if (filename
!= NULL
&& *filename
== '\0')
1958 if (functionname
!= NULL
&& *functionname
== '\0')
1959 functionname
= NULL
;
1962 && IS_ABSOLUTE_PATH (filename
)
1966 const char *fname
= filename
;
1968 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
1971 memcpy (path
, prefix
, prefix_length
);
1972 path_up
= path
+ prefix_length
;
1974 /* Build relocated filename, stripping off leading directories
1975 from the initial filename if requested. */
1976 if (prefix_strip
> 0)
1981 /* Skip selected directory levels. */
1982 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1983 if (IS_DIR_SEPARATOR (*s
))
1990 /* Update complete filename. */
1991 strcpy (path_up
, fname
);
1999 if (with_line_numbers
)
2001 if (functionname
!= NULL
2002 && (prev_functionname
== NULL
2003 || strcmp (functionname
, prev_functionname
) != 0))
2005 char *demangle_alloc
= NULL
;
2006 if (do_demangle
&& functionname
[0] != '\0')
2008 /* Demangle the name. */
2009 demangle_alloc
= bfd_demangle (abfd
, functionname
,
2013 /* Demangling adds trailing parens, so don't print those. */
2014 if (demangle_alloc
!= NULL
)
2015 printf ("%s:\n", sanitize_string (demangle_alloc
));
2017 printf ("%s():\n", sanitize_string (functionname
));
2020 free (demangle_alloc
);
2023 && (linenumber
!= prev_line
2024 || discriminator
!= prev_discriminator
))
2026 if (discriminator
> 0)
2027 printf ("%s:%u (discriminator %u)\n",
2028 filename
== NULL
? "???" : sanitize_string (filename
),
2029 linenumber
, discriminator
);
2031 printf ("%s:%u\n", filename
== NULL
2032 ? "???" : sanitize_string (filename
),
2037 const char *filename2
;
2038 const char *functionname2
;
2041 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2044 printf ("inlined by %s:%u",
2045 sanitize_string (filename2
), line2
);
2046 printf (" (%s)\n", sanitize_string (functionname2
));
2051 if (with_source_code
2055 struct print_file_list
**pp
, *p
;
2058 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2059 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2066 filename
= xstrdup (filename
);
2067 p
= update_source_path (filename
, abfd
);
2070 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2072 if (file_start_context
&& p
->first
)
2076 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2077 if (l
>= linenumber
)
2079 if (p
->max_printed
>= l
)
2081 if (p
->max_printed
< linenumber
)
2082 l
= p
->max_printed
+ 1;
2087 dump_lines (p
, l
, linenumber
);
2088 if (p
->max_printed
< linenumber
)
2089 p
->max_printed
= linenumber
;
2090 p
->last_line
= linenumber
;
2095 if (functionname
!= NULL
2096 && (prev_functionname
== NULL
2097 || strcmp (functionname
, prev_functionname
) != 0))
2099 if (prev_functionname
!= NULL
)
2100 free (prev_functionname
);
2101 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2102 strcpy (prev_functionname
, functionname
);
2105 if (linenumber
> 0 && linenumber
!= prev_line
)
2106 prev_line
= linenumber
;
2108 if (discriminator
!= prev_discriminator
)
2109 prev_discriminator
= discriminator
;
2115 /* Pseudo FILE object for strings. */
2123 /* sprintf to a "stream". */
2125 static int ATTRIBUTE_PRINTF_2
2126 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2133 size_t space
= f
->alloc
- f
->pos
;
2135 va_start (args
, format
);
2136 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2142 f
->alloc
= (f
->alloc
+ n
) * 2;
2143 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2150 /* Return an integer greater than, or equal to zero, representing the color
2151 for STYLE, or -1 if no color should be used. */
2154 objdump_color_for_disassembler_style (enum disassembler_style style
)
2158 if (style
== dis_style_comment_start
)
2159 disassembler_in_comment
= true;
2161 if (disassembler_color
)
2163 if (disassembler_in_comment
)
2168 case dis_style_symbol
: color
= 32; break;
2169 case dis_style_assembler_directive
:
2170 case dis_style_mnemonic
: color
= 33; break;
2171 case dis_style_register
: color
= 34; break;
2172 case dis_style_address
:
2173 case dis_style_address_offset
:
2174 case dis_style_immediate
: color
= 35; break;
2176 case dis_style_text
: color
= -1; break;
2179 else if (disassembler_extended_color
)
2181 if (disassembler_in_comment
)
2186 case dis_style_symbol
: color
= 40; break;
2187 case dis_style_assembler_directive
:
2188 case dis_style_mnemonic
: color
= 142; break;
2189 case dis_style_register
: color
= 27; break;
2190 case dis_style_address
:
2191 case dis_style_address_offset
:
2192 case dis_style_immediate
: color
= 134; break;
2194 case dis_style_text
: color
= -1; break;
2201 /* Like objdump_sprintf, but add in escape sequences to highlight the
2202 content according to STYLE. */
2204 static int ATTRIBUTE_PRINTF_3
2205 objdump_styled_sprintf (SFILE
*f
, enum disassembler_style style
,
2206 const char *format
, ...)
2210 int color
= objdump_color_for_disassembler_style (style
);
2216 size_t space
= f
->alloc
- f
->pos
;
2218 if (disassembler_color
)
2219 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[%dm", color
);
2221 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[38;5;%dm", color
);
2225 f
->alloc
= (f
->alloc
+ n
) * 2;
2226 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2233 size_t space
= f
->alloc
- f
->pos
;
2235 va_start (args
, format
);
2236 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2242 f
->alloc
= (f
->alloc
+ n
) * 2;
2243 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2251 size_t space
= f
->alloc
- f
->pos
;
2253 n
= snprintf (f
->buffer
+ f
->pos
, space
, "\033[0m");
2258 f
->alloc
= (f
->alloc
+ n
) * 2;
2259 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2267 /* We discard the styling information here. This function is only used
2268 when objdump is printing auxiliary information, the symbol headers, and
2269 disassembly address, or the bytes of the disassembled instruction. We
2270 don't (currently) apply styling to any of this stuff, so, for now, just
2271 print the content with no additional style added. */
2273 static int ATTRIBUTE_PRINTF_3
2274 fprintf_styled (FILE *f
, enum disassembler_style style ATTRIBUTE_UNUSED
,
2275 const char *fmt
, ...)
2281 res
= vfprintf (f
, fmt
, ap
);
2287 /* Code for generating (colored) diagrams of control flow start and end
2290 /* Structure used to store the properties of a jump. */
2294 /* The next jump, or NULL if this is the last object. */
2295 struct jump_info
*next
;
2296 /* The previous jump, or NULL if this is the first object. */
2297 struct jump_info
*prev
;
2298 /* The start addresses of the jump. */
2301 /* The list of start addresses. */
2303 /* The number of elements. */
2305 /* The maximum number of elements that fit into the array. */
2308 /* The end address of the jump. */
2310 /* The drawing level of the jump. */
2314 /* Construct a jump object for a jump from start
2315 to end with the corresponding level. */
2317 static struct jump_info
*
2318 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2320 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2322 result
->next
= NULL
;
2323 result
->prev
= NULL
;
2324 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2325 result
->start
.addresses
[0] = start
;
2326 result
->start
.count
= 1;
2327 result
->start
.max_count
= 2;
2329 result
->level
= level
;
2334 /* Free a jump object and return the next object
2335 or NULL if this was the last one. */
2337 static struct jump_info
*
2338 jump_info_free (struct jump_info
*ji
)
2340 struct jump_info
*result
= NULL
;
2345 if (ji
->start
.addresses
)
2346 free (ji
->start
.addresses
);
2353 /* Get the smallest value of all start and end addresses. */
2356 jump_info_min_address (const struct jump_info
*ji
)
2358 bfd_vma min_address
= ji
->end
;
2361 for (i
= ji
->start
.count
; i
-- > 0;)
2362 if (ji
->start
.addresses
[i
] < min_address
)
2363 min_address
= ji
->start
.addresses
[i
];
2367 /* Get the largest value of all start and end addresses. */
2370 jump_info_max_address (const struct jump_info
*ji
)
2372 bfd_vma max_address
= ji
->end
;
2375 for (i
= ji
->start
.count
; i
-- > 0;)
2376 if (ji
->start
.addresses
[i
] > max_address
)
2377 max_address
= ji
->start
.addresses
[i
];
2381 /* Get the target address of a jump. */
2384 jump_info_end_address (const struct jump_info
*ji
)
2389 /* Test if an address is one of the start addresses of a jump. */
2392 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2394 bool result
= false;
2397 for (i
= ji
->start
.count
; i
-- > 0;)
2398 if (address
== ji
->start
.addresses
[i
])
2407 /* Test if an address is the target address of a jump. */
2410 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2412 return (address
== ji
->end
);
2415 /* Get the difference between the smallest and largest address of a jump. */
2418 jump_info_size (const struct jump_info
*ji
)
2420 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2423 /* Unlink a jump object from a list. */
2426 jump_info_unlink (struct jump_info
*node
,
2427 struct jump_info
**base
)
2430 node
->next
->prev
= node
->prev
;
2432 node
->prev
->next
= node
->next
;
2439 /* Insert unlinked jump info node into a list. */
2442 jump_info_insert (struct jump_info
*node
,
2443 struct jump_info
*target
,
2444 struct jump_info
**base
)
2446 node
->next
= target
;
2447 node
->prev
= target
->prev
;
2448 target
->prev
= node
;
2450 node
->prev
->next
= node
;
2455 /* Add unlinked node to the front of a list. */
2458 jump_info_add_front (struct jump_info
*node
,
2459 struct jump_info
**base
)
2463 node
->next
->prev
= node
;
2468 /* Move linked node to target position. */
2471 jump_info_move_linked (struct jump_info
*node
,
2472 struct jump_info
*target
,
2473 struct jump_info
**base
)
2476 jump_info_unlink (node
, base
);
2477 /* Insert node at target position. */
2478 jump_info_insert (node
, target
, base
);
2481 /* Test if two jumps intersect. */
2484 jump_info_intersect (const struct jump_info
*a
,
2485 const struct jump_info
*b
)
2487 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2488 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2491 /* Merge two compatible jump info objects. */
2494 jump_info_merge (struct jump_info
**base
)
2496 struct jump_info
*a
;
2498 for (a
= *base
; a
; a
= a
->next
)
2500 struct jump_info
*b
;
2502 for (b
= a
->next
; b
; b
= b
->next
)
2504 /* Merge both jumps into one. */
2505 if (a
->end
== b
->end
)
2507 /* Reallocate addresses. */
2508 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2511 if (needed_size
> a
->start
.max_count
)
2513 a
->start
.max_count
+= b
->start
.max_count
;
2514 a
->start
.addresses
=
2515 xrealloc (a
->start
.addresses
,
2516 a
->start
.max_count
* sizeof (bfd_vma
*));
2519 /* Append start addresses. */
2520 for (i
= 0; i
< b
->start
.count
; ++i
)
2521 a
->start
.addresses
[a
->start
.count
++] =
2522 b
->start
.addresses
[i
];
2524 /* Remove and delete jump. */
2525 struct jump_info
*tmp
= b
->prev
;
2526 jump_info_unlink (b
, base
);
2534 /* Sort jumps by their size and starting point using a stable
2535 minsort. This could be improved if sorting performance is
2536 an issue, for example by using mergesort. */
2539 jump_info_sort (struct jump_info
**base
)
2541 struct jump_info
*current_element
= *base
;
2543 while (current_element
)
2545 struct jump_info
*best_match
= current_element
;
2546 struct jump_info
*runner
= current_element
->next
;
2547 bfd_vma best_size
= jump_info_size (best_match
);
2551 bfd_vma runner_size
= jump_info_size (runner
);
2553 if ((runner_size
< best_size
)
2554 || ((runner_size
== best_size
)
2555 && (jump_info_min_address (runner
)
2556 < jump_info_min_address (best_match
))))
2558 best_match
= runner
;
2559 best_size
= runner_size
;
2562 runner
= runner
->next
;
2565 if (best_match
== current_element
)
2566 current_element
= current_element
->next
;
2568 jump_info_move_linked (best_match
, current_element
, base
);
2572 /* Visualize all jumps at a given address. */
2575 jump_info_visualize_address (bfd_vma address
,
2578 uint8_t *color_buffer
)
2580 struct jump_info
*ji
= detected_jumps
;
2581 size_t len
= (max_level
+ 1) * 3;
2583 /* Clear line buffer. */
2584 memset (line_buffer
, ' ', len
);
2585 memset (color_buffer
, 0, len
);
2587 /* Iterate over jumps and add their ASCII art. */
2590 /* Discard jumps that are never needed again. */
2591 if (jump_info_max_address (ji
) < address
)
2593 struct jump_info
*tmp
= ji
;
2596 jump_info_unlink (tmp
, &detected_jumps
);
2597 jump_info_free (tmp
);
2601 /* This jump intersects with the current address. */
2602 if (jump_info_min_address (ji
) <= address
)
2604 /* Hash target address to get an even
2605 distribution between all values. */
2606 bfd_vma hash_address
= jump_info_end_address (ji
);
2607 uint8_t color
= iterative_hash_object (hash_address
, 0);
2608 /* Fetch line offset. */
2609 int offset
= (max_level
- ji
->level
) * 3;
2611 /* Draw start line. */
2612 if (jump_info_is_start_address (ji
, address
))
2614 size_t i
= offset
+ 1;
2616 for (; i
< len
- 1; ++i
)
2617 if (line_buffer
[i
] == ' ')
2619 line_buffer
[i
] = '-';
2620 color_buffer
[i
] = color
;
2623 if (line_buffer
[i
] == ' ')
2625 line_buffer
[i
] = '-';
2626 color_buffer
[i
] = color
;
2628 else if (line_buffer
[i
] == '>')
2630 line_buffer
[i
] = 'X';
2631 color_buffer
[i
] = color
;
2634 if (line_buffer
[offset
] == ' ')
2636 if (address
<= ji
->end
)
2637 line_buffer
[offset
] =
2638 (jump_info_min_address (ji
) == address
) ? '/': '+';
2640 line_buffer
[offset
] =
2641 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2642 color_buffer
[offset
] = color
;
2645 /* Draw jump target. */
2646 else if (jump_info_is_end_address (ji
, address
))
2648 size_t i
= offset
+ 1;
2650 for (; i
< len
- 1; ++i
)
2651 if (line_buffer
[i
] == ' ')
2653 line_buffer
[i
] = '-';
2654 color_buffer
[i
] = color
;
2657 if (line_buffer
[i
] == ' ')
2659 line_buffer
[i
] = '>';
2660 color_buffer
[i
] = color
;
2662 else if (line_buffer
[i
] == '-')
2664 line_buffer
[i
] = 'X';
2665 color_buffer
[i
] = color
;
2668 if (line_buffer
[offset
] == ' ')
2670 if (jump_info_min_address (ji
) < address
)
2671 line_buffer
[offset
] =
2672 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2674 line_buffer
[offset
] = '/';
2675 color_buffer
[offset
] = color
;
2678 /* Draw intermediate line segment. */
2679 else if (line_buffer
[offset
] == ' ')
2681 line_buffer
[offset
] = '|';
2682 color_buffer
[offset
] = color
;
2690 /* Clone of disassemble_bytes to detect jumps inside a function. */
2691 /* FIXME: is this correct? Can we strip it down even further? */
2693 static struct jump_info
*
2694 disassemble_jumps (struct disassemble_info
* inf
,
2695 disassembler_ftype disassemble_fn
,
2696 bfd_vma start_offset
,
2697 bfd_vma stop_offset
,
2700 arelent
** relppend
)
2702 struct objdump_disasm_info
*aux
;
2703 struct jump_info
*jumps
= NULL
;
2705 bfd_vma addr_offset
;
2706 unsigned int opb
= inf
->octets_per_byte
;
2710 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2711 section
= inf
->section
;
2714 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2717 inf
->insn_info_valid
= 0;
2718 disassemble_set_printf (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
2719 (fprintf_styled_ftype
) objdump_styled_sprintf
);
2721 addr_offset
= start_offset
;
2722 while (addr_offset
< stop_offset
)
2724 int previous_octets
;
2726 /* Remember the length of the previous instruction. */
2727 previous_octets
= octets
;
2731 inf
->bytes_per_line
= 0;
2732 inf
->bytes_per_chunk
= 0;
2733 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2734 | (wide_output
? WIDE_OUTPUT
: 0));
2736 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2738 if (inf
->disassembler_needs_relocs
2739 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2740 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2741 && *relppp
< relppend
)
2743 bfd_signed_vma distance_to_rel
;
2745 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2747 /* Check to see if the current reloc is associated with
2748 the instruction that we are about to disassemble. */
2749 if (distance_to_rel
== 0
2750 /* FIXME: This is wrong. We are trying to catch
2751 relocs that are addressed part way through the
2752 current instruction, as might happen with a packed
2753 VLIW instruction. Unfortunately we do not know the
2754 length of the current instruction since we have not
2755 disassembled it yet. Instead we take a guess based
2756 upon the length of the previous instruction. The
2757 proper solution is to have a new target-specific
2758 disassembler function which just returns the length
2759 of an instruction at a given address without trying
2760 to display its disassembly. */
2761 || (distance_to_rel
> 0
2762 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2764 inf
->flags
|= INSN_HAS_RELOC
;
2768 if (! disassemble_all
2769 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2770 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2771 /* Set a stop_vma so that the disassembler will not read
2772 beyond the next symbol. We assume that symbols appear on
2773 the boundaries between instructions. We only do this when
2774 disassembling code of course, and when -D is in effect. */
2775 inf
->stop_vma
= section
->vma
+ stop_offset
;
2777 inf
->stop_offset
= stop_offset
;
2779 /* Extract jump information. */
2780 inf
->insn_info_valid
= 0;
2781 disassembler_in_comment
= false;
2782 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2783 /* Test if a jump was detected. */
2784 if (inf
->insn_info_valid
2785 && ((inf
->insn_type
== dis_branch
)
2786 || (inf
->insn_type
== dis_condbranch
)
2787 || (inf
->insn_type
== dis_jsr
)
2788 || (inf
->insn_type
== dis_condjsr
))
2789 && (inf
->target
>= section
->vma
+ start_offset
)
2790 && (inf
->target
< section
->vma
+ stop_offset
))
2792 struct jump_info
*ji
=
2793 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2794 jump_info_add_front (ji
, &jumps
);
2799 addr_offset
+= octets
/ opb
;
2802 disassemble_set_printf (inf
, (void *) stdout
, (fprintf_ftype
) fprintf
,
2803 (fprintf_styled_ftype
) fprintf_styled
);
2804 free (sfile
.buffer
);
2807 jump_info_merge (&jumps
);
2808 /* Process jumps. */
2809 jump_info_sort (&jumps
);
2811 /* Group jumps by level. */
2812 struct jump_info
*last_jump
= jumps
;
2817 /* The last jump is part of the next group. */
2818 struct jump_info
*base
= last_jump
;
2819 /* Increment level. */
2820 base
->level
= ++max_level
;
2822 /* Find jumps that can be combined on the same
2823 level, with the largest jumps tested first.
2824 This has the advantage that large jumps are on
2825 lower levels and do not intersect with small
2826 jumps that get grouped on higher levels. */
2827 struct jump_info
*exchange_item
= last_jump
->next
;
2828 struct jump_info
*it
= exchange_item
;
2830 for (; it
; it
= it
->next
)
2832 /* Test if the jump intersects with any
2833 jump from current group. */
2835 struct jump_info
*it_collision
;
2837 for (it_collision
= base
;
2838 it_collision
!= exchange_item
;
2839 it_collision
= it_collision
->next
)
2841 /* This jump intersects so we leave it out. */
2842 if (jump_info_intersect (it_collision
, it
))
2849 /* Add jump to group. */
2852 /* Move current element to the front. */
2853 if (it
!= exchange_item
)
2855 struct jump_info
*save
= it
->prev
;
2856 jump_info_move_linked (it
, exchange_item
, &jumps
);
2862 last_jump
= exchange_item
;
2863 exchange_item
= exchange_item
->next
;
2865 last_jump
->level
= max_level
;
2869 /* Move to next group. */
2870 last_jump
= exchange_item
;
2876 /* The number of zeroes we want to see before we start skipping them.
2877 The number is arbitrarily chosen. */
2879 #define DEFAULT_SKIP_ZEROES 8
2881 /* The number of zeroes to skip at the end of a section. If the
2882 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2883 SKIP_ZEROES, they will be disassembled. If there are fewer than
2884 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2885 attempt to avoid disassembling zeroes inserted by section
2888 #define DEFAULT_SKIP_ZEROES_AT_END 3
2891 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2896 /* Like null_print, but takes the extra STYLE argument. As this is not
2897 going to print anything, the extra argument is just ignored. */
2900 null_styled_print (const void * stream ATTRIBUTE_UNUSED
,
2901 enum disassembler_style style ATTRIBUTE_UNUSED
,
2902 const char * format ATTRIBUTE_UNUSED
, ...)
2907 /* Print out jump visualization. */
2910 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2911 uint8_t *color_buffer
)
2916 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2918 size_t line_buffer_size
= strlen (line_buffer
);
2919 char last_color
= 0;
2922 for (i
= 0; i
<= line_buffer_size
; ++i
)
2926 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2928 if (color
!= last_color
)
2931 if (extended_color_output
)
2932 /* Use extended 8bit color, but
2933 do not choose dark colors. */
2934 printf ("\033[38;5;%dm", 124 + (color
% 108));
2936 /* Use simple terminal colors. */
2937 printf ("\033[%dm", 31 + (color
% 7));
2944 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2948 /* Disassemble some data in memory between given values. */
2951 disassemble_bytes (struct disassemble_info
*inf
,
2952 disassembler_ftype disassemble_fn
,
2955 bfd_vma start_offset
,
2956 bfd_vma stop_offset
,
2961 struct objdump_disasm_info
*aux
;
2963 unsigned int octets_per_line
;
2964 unsigned int skip_addr_chars
;
2965 bfd_vma addr_offset
;
2966 unsigned int opb
= inf
->octets_per_byte
;
2967 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2968 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2972 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2973 section
= inf
->section
;
2976 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2980 octets_per_line
= insn_width
;
2982 octets_per_line
= 4;
2984 octets_per_line
= 16;
2986 /* Figure out how many characters to skip at the start of an
2987 address, to make the disassembly look nicer. We discard leading
2988 zeroes in chunks of 4, ensuring that there is always a leading
2990 skip_addr_chars
= 0;
2991 if (!no_addresses
&& !prefix_addresses
)
2995 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2997 while (buf
[skip_addr_chars
] == '0')
3000 /* Don't discard zeros on overflow. */
3001 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
3002 skip_addr_chars
= 0;
3004 if (skip_addr_chars
!= 0)
3005 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
3008 inf
->insn_info_valid
= 0;
3010 /* Determine maximum level. */
3011 uint8_t *color_buffer
= NULL
;
3012 char *line_buffer
= NULL
;
3015 /* Some jumps were detected. */
3018 struct jump_info
*ji
;
3020 /* Find maximum jump level. */
3021 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
3023 if (ji
->level
> max_level
)
3024 max_level
= ji
->level
;
3027 /* Allocate buffers. */
3028 size_t len
= (max_level
+ 1) * 3 + 1;
3029 line_buffer
= xmalloc (len
);
3030 line_buffer
[len
- 1] = 0;
3031 color_buffer
= xmalloc (len
);
3032 color_buffer
[len
- 1] = 0;
3035 addr_offset
= start_offset
;
3036 while (addr_offset
< stop_offset
)
3038 bool need_nl
= false;
3042 /* Make sure we don't use relocs from previous instructions. */
3045 /* If we see more than SKIP_ZEROES octets of zeroes, we just
3047 if (! disassemble_zeroes
)
3048 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
3049 if (data
[addr_offset
* opb
+ octets
] != 0)
3051 if (! disassemble_zeroes
3052 && (inf
->insn_info_valid
== 0
3053 || inf
->branch_delay_insns
== 0)
3054 && (octets
>= skip_zeroes
3055 || (addr_offset
* opb
+ octets
== stop_offset
* opb
3056 && octets
< skip_zeroes_at_end
)))
3058 /* If there are more nonzero octets to follow, we only skip
3059 zeroes in multiples of 4, to try to avoid running over
3060 the start of an instruction which happens to start with
3062 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
3065 /* If we are going to display more data, and we are displaying
3066 file offsets, then tell the user how many zeroes we skip
3067 and the file offset from where we resume dumping. */
3068 if (display_file_offsets
3069 && addr_offset
+ octets
/ opb
< stop_offset
)
3070 printf (_("\t... (skipping %lu zeroes, "
3071 "resuming at file offset: 0x%lx)\n"),
3072 (unsigned long) (octets
/ opb
),
3073 (unsigned long) (section
->filepos
3074 + addr_offset
+ octets
/ opb
));
3081 unsigned int bpc
= 0;
3082 unsigned int pb
= 0;
3084 if (with_line_numbers
|| with_source_code
)
3085 show_line (aux
->abfd
, section
, addr_offset
);
3089 else if (!prefix_addresses
)
3093 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
3094 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3098 printf ("%s:\t", buf
+ skip_addr_chars
);
3102 aux
->require_sec
= true;
3103 objdump_print_address (section
->vma
+ addr_offset
, inf
);
3104 aux
->require_sec
= false;
3108 print_jump_visualisation (section
->vma
+ addr_offset
,
3109 max_level
, line_buffer
,
3117 disassemble_set_printf
3118 (inf
, &sfile
, (fprintf_ftype
) objdump_sprintf
,
3119 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3120 inf
->bytes_per_line
= 0;
3121 inf
->bytes_per_chunk
= 0;
3122 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
3123 | (wide_output
? WIDE_OUTPUT
: 0));
3125 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
3127 if (inf
->disassembler_needs_relocs
3128 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
3129 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
3130 && *relppp
< relppend
)
3132 bfd_signed_vma distance_to_rel
;
3133 int max_reloc_offset
3134 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
3136 distance_to_rel
= ((**relppp
)->address
- rel_offset
3140 if (distance_to_rel
> 0
3141 && (max_reloc_offset
< 0
3142 || distance_to_rel
<= max_reloc_offset
))
3144 /* This reloc *might* apply to the current insn,
3145 starting somewhere inside it. Discover the length
3146 of the current insn so that the check below will
3149 insn_size
= insn_width
;
3152 /* We find the length by calling the dissassembler
3153 function with a dummy print handler. This should
3154 work unless the disassembler is not expecting to
3155 be called multiple times for the same address.
3157 This does mean disassembling the instruction
3158 twice, but we only do this when there is a high
3159 probability that there is a reloc that will
3160 affect the instruction. */
3161 disassemble_set_printf
3162 (inf
, inf
->stream
, (fprintf_ftype
) null_print
,
3163 (fprintf_styled_ftype
) null_styled_print
);
3164 insn_size
= disassemble_fn (section
->vma
3165 + addr_offset
, inf
);
3166 disassemble_set_printf
3168 (fprintf_ftype
) objdump_sprintf
,
3169 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3173 /* Check to see if the current reloc is associated with
3174 the instruction that we are about to disassemble. */
3175 if (distance_to_rel
== 0
3176 || (distance_to_rel
> 0
3177 && distance_to_rel
< insn_size
/ (int) opb
))
3179 inf
->flags
|= INSN_HAS_RELOC
;
3180 aux
->reloc
= **relppp
;
3184 if (! disassemble_all
3185 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3186 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3187 /* Set a stop_vma so that the disassembler will not read
3188 beyond the next symbol. We assume that symbols appear on
3189 the boundaries between instructions. We only do this when
3190 disassembling code of course, and when -D is in effect. */
3191 inf
->stop_vma
= section
->vma
+ stop_offset
;
3193 inf
->stop_offset
= stop_offset
;
3194 disassembler_in_comment
= false;
3195 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3199 disassemble_set_printf (inf
, stdout
, (fprintf_ftype
) fprintf
,
3200 (fprintf_styled_ftype
) fprintf_styled
);
3201 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3202 octets_per_line
= inf
->bytes_per_line
;
3203 if (insn_size
< (int) opb
)
3206 printf ("%s\n", sfile
.buffer
);
3209 non_fatal (_("disassemble_fn returned length %d"),
3220 octets
= octets_per_line
;
3221 if (addr_offset
+ octets
/ opb
> stop_offset
)
3222 octets
= (stop_offset
- addr_offset
) * opb
;
3224 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3226 if (ISPRINT (data
[j
]))
3227 buf
[j
- addr_offset
* opb
] = data
[j
];
3229 buf
[j
- addr_offset
* opb
] = '.';
3231 buf
[j
- addr_offset
* opb
] = '\0';
3234 if (prefix_addresses
3236 : show_raw_insn
>= 0)
3240 /* If ! prefix_addresses and ! wide_output, we print
3241 octets_per_line octets per line. */
3243 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3244 pb
= octets_per_line
;
3246 if (inf
->bytes_per_chunk
)
3247 bpc
= inf
->bytes_per_chunk
;
3251 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3253 /* PR 21580: Check for a buffer ending early. */
3254 if (j
+ bpc
<= stop_offset
* opb
)
3258 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3260 for (k
= bpc
; k
-- != 0; )
3261 printf ("%02x", (unsigned) data
[j
+ k
]);
3265 for (k
= 0; k
< bpc
; k
++)
3266 printf ("%02x", (unsigned) data
[j
+ k
]);
3272 for (; pb
< octets_per_line
; pb
+= bpc
)
3276 for (k
= 0; k
< bpc
; k
++)
3281 /* Separate raw data from instruction by extra space. */
3291 printf ("%s", sfile
.buffer
);
3293 if (prefix_addresses
3295 : show_raw_insn
>= 0)
3303 j
= addr_offset
* opb
+ pb
;
3309 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3310 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3314 printf ("%s:\t", buf
+ skip_addr_chars
);
3317 print_jump_visualisation (section
->vma
+ j
/ opb
,
3318 max_level
, line_buffer
,
3321 pb
+= octets_per_line
;
3324 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3326 /* PR 21619: Check for a buffer ending early. */
3327 if (j
+ bpc
<= stop_offset
* opb
)
3331 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3333 for (k
= bpc
; k
-- != 0; )
3334 printf ("%02x", (unsigned) data
[j
+ k
]);
3338 for (k
= 0; k
< bpc
; k
++)
3339 printf ("%02x", (unsigned) data
[j
+ k
]);
3353 while ((*relppp
) < relppend
3354 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3356 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3369 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3374 if (q
->howto
== NULL
)
3375 printf ("*unknown*\t");
3376 else if (q
->howto
->name
)
3377 printf ("%s\t", q
->howto
->name
);
3379 printf ("%d\t", q
->howto
->type
);
3381 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3382 printf ("*unknown*");
3385 const char *sym_name
;
3387 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3388 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3389 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3394 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3395 sym_name
= bfd_section_name (sym_sec
);
3396 if (sym_name
== NULL
|| *sym_name
== '\0')
3397 sym_name
= "*unknown*";
3398 printf ("%s", sanitize_string (sym_name
));
3404 bfd_vma addend
= q
->addend
;
3405 if ((bfd_signed_vma
) addend
< 0)
3412 objdump_print_value (addend
, inf
, true);
3424 addr_offset
+= octets
/ opb
;
3427 free (sfile
.buffer
);
3429 free (color_buffer
);
3433 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3435 const struct elf_backend_data
*bed
;
3436 bfd_vma sign_adjust
= 0;
3437 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3438 struct objdump_disasm_info
*paux
;
3439 unsigned int opb
= pinfo
->octets_per_byte
;
3440 bfd_byte
*data
= NULL
;
3441 bfd_size_type datasize
= 0;
3442 arelent
**rel_pp
= NULL
;
3443 arelent
**rel_ppstart
= NULL
;
3444 arelent
**rel_ppend
;
3445 bfd_vma stop_offset
;
3446 asymbol
*sym
= NULL
;
3450 unsigned long addr_offset
;
3454 stop_offset_reached
,
3459 /* Sections that do not contain machine
3460 code are not normally disassembled. */
3461 if (! disassemble_all
3462 && only_list
== NULL
3463 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3464 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3467 if (! process_section_p (section
))
3470 datasize
= bfd_section_size (section
);
3474 if (start_address
== (bfd_vma
) -1
3475 || start_address
< section
->vma
)
3478 addr_offset
= start_address
- section
->vma
;
3480 if (stop_address
== (bfd_vma
) -1)
3481 stop_offset
= datasize
/ opb
;
3484 if (stop_address
< section
->vma
)
3487 stop_offset
= stop_address
- section
->vma
;
3488 if (stop_offset
> datasize
/ opb
)
3489 stop_offset
= datasize
/ opb
;
3492 if (addr_offset
>= stop_offset
)
3495 /* Decide which set of relocs to use. Load them if necessary. */
3496 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3497 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3499 rel_pp
= pinfo
->dynrelbuf
;
3500 rel_count
= pinfo
->dynrelcount
;
3501 /* Dynamic reloc addresses are absolute, non-dynamic are section
3502 relative. REL_OFFSET specifies the reloc address corresponding
3503 to the start of this section. */
3504 rel_offset
= section
->vma
;
3512 if ((section
->flags
& SEC_RELOC
) != 0
3513 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3517 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3519 bfd_fatal (bfd_get_filename (abfd
));
3523 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3524 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3526 bfd_fatal (bfd_get_filename (abfd
));
3528 /* Sort the relocs by address. */
3529 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3533 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3535 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3537 non_fatal (_("Reading section %s failed because: %s"),
3538 section
->name
, bfd_errmsg (bfd_get_error ()));
3542 pinfo
->buffer
= data
;
3543 pinfo
->buffer_vma
= section
->vma
;
3544 pinfo
->buffer_length
= datasize
;
3545 pinfo
->section
= section
;
3547 /* Sort the symbols into value and section order. */
3548 compare_section
= section
;
3549 if (sorted_symcount
> 1)
3550 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3552 /* Skip over the relocs belonging to addresses below the
3554 while (rel_pp
< rel_ppend
3555 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3558 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3560 /* Find the nearest symbol forwards from our current position. */
3561 paux
->require_sec
= true;
3562 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3563 (struct disassemble_info
*) inf
,
3565 paux
->require_sec
= false;
3567 /* PR 9774: If the target used signed addresses then we must make
3568 sure that we sign extend the value that we calculate for 'addr'
3569 in the loop below. */
3570 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3571 && (bed
= get_elf_backend_data (abfd
)) != NULL
3572 && bed
->sign_extend_vma
)
3573 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3575 /* Disassemble a block of instructions up to the address associated with
3576 the symbol we have just found. Then print the symbol and find the
3577 next symbol on. Repeat until we have disassembled the entire section
3578 or we have reached the end of the address range we are interested in. */
3579 do_print
= paux
->symbol
== NULL
;
3580 loop_until
= stop_offset_reached
;
3582 while (addr_offset
< stop_offset
)
3586 bfd_vma nextstop_offset
;
3589 addr
= section
->vma
+ addr_offset
;
3590 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3592 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3597 (x
< sorted_symcount
3598 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3602 pinfo
->symbols
= sorted_syms
+ place
;
3603 pinfo
->num_symbols
= x
- place
;
3604 pinfo
->symtab_pos
= place
;
3608 pinfo
->symbols
= NULL
;
3609 pinfo
->num_symbols
= 0;
3610 pinfo
->symtab_pos
= -1;
3613 /* If we are only disassembling from a specific symbol,
3614 check to see if we should start or stop displaying. */
3615 if (sym
&& paux
->symbol
)
3619 /* See if we should stop printing. */
3623 if (sym
->flags
& BSF_FUNCTION
)
3627 case stop_offset_reached
:
3628 /* Handled by the while loop. */
3632 /* FIXME: There is an implicit assumption here
3633 that the name of sym is different from
3635 if (! bfd_is_local_label (abfd
, sym
))
3642 const char * name
= bfd_asymbol_name (sym
);
3643 char * alloc
= NULL
;
3645 if (do_demangle
&& name
[0] != '\0')
3647 /* Demangle the name. */
3648 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3653 /* We are not currently printing. Check to see
3654 if the current symbol matches the requested symbol. */
3655 if (streq (name
, paux
->symbol
))
3659 if (sym
->flags
& BSF_FUNCTION
)
3661 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3662 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3664 /* Sym is a function symbol with a size associated
3665 with it. Turn on automatic disassembly for the
3666 next VALUE bytes. */
3667 stop_offset
= addr_offset
3668 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3669 loop_until
= stop_offset_reached
;
3673 /* Otherwise we need to tell the loop heuristic to
3674 loop until the next function symbol is encountered. */
3675 loop_until
= function_sym
;
3680 /* Otherwise loop until the next symbol is encountered. */
3681 loop_until
= next_sym
;
3689 if (! prefix_addresses
&& do_print
)
3691 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3692 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3694 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3697 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3699 else if (sym
== NULL
)
3703 #define is_valid_next_sym(SYM) \
3704 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3705 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3706 && pinfo->symbol_is_valid (SYM, pinfo))
3708 /* Search forward for the next appropriate symbol in
3709 SECTION. Note that all the symbols are sorted
3710 together into one big array, and that some sections
3711 may have overlapping addresses. */
3712 while (place
< sorted_symcount
3713 && ! is_valid_next_sym (sorted_syms
[place
]))
3716 if (place
>= sorted_symcount
)
3719 nextsym
= sorted_syms
[place
];
3722 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3723 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3724 else if (nextsym
== NULL
)
3725 nextstop_offset
= stop_offset
;
3727 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3729 if (nextstop_offset
> stop_offset
3730 || nextstop_offset
<= addr_offset
)
3731 nextstop_offset
= stop_offset
;
3733 /* If a symbol is explicitly marked as being an object
3734 rather than a function, just dump the bytes without
3735 disassembling them. */
3738 || sym
->section
!= section
3739 || bfd_asymbol_value (sym
) > addr
3740 || ((sym
->flags
& BSF_OBJECT
) == 0
3741 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3743 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3745 || (sym
->flags
& BSF_FUNCTION
) != 0)
3752 /* Resolve symbol name. */
3753 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3755 struct disassemble_info di
;
3758 sf
.alloc
= strlen (sym
->name
) + 40;
3759 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3761 disassemble_set_printf
3762 (&di
, &sf
, (fprintf_ftype
) objdump_sprintf
,
3763 (fprintf_styled_ftype
) objdump_styled_sprintf
);
3765 objdump_print_symname (abfd
, &di
, sym
);
3767 /* Fetch jump information. */
3768 detected_jumps
= disassemble_jumps
3769 (pinfo
, paux
->disassemble_fn
,
3770 addr_offset
, nextstop_offset
,
3771 rel_offset
, &rel_pp
, rel_ppend
);
3773 /* Free symbol name. */
3777 /* Add jumps to output. */
3778 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3779 addr_offset
, nextstop_offset
,
3780 rel_offset
, &rel_pp
, rel_ppend
);
3783 while (detected_jumps
)
3785 detected_jumps
= jump_info_free (detected_jumps
);
3789 addr_offset
= nextstop_offset
;
3795 if (rel_ppstart
!= NULL
)
3799 /* Disassemble the contents of an object file. */
3802 disassemble_data (bfd
*abfd
)
3804 struct disassemble_info disasm_info
;
3805 struct objdump_disasm_info aux
;
3809 prev_functionname
= NULL
;
3811 prev_discriminator
= 0;
3813 /* We make a copy of syms to sort. We don't want to sort syms
3814 because that will screw up the relocs. */
3815 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3816 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3817 * sizeof (asymbol
*));
3818 if (sorted_symcount
!= 0)
3820 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3821 sorted_symcount
* sizeof (asymbol
*));
3823 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3826 for (i
= 0; i
< synthcount
; ++i
)
3828 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3832 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
,
3833 (fprintf_styled_ftype
) fprintf_styled
);
3834 disasm_info
.application_data
= (void *) &aux
;
3836 aux
.require_sec
= false;
3837 disasm_info
.dynrelbuf
= NULL
;
3838 disasm_info
.dynrelcount
= 0;
3840 aux
.symbol
= disasm_sym
;
3842 disasm_info
.print_address_func
= objdump_print_address
;
3843 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3845 if (machine
!= NULL
)
3847 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3850 fatal (_("can't use supplied machine %s"), machine
);
3852 abfd
->arch_info
= inf
;
3855 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3857 struct bfd_target
*xvec
;
3859 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3860 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3861 xvec
->byteorder
= endian
;
3865 /* Use libopcodes to locate a suitable disassembler. */
3866 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3867 bfd_big_endian (abfd
),
3868 bfd_get_mach (abfd
), abfd
);
3869 if (!aux
.disassemble_fn
)
3871 non_fatal (_("can't disassemble for architecture %s\n"),
3872 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3877 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3878 disasm_info
.arch
= bfd_get_arch (abfd
);
3879 disasm_info
.mach
= bfd_get_mach (abfd
);
3880 disasm_info
.disassembler_options
= disassembler_options
;
3881 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3882 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3883 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3884 disasm_info
.disassembler_needs_relocs
= false;
3886 if (bfd_big_endian (abfd
))
3887 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3888 else if (bfd_little_endian (abfd
))
3889 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3891 /* ??? Aborting here seems too drastic. We could default to big or little
3893 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3895 disasm_info
.endian_code
= disasm_info
.endian
;
3897 /* Allow the target to customize the info structure. */
3898 disassemble_init_for_target (& disasm_info
);
3900 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3901 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3903 if (relsize
< 0 && dump_dynamic_reloc_info
)
3904 bfd_fatal (bfd_get_filename (abfd
));
3908 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3909 disasm_info
.dynrelcount
3910 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
3911 if (disasm_info
.dynrelcount
< 0)
3912 bfd_fatal (bfd_get_filename (abfd
));
3914 /* Sort the relocs by address. */
3915 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
3919 disasm_info
.symtab
= sorted_syms
;
3920 disasm_info
.symtab_size
= sorted_symcount
;
3922 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3924 free (disasm_info
.dynrelbuf
);
3925 disasm_info
.dynrelbuf
= NULL
;
3927 disassemble_free_target (&disasm_info
);
3931 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3932 asection
*sec
, void *file
)
3934 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3935 bfd
*abfd
= (bfd
*) file
;
3941 if (section
->start
!= NULL
)
3943 /* If it is already loaded, do nothing. */
3944 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3946 free (section
->start
);
3949 section
->filename
= bfd_get_filename (abfd
);
3950 section
->reloc_info
= NULL
;
3951 section
->num_relocs
= 0;
3952 section
->address
= bfd_section_vma (sec
);
3953 section
->size
= bfd_section_size (sec
);
3954 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3955 alloced
= amt
= section
->size
+ 1;
3956 if (alloced
!= amt
|| alloced
== 0)
3958 section
->start
= NULL
;
3959 free_debug_section (debug
);
3960 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3961 sanitize_string (section
->name
),
3962 (unsigned long long) section
->size
);
3966 section
->start
= contents
= xmalloc (alloced
);
3967 /* Ensure any string section has a terminating NUL. */
3968 section
->start
[section
->size
] = 0;
3970 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3971 && debug_displays
[debug
].relocate
)
3973 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3979 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3983 unsigned long reloc_count
;
3986 relocs
= (arelent
**) xmalloc (reloc_size
);
3988 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3989 if (reloc_count
== 0)
3993 section
->reloc_info
= relocs
;
3994 section
->num_relocs
= reloc_count
;
4000 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
4004 free_debug_section (debug
);
4005 printf (_("\nCan't get contents for section '%s'.\n"),
4006 sanitize_string (section
->name
));
4014 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
4019 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
4022 relocs
= (arelent
**) dsec
->reloc_info
;
4024 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
4025 if (rp
->address
== offset
)
4032 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
4034 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4035 bfd
*abfd
= (bfd
*) file
;
4039 if (!dump_any_debugging
)
4042 /* If it is already loaded, do nothing. */
4043 if (section
->start
!= NULL
)
4045 if (streq (section
->filename
, bfd_get_filename (abfd
)))
4048 /* Locate the debug section. */
4049 name
= section
->uncompressed_name
;
4050 sec
= bfd_get_section_by_name (abfd
, name
);
4053 name
= section
->compressed_name
;
4055 sec
= bfd_get_section_by_name (abfd
, name
);
4059 name
= section
->xcoff_name
;
4061 sec
= bfd_get_section_by_name (abfd
, name
);
4066 section
->name
= name
;
4067 return load_specific_debug_section (debug
, sec
, file
);
4071 free_debug_section (enum dwarf_section_display_enum debug
)
4073 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
4075 free ((char *) section
->start
);
4076 section
->start
= NULL
;
4077 section
->address
= 0;
4082 close_debug_file (void * file
)
4084 bfd
* abfd
= (bfd
*) file
;
4090 open_debug_file (const char * pathname
)
4094 data
= bfd_openr (pathname
, NULL
);
4098 if (! bfd_check_format (data
, bfd_object
))
4104 #if HAVE_LIBDEBUGINFOD
4105 /* Return a hex string represention of the build-id. */
4108 get_build_id (void * data
)
4111 char * build_id_str
;
4112 bfd
* abfd
= (bfd
*) data
;
4113 const struct bfd_build_id
* build_id
;
4115 build_id
= abfd
->build_id
;
4116 if (build_id
== NULL
)
4119 build_id_str
= malloc (build_id
->size
* 2 + 1);
4120 if (build_id_str
== NULL
)
4123 for (i
= 0; i
< build_id
->size
; i
++)
4124 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
4125 build_id_str
[build_id
->size
* 2] = '\0';
4127 return (unsigned char *)build_id_str
;
4129 #endif /* HAVE_LIBDEBUGINFOD */
4132 dump_dwarf_section (bfd
*abfd
, asection
*section
,
4135 const char *name
= bfd_section_name (section
);
4138 bool is_mainfile
= *(bool *) arg
;
4143 if (!is_mainfile
&& !process_links
4144 && (section
->flags
& SEC_DEBUGGING
) == 0)
4147 if (startswith (name
, ".gnu.linkonce.wi."))
4148 match
= ".debug_info";
4152 for (i
= 0; i
< max
; i
++)
4153 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
4154 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
4155 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
4156 && debug_displays
[i
].enabled
!= NULL
4157 && *debug_displays
[i
].enabled
)
4159 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
4161 if (strcmp (sec
->uncompressed_name
, match
) == 0)
4162 sec
->name
= sec
->uncompressed_name
;
4163 else if (strcmp (sec
->compressed_name
, match
) == 0)
4164 sec
->name
= sec
->compressed_name
;
4166 sec
->name
= sec
->xcoff_name
;
4167 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
4170 debug_displays
[i
].display (sec
, abfd
);
4172 if (i
!= info
&& i
!= abbrev
)
4173 free_debug_section ((enum dwarf_section_display_enum
) i
);
4179 /* Dump the dwarf debugging information. */
4182 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4184 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4185 if (byte_get
== NULL
)
4187 warn (_("File %s does not contain any dwarf debug information\n"),
4188 bfd_get_filename (abfd
));
4192 switch (bfd_get_arch (abfd
))
4195 /* S12Z has a 24 bit address space. But the only known
4196 producer of dwarf_info encodes addresses into 32 bits. */
4201 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4205 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4206 bfd_get_mach (abfd
));
4208 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4211 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
4212 it. Return NULL on failure. */
4215 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4216 bfd_size_type
*entsize_ptr
)
4221 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
4222 if (stabsect
== NULL
)
4224 printf (_("No %s section present\n\n"),
4225 sanitize_string (sect_name
));
4229 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
4231 non_fatal (_("reading %s section of %s failed: %s"),
4232 sect_name
, bfd_get_filename (abfd
),
4233 bfd_errmsg (bfd_get_error ()));
4239 *size_ptr
= bfd_section_size (stabsect
);
4241 *entsize_ptr
= stabsect
->entsize
;
4246 /* Stabs entries use a 12 byte format:
4247 4 byte string table index
4249 1 byte stab other field
4250 2 byte stab desc field
4252 FIXME: This will have to change for a 64 bit object format. */
4254 #define STRDXOFF (0)
4256 #define OTHEROFF (5)
4259 #define STABSIZE (12)
4261 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4262 using string table section STRSECT_NAME (in `strtab'). */
4265 print_section_stabs (bfd
*abfd
,
4266 const char *stabsect_name
,
4267 unsigned *string_offset_ptr
)
4270 unsigned file_string_table_offset
= 0;
4271 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4272 bfd_byte
*stabp
, *stabs_end
;
4275 stabs_end
= stabp
+ stab_size
;
4277 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4278 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4280 /* Loop through all symbols and print them.
4282 We start the index at -1 because there is a dummy symbol on
4283 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4284 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
4288 unsigned char type
, other
;
4289 unsigned short desc
;
4292 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4293 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4294 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4295 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4296 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4298 printf ("\n%-6d ", i
);
4299 /* Either print the stab name, or, if unnamed, print its number
4300 again (makes consistent formatting for tools like awk). */
4301 name
= bfd_get_stab_name (type
);
4303 printf ("%-6s", sanitize_string (name
));
4304 else if (type
== N_UNDF
)
4307 printf ("%-6d", type
);
4308 printf (" %-6d %-6d ", other
, desc
);
4309 bfd_printf_vma (abfd
, value
);
4310 printf (" %-6lu", strx
);
4312 /* Symbols with type == 0 (N_UNDF) specify the length of the
4313 string table associated with this file. We use that info
4314 to know how to relocate the *next* file's string table indices. */
4317 file_string_table_offset
= next_file_string_table_offset
;
4318 next_file_string_table_offset
+= value
;
4322 bfd_size_type amt
= strx
+ file_string_table_offset
;
4324 /* Using the (possibly updated) string table offset, print the
4325 string (if any) associated with this symbol. */
4326 if (amt
< stabstr_size
)
4327 /* PR 17512: file: 079-79389-0.001:0.1.
4328 FIXME: May need to sanitize this string before displaying. */
4329 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4335 *string_offset_ptr
= next_file_string_table_offset
;
4340 const char * section_name
;
4341 const char * string_section_name
;
4342 unsigned string_offset
;
4347 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4350 stab_section_names
* sought
= (stab_section_names
*) names
;
4352 /* Check for section names for which stabsect_name is a prefix, to
4353 handle .stab.N, etc. */
4354 len
= strlen (sought
->section_name
);
4356 /* If the prefix matches, and the files section name ends with a
4357 nul or a digit, then we match. I.e., we want either an exact
4358 match or a section followed by a number. */
4359 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4360 && (section
->name
[len
] == 0
4361 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4364 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
4365 &stabstr_size
, NULL
);
4369 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
4371 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4377 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4379 stab_section_names s
;
4381 s
.section_name
= stabsect_name
;
4382 s
.string_section_name
= strsect_name
;
4383 s
.string_offset
= 0;
4385 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4391 /* Dump the any sections containing stabs debugging information. */
4394 dump_stabs (bfd
*abfd
)
4396 dump_stabs_section (abfd
, ".stab", ".stabstr");
4397 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4398 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4401 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4403 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4407 dump_bfd_header (bfd
*abfd
)
4411 printf (_("architecture: %s, "),
4412 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4413 bfd_get_mach (abfd
)));
4414 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4416 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4417 PF (HAS_RELOC
, "HAS_RELOC");
4418 PF (EXEC_P
, "EXEC_P");
4419 PF (HAS_LINENO
, "HAS_LINENO");
4420 PF (HAS_DEBUG
, "HAS_DEBUG");
4421 PF (HAS_SYMS
, "HAS_SYMS");
4422 PF (HAS_LOCALS
, "HAS_LOCALS");
4423 PF (DYNAMIC
, "DYNAMIC");
4424 PF (WP_TEXT
, "WP_TEXT");
4425 PF (D_PAGED
, "D_PAGED");
4426 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4427 printf (_("\nstart address 0x"));
4428 bfd_printf_vma (abfd
, abfd
->start_address
);
4433 #ifdef ENABLE_LIBCTF
4434 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4435 it is passed, or a pointer to newly-allocated storage, in which case
4436 dump_ctf() will free it when it no longer needs it. */
4439 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4442 const char *blanks
= arg
;
4445 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4450 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4452 make_ctfsect (const char *name
, bfd_byte
*data
,
4457 ctfsect
.cts_name
= name
;
4458 ctfsect
.cts_entsize
= 1;
4459 ctfsect
.cts_size
= size
;
4460 ctfsect
.cts_data
= data
;
4465 /* Dump CTF errors/warnings. */
4467 dump_ctf_errs (ctf_dict_t
*fp
)
4469 ctf_next_t
*it
= NULL
;
4474 /* Dump accumulated errors and warnings. */
4475 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4477 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4481 if (err
!= ECTF_NEXT_END
)
4483 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4488 /* Dump one CTF archive member. */
4491 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4494 const char *things
[] = {"Header", "Labels", "Data objects",
4495 "Function objects", "Variables", "Types", "Strings",
4500 /* Don't print out the name of the default-named archive member if it appears
4501 first in the list. The name .ctf appears everywhere, even for things that
4502 aren't really archives, so printing it out is liable to be confusing; also,
4503 the common case by far is for only one archive member to exist, and hiding
4504 it in that case seems worthwhile. */
4506 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4507 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4509 if (ctf_parent_name (ctf
) != NULL
)
4510 ctf_import (ctf
, parent
);
4512 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4514 ctf_dump_state_t
*s
= NULL
;
4517 printf ("\n %s:\n", *thing
);
4518 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4519 (void *) " ")) != NULL
)
4521 printf ("%s\n", item
);
4525 if (ctf_errno (ctf
))
4527 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4528 ctf_errmsg (ctf_errno (ctf
)));
4533 dump_ctf_errs (ctf
);
4536 /* Dump the CTF debugging information. */
4539 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4541 ctf_archive_t
*ctfa
= NULL
;
4542 bfd_byte
*ctfdata
= NULL
;
4543 bfd_size_type ctfsize
;
4547 ctf_next_t
*i
= NULL
;
4552 if (sect_name
== NULL
)
4555 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4556 bfd_fatal (bfd_get_filename (abfd
));
4558 /* Load the CTF file and dump it. Preload the parent dict, since it will
4559 need to be imported into every child in turn. */
4561 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4562 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4564 dump_ctf_errs (NULL
);
4565 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4566 bfd_fatal (bfd_get_filename (abfd
));
4569 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4571 dump_ctf_errs (NULL
);
4572 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4573 bfd_fatal (bfd_get_filename (abfd
));
4576 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4578 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4579 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4580 if (err
!= ECTF_NEXT_END
)
4582 dump_ctf_errs (NULL
);
4583 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4584 bfd_fatal (bfd_get_filename (abfd
));
4586 ctf_dict_close (parent
);
4592 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4593 const char *parent_name ATTRIBUTE_UNUSED
) {}
4598 dump_bfd_private_header (bfd
*abfd
)
4600 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4601 non_fatal (_("warning: private headers incomplete: %s"),
4602 bfd_errmsg (bfd_get_error ()));
4606 dump_target_specific (bfd
*abfd
)
4608 const struct objdump_private_desc
* const *desc
;
4609 struct objdump_private_option
*opt
;
4612 /* Find the desc. */
4613 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4614 if ((*desc
)->filter (abfd
))
4619 non_fatal (_("option -P/--private not supported by this file"));
4623 /* Clear all options. */
4624 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4625 opt
->selected
= false;
4627 /* Decode options. */
4628 b
= dump_private_options
;
4631 e
= strchr (b
, ',');
4636 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4637 if (strcmp (opt
->name
, b
) == 0)
4639 opt
->selected
= true;
4642 if (opt
->name
== NULL
)
4643 non_fatal (_("target specific dump '%s' not supported"), b
);
4654 (*desc
)->dump (abfd
);
4657 /* Display a section in hexadecimal format with associated characters.
4658 Each line prefixed by the zero padded address. */
4661 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4663 bfd_byte
*data
= NULL
;
4664 bfd_size_type datasize
;
4665 bfd_vma addr_offset
;
4666 bfd_vma start_offset
;
4667 bfd_vma stop_offset
;
4668 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4669 /* Bytes per line. */
4670 const int onaline
= 16;
4675 if (! process_section_p (section
))
4678 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4681 if ((datasize
= bfd_section_size (section
)) == 0)
4684 /* Compute the address range to display. */
4685 if (start_address
== (bfd_vma
) -1
4686 || start_address
< section
->vma
)
4689 start_offset
= start_address
- section
->vma
;
4691 if (stop_address
== (bfd_vma
) -1)
4692 stop_offset
= datasize
/ opb
;
4695 if (stop_address
< section
->vma
)
4698 stop_offset
= stop_address
- section
->vma
;
4700 if (stop_offset
> datasize
/ opb
)
4701 stop_offset
= datasize
/ opb
;
4704 if (start_offset
>= stop_offset
)
4707 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4708 if (display_file_offsets
)
4709 printf (_(" (Starting at file offset: 0x%lx)"),
4710 (unsigned long) (section
->filepos
+ start_offset
));
4713 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4715 non_fatal (_("Reading section %s failed because: %s"),
4716 section
->name
, bfd_errmsg (bfd_get_error ()));
4722 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4723 if (strlen (buf
) >= sizeof (buf
))
4727 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4729 count
= strlen (buf
) - count
;
4733 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4734 if (strlen (buf
) >= sizeof (buf
))
4738 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4740 count
= strlen (buf
) - count
;
4744 for (addr_offset
= start_offset
;
4745 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4749 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4750 count
= strlen (buf
);
4751 if ((size_t) count
>= sizeof (buf
))
4755 while (count
< width
)
4760 fputs (buf
+ count
- width
, stdout
);
4763 for (j
= addr_offset
* opb
;
4764 j
< addr_offset
* opb
+ onaline
; j
++)
4766 if (j
< stop_offset
* opb
)
4767 printf ("%02x", (unsigned) (data
[j
]));
4775 for (j
= addr_offset
* opb
;
4776 j
< addr_offset
* opb
+ onaline
; j
++)
4778 if (j
>= stop_offset
* opb
)
4781 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4788 /* Actually display the various requested regions. */
4791 dump_data (bfd
*abfd
)
4793 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4796 /* Should perhaps share code and display with nm? */
4799 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
4808 max_count
= dynsymcount
;
4809 printf ("DYNAMIC SYMBOL TABLE:\n");
4814 max_count
= symcount
;
4815 printf ("SYMBOL TABLE:\n");
4819 printf (_("no symbols\n"));
4821 for (count
= 0; count
< max_count
; count
++)
4825 if (*current
== NULL
)
4826 printf (_("no information for symbol number %ld\n"), count
);
4828 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4829 printf (_("could not determine the type of symbol number %ld\n"),
4832 else if (process_section_p ((* current
)->section
)
4833 && (dump_special_syms
4834 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4836 const char *name
= (*current
)->name
;
4838 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4842 /* If we want to demangle the name, we demangle it
4843 here, and temporarily clobber it while calling
4844 bfd_print_symbol. FIXME: This is a gross hack. */
4845 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4847 (*current
)->name
= alloc
;
4848 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4849 bfd_print_symbol_all
);
4852 (*current
)->name
= name
;
4856 else if (unicode_display
!= unicode_default
4857 && name
!= NULL
&& *name
!= '\0')
4859 const char * sanitized_name
;
4861 /* If we want to sanitize the name, we do it here, and
4862 temporarily clobber it while calling bfd_print_symbol.
4863 FIXME: This is a gross hack. */
4864 sanitized_name
= sanitize_string (name
);
4865 if (sanitized_name
!= name
)
4866 (*current
)->name
= sanitized_name
;
4868 sanitized_name
= NULL
;
4869 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4870 bfd_print_symbol_all
);
4871 if (sanitized_name
!= NULL
)
4872 (*current
)->name
= name
;
4875 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4876 bfd_print_symbol_all
);
4886 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4889 char *last_filename
, *last_functionname
;
4890 unsigned int last_line
;
4891 unsigned int last_discriminator
;
4893 /* Get column headers lined up reasonably. */
4901 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4902 width
= strlen (buf
) - 7;
4904 printf ("OFFSET %*s TYPE %*s VALUE\n", width
, "", 12, "");
4907 last_filename
= NULL
;
4908 last_functionname
= NULL
;
4910 last_discriminator
= 0;
4912 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4915 const char *filename
, *functionname
;
4916 unsigned int linenumber
;
4917 unsigned int discriminator
;
4918 const char *sym_name
;
4919 const char *section_name
;
4920 bfd_vma addend2
= 0;
4922 if (start_address
!= (bfd_vma
) -1
4923 && q
->address
< start_address
)
4925 if (stop_address
!= (bfd_vma
) -1
4926 && q
->address
> stop_address
)
4929 if (with_line_numbers
4931 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4932 &filename
, &functionname
,
4933 &linenumber
, &discriminator
))
4935 if (functionname
!= NULL
4936 && (last_functionname
== NULL
4937 || strcmp (functionname
, last_functionname
) != 0))
4939 printf ("%s():\n", sanitize_string (functionname
));
4940 if (last_functionname
!= NULL
)
4941 free (last_functionname
);
4942 last_functionname
= xstrdup (functionname
);
4946 && (linenumber
!= last_line
4947 || (filename
!= NULL
4948 && last_filename
!= NULL
4949 && filename_cmp (filename
, last_filename
) != 0)
4950 || (discriminator
!= last_discriminator
)))
4952 if (discriminator
> 0)
4953 printf ("%s:%u\n", filename
== NULL
? "???" :
4954 sanitize_string (filename
), linenumber
);
4956 printf ("%s:%u (discriminator %u)\n",
4957 filename
== NULL
? "???" : sanitize_string (filename
),
4958 linenumber
, discriminator
);
4959 last_line
= linenumber
;
4960 last_discriminator
= discriminator
;
4961 if (last_filename
!= NULL
)
4962 free (last_filename
);
4963 if (filename
== NULL
)
4964 last_filename
= NULL
;
4966 last_filename
= xstrdup (filename
);
4970 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4972 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4973 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4978 section_name
= NULL
;
4981 bfd_printf_vma (abfd
, q
->address
);
4982 if (q
->howto
== NULL
)
4983 printf (" *unknown* ");
4984 else if (q
->howto
->name
)
4986 const char *name
= q
->howto
->name
;
4988 /* R_SPARC_OLO10 relocations contain two addends.
4989 But because 'arelent' lacks enough storage to
4990 store them both, the 64-bit ELF Sparc backend
4991 records this as two relocations. One R_SPARC_LO10
4992 and one R_SPARC_13, both pointing to the same
4993 address. This is merely so that we have some
4994 place to store both addend fields.
4996 Undo this transformation, otherwise the output
4997 will be confusing. */
4998 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4999 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
5001 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
5003 arelent
*q2
= *(p
+ 1);
5006 && q
->address
== q2
->address
5007 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
5009 name
= "R_SPARC_OLO10";
5010 addend2
= q2
->addend
;
5014 printf (" %-16s ", name
);
5017 printf (" %-16d ", q
->howto
->type
);
5021 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
5025 if (section_name
== NULL
)
5026 section_name
= "*unknown*";
5027 printf ("[%s]", sanitize_string (section_name
));
5032 bfd_signed_vma addend
= q
->addend
;
5040 bfd_printf_vma (abfd
, addend
);
5045 bfd_printf_vma (abfd
, addend2
);
5051 if (last_filename
!= NULL
)
5052 free (last_filename
);
5053 if (last_functionname
!= NULL
)
5054 free (last_functionname
);
5058 dump_relocs_in_section (bfd
*abfd
,
5060 void *dummy ATTRIBUTE_UNUSED
)
5062 arelent
**relpp
= NULL
;
5066 if ( bfd_is_abs_section (section
)
5067 || bfd_is_und_section (section
)
5068 || bfd_is_com_section (section
)
5069 || (! process_section_p (section
))
5070 || ((section
->flags
& SEC_RELOC
) == 0))
5073 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
5075 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
5078 printf (" (none)\n\n");
5086 relpp
= (arelent
**) xmalloc (relsize
);
5087 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
5093 non_fatal (_("failed to read relocs in: %s"),
5094 sanitize_string (bfd_get_filename (abfd
)));
5095 bfd_fatal (_("error message was"));
5097 else if (relcount
== 0)
5098 printf (" (none)\n\n");
5102 dump_reloc_set (abfd
, section
, relpp
, relcount
);
5109 dump_relocs (bfd
*abfd
)
5111 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
5115 dump_dynamic_relocs (bfd
*abfd
)
5121 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5123 bfd_fatal (bfd_get_filename (abfd
));
5125 printf ("DYNAMIC RELOCATION RECORDS");
5128 printf (" (none)\n\n");
5131 relpp
= (arelent
**) xmalloc (relsize
);
5132 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
5135 bfd_fatal (bfd_get_filename (abfd
));
5136 else if (relcount
== 0)
5137 printf (" (none)\n\n");
5141 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
5148 /* Creates a table of paths, to search for source files. */
5151 add_include_path (const char *path
)
5155 include_path_count
++;
5156 include_paths
= (const char **)
5157 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
5158 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5159 if (path
[1] == ':' && path
[2] == 0)
5160 path
= concat (path
, ".", (const char *) 0);
5162 include_paths
[include_path_count
- 1] = path
;
5166 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
5170 if ((section
->flags
& SEC_DEBUGGING
) == 0)
5172 bool *has_reloc_p
= (bool *) arg
;
5173 section
->vma
+= adjust_section_vma
;
5175 section
->lma
+= adjust_section_vma
;
5179 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5182 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5187 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5188 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5192 might_need_separate_debug_info (bool is_mainfile
)
5194 /* We do not follow links from debug info files. */
5198 /* Since do_follow_links might be enabled by default, only treat it as an
5199 indication that separate files should be loaded if setting it was a
5200 deliberate user action. */
5201 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
5204 if (process_links
|| dump_symtab
|| dump_debugging
5205 || dump_dwarf_section_info
)
5211 /* Dump selected contents of ABFD. */
5214 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5216 const struct elf_backend_data
* bed
;
5218 if (bfd_big_endian (abfd
))
5219 byte_get
= byte_get_big_endian
;
5220 else if (bfd_little_endian (abfd
))
5221 byte_get
= byte_get_little_endian
;
5225 /* Load any separate debug information files. */
5226 if (byte_get
!= NULL
&& might_need_separate_debug_info (is_mainfile
))
5228 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5230 /* If asked to do so, recursively dump the separate files. */
5231 if (do_follow_links
)
5235 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5236 dump_bfd (i
->handle
, false);
5240 /* Adjust user-specified start and stop limits for targets that use
5241 signed addresses. */
5242 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5243 && (bed
= get_elf_backend_data (abfd
)) != NULL
5244 && bed
->sign_extend_vma
)
5246 start_address
= sign_extend_address (abfd
, start_address
,
5248 stop_address
= sign_extend_address (abfd
, stop_address
,
5252 /* If we are adjusting section VMA's, change them all now. Changing
5253 the BFD information is a hack. However, we must do it, or
5254 bfd_find_nearest_line will not do the right thing. */
5255 if (adjust_section_vma
!= 0)
5257 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5258 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5261 if (is_mainfile
|| process_links
)
5263 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5264 printf (_("\n%s: file format %s\n"),
5265 sanitize_string (bfd_get_filename (abfd
)),
5268 print_arelt_descr (stdout
, abfd
, true, false);
5269 if (dump_file_header
)
5270 dump_bfd_header (abfd
);
5271 if (dump_private_headers
)
5272 dump_bfd_private_header (abfd
);
5273 if (dump_private_options
!= NULL
)
5274 dump_target_specific (abfd
);
5275 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5283 || dump_dwarf_section_info
)
5285 syms
= slurp_symtab (abfd
);
5287 /* If following links, load any symbol tables from the linked files as well. */
5288 if (do_follow_links
&& is_mainfile
)
5292 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5294 asymbol
** extra_syms
;
5295 long old_symcount
= symcount
;
5297 extra_syms
= slurp_symtab (i
->handle
);
5301 if (old_symcount
== 0)
5307 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5308 * sizeof (asymbol
*)));
5309 memcpy (syms
+ old_symcount
,
5311 (symcount
+ 1) * sizeof (asymbol
*));
5315 symcount
+= old_symcount
;
5320 if (is_mainfile
|| process_links
)
5322 if (dump_section_headers
)
5323 dump_headers (abfd
);
5325 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5326 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5327 dynsyms
= slurp_dynamic_symtab (abfd
);
5331 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5332 dynsymcount
, dynsyms
,
5339 dump_symbols (abfd
, false);
5340 if (dump_dynamic_symtab
)
5341 dump_symbols (abfd
, true);
5343 if (dump_dwarf_section_info
)
5344 dump_dwarf (abfd
, is_mainfile
);
5345 if (is_mainfile
|| process_links
)
5347 if (dump_ctf_section_info
)
5348 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5349 if (dump_stab_section_info
)
5351 if (dump_reloc_info
&& ! disassemble
)
5353 if (dump_dynamic_reloc_info
&& ! disassemble
)
5354 dump_dynamic_relocs (abfd
);
5355 if (dump_section_contents
)
5358 disassemble_data (abfd
);
5365 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5366 if (dhandle
!= NULL
)
5368 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5370 dump_debugging_tags
!= 0))
5372 non_fatal (_("%s: printing debugging information failed"),
5373 bfd_get_filename (abfd
));
5379 /* PR 6483: If there was no STABS debug info in the file, try
5381 else if (! dump_dwarf_section_info
)
5383 dwarf_select_sections_all ();
5384 dump_dwarf (abfd
, is_mainfile
);
5411 free_debug_memory ();
5415 display_object_bfd (bfd
*abfd
)
5419 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5421 dump_bfd (abfd
, true);
5425 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5427 nonfatal (bfd_get_filename (abfd
));
5428 list_matching_formats (matching
);
5432 if (bfd_get_error () != bfd_error_file_not_recognized
)
5434 nonfatal (bfd_get_filename (abfd
));
5438 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5440 dump_bfd (abfd
, true);
5444 nonfatal (bfd_get_filename (abfd
));
5446 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5447 list_matching_formats (matching
);
5451 display_any_bfd (bfd
*file
, int level
)
5453 /* Decompress sections unless dumping the section contents. */
5454 if (!dump_section_contents
)
5455 file
->flags
|= BFD_DECOMPRESS
;
5457 /* If the file is an archive, process all of its elements. */
5458 if (bfd_check_format (file
, bfd_archive
))
5461 bfd
*last_arfile
= NULL
;
5464 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5465 else if (level
> 100)
5467 /* Prevent corrupted files from spinning us into an
5468 infinite loop. 100 is an arbitrary heuristic. */
5469 fatal (_("Archive nesting is too deep"));
5473 printf (_("In nested archive %s:\n"),
5474 sanitize_string (bfd_get_filename (file
)));
5478 bfd_set_error (bfd_error_no_error
);
5480 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5483 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5484 nonfatal (bfd_get_filename (file
));
5488 display_any_bfd (arfile
, level
+ 1);
5490 if (last_arfile
!= NULL
)
5492 bfd_close (last_arfile
);
5493 /* PR 17512: file: ac585d01. */
5494 if (arfile
== last_arfile
)
5500 last_arfile
= arfile
;
5503 if (last_arfile
!= NULL
)
5504 bfd_close (last_arfile
);
5507 display_object_bfd (file
);
5511 display_file (char *filename
, char *target
, bool last_file
)
5515 if (get_file_size (filename
) < 1)
5521 file
= bfd_openr (filename
, target
);
5524 nonfatal (filename
);
5528 display_any_bfd (file
, 0);
5530 /* This is an optimization to improve the speed of objdump, especially when
5531 dumping a file with lots of associated debug informatiom. Calling
5532 bfd_close on such a file can take a non-trivial amount of time as there
5533 are lots of lists to walk and buffers to free. This is only really
5534 necessary however if we are about to load another file and we need the
5535 memory back. Otherwise, if we are about to exit, then we can save (a lot
5536 of) time by only doing a quick close, and allowing the OS to reclaim the
5541 bfd_close_all_done (file
);
5545 main (int argc
, char **argv
)
5548 char *target
= default_target
;
5549 bool seenflag
= false;
5551 #ifdef HAVE_LC_MESSAGES
5552 setlocale (LC_MESSAGES
, "");
5554 setlocale (LC_CTYPE
, "");
5556 bindtextdomain (PACKAGE
, LOCALEDIR
);
5557 textdomain (PACKAGE
);
5559 program_name
= *argv
;
5560 xmalloc_set_program_name (program_name
);
5561 bfd_set_error_program_name (program_name
);
5563 START_PROGRESS (program_name
, 0);
5565 expandargv (&argc
, &argv
);
5567 if (bfd_init () != BFD_INIT_MAGIC
)
5568 fatal (_("fatal error: libbfd ABI mismatch"));
5569 set_default_bfd_target ();
5571 while ((c
= getopt_long (argc
, argv
,
5572 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5573 long_options
, (int *) 0))
5579 break; /* We've been given a long option. */
5586 if (disassembler_options
)
5587 /* Ignore potential memory leak for now. */
5588 options
= concat (disassembler_options
, ",",
5589 optarg
, (const char *) NULL
);
5592 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5599 display_file_offsets
= true;
5602 with_line_numbers
= true;
5611 enum demangling_styles style
;
5613 style
= cplus_demangle_name_to_style (optarg
);
5614 if (style
== unknown_demangling
)
5615 fatal (_("unknown demangling style `%s'"),
5618 cplus_demangle_set_style (style
);
5621 case OPTION_RECURSE_LIMIT
:
5622 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5624 case OPTION_NO_RECURSE_LIMIT
:
5625 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5628 do_wide
= wide_output
= true;
5630 case OPTION_ADJUST_VMA
:
5631 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5633 case OPTION_START_ADDRESS
:
5634 start_address
= parse_vma (optarg
, "--start-address");
5635 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5636 fatal (_("error: the start address should be before the end address"));
5638 case OPTION_STOP_ADDRESS
:
5639 stop_address
= parse_vma (optarg
, "--stop-address");
5640 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5641 fatal (_("error: the stop address should be after the start address"));
5645 prefix_length
= strlen (prefix
);
5646 /* Remove an unnecessary trailing '/' */
5647 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5650 case OPTION_PREFIX_STRIP
:
5651 prefix_strip
= atoi (optarg
);
5652 if (prefix_strip
< 0)
5653 fatal (_("error: prefix strip must be non-negative"));
5655 case OPTION_INSN_WIDTH
:
5656 insn_width
= strtoul (optarg
, NULL
, 0);
5657 if (insn_width
<= 0)
5658 fatal (_("error: instruction width must be positive"));
5660 case OPTION_INLINES
:
5661 unwind_inlines
= true;
5663 case OPTION_VISUALIZE_JUMPS
:
5664 visualize_jumps
= true;
5665 color_output
= false;
5666 extended_color_output
= false;
5669 if (streq (optarg
, "color"))
5670 color_output
= true;
5671 else if (streq (optarg
, "extended-color"))
5673 color_output
= true;
5674 extended_color_output
= true;
5676 else if (streq (optarg
, "off"))
5677 visualize_jumps
= false;
5679 nonfatal (_("unrecognized argument to --visualize-option"));
5682 case OPTION_DISASSEMBLER_COLOR
:
5683 if (streq (optarg
, "off"))
5684 disassembler_color
= false;
5685 else if (streq (optarg
, "color"))
5686 disassembler_color
= true;
5687 else if (streq (optarg
, "extended-color"))
5688 disassembler_extended_color
= true;
5690 nonfatal (_("unrecognized argument to --disassembler-color"));
5693 if (strcmp (optarg
, "B") == 0)
5694 endian
= BFD_ENDIAN_BIG
;
5695 else if (strcmp (optarg
, "L") == 0)
5696 endian
= BFD_ENDIAN_LITTLE
;
5699 nonfatal (_("unrecognized -E option"));
5704 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5705 endian
= BFD_ENDIAN_BIG
;
5706 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5707 endian
= BFD_ENDIAN_LITTLE
;
5710 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5717 dump_file_header
= true;
5721 formats_info
= true;
5725 add_include_path (optarg
);
5728 dump_private_headers
= true;
5732 dump_private_options
= optarg
;
5736 dump_private_headers
= true;
5738 dump_reloc_info
= true;
5739 dump_file_header
= true;
5740 dump_ar_hdrs
= true;
5741 dump_section_headers
= true;
5749 dump_dynamic_symtab
= true;
5755 disasm_sym
= optarg
;
5758 disassemble_zeroes
= true;
5762 disassemble_all
= true;
5767 with_source_code
= true;
5770 case OPTION_SOURCE_COMMENT
:
5772 with_source_code
= true;
5775 source_comment
= xstrdup (sanitize_string (optarg
));
5777 source_comment
= xstrdup ("# ");
5785 dump_debugging_tags
= 1;
5790 process_links
= true;
5791 do_follow_links
= true;
5797 if (dwarf_select_sections_by_letters (optarg
))
5798 dump_dwarf_section_info
= true;
5802 dump_dwarf_section_info
= true;
5803 dwarf_select_sections_all ();
5810 if (dwarf_select_sections_by_names (optarg
))
5811 dump_dwarf_section_info
= true;
5815 dwarf_select_sections_all ();
5816 dump_dwarf_section_info
= true;
5819 case OPTION_DWARF_DEPTH
:
5822 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5825 case OPTION_DWARF_START
:
5828 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5829 suppress_bfd_header
= 1;
5832 case OPTION_DWARF_CHECK
:
5835 #ifdef ENABLE_LIBCTF
5837 dump_ctf_section_info
= true;
5839 dump_ctf_section_name
= xstrdup (optarg
);
5842 case OPTION_CTF_PARENT
:
5843 dump_ctf_parent_name
= xstrdup (optarg
);
5847 dump_stab_section_info
= true;
5851 dump_section_contents
= true;
5855 dump_reloc_info
= true;
5859 dump_dynamic_reloc_info
= true;
5863 dump_ar_hdrs
= true;
5867 dump_section_headers
= true;
5872 show_version
= true;
5877 if (streq (optarg
, "default") || streq (optarg
, "d"))
5878 unicode_display
= unicode_default
;
5879 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5880 unicode_display
= unicode_locale
;
5881 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5882 unicode_display
= unicode_escape
;
5883 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5884 unicode_display
= unicode_invalid
;
5885 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5886 unicode_display
= unicode_hex
;
5887 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5888 unicode_display
= unicode_highlight
;
5890 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
5895 /* No need to set seenflag or to break - usage() does not return. */
5902 print_version ("objdump");
5907 dump_any_debugging
= (dump_debugging
5908 || dump_dwarf_section_info
5912 exit_status
= display_info ();
5916 display_file ("a.out", target
, true);
5918 for (; optind
< argc
;)
5920 display_file (argv
[optind
], target
, optind
== argc
- 1);
5926 free (dump_ctf_section_name
);
5927 free (dump_ctf_parent_name
);
5928 free ((void *) source_comment
);
5930 END_PROGRESS (program_name
);