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. */
134 static int dump_any_debugging
;
135 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
137 /* A structure to record the sections mentioned in -j switches. */
140 const char *name
; /* The name of the section. */
141 bool seen
; /* A flag to indicate that the section has been found in one or more input files. */
142 struct only
*next
; /* Pointer to the next structure in the list. */
144 /* Pointer to an array of 'only' structures.
145 This pointer is NULL if the -j switch has not been used. */
146 static struct only
* only_list
= NULL
;
148 /* Variables for handling include file path table. */
149 static const char **include_paths
;
150 static int include_path_count
;
152 /* Extra info to pass to the section disassembler and address printing
154 struct objdump_disasm_info
158 disassembler_ftype disassemble_fn
;
163 /* Architecture to disassemble for, or default if NULL. */
164 static char *machine
= NULL
;
166 /* Target specific options to the disassembler. */
167 static char *disassembler_options
= NULL
;
169 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
170 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
172 /* The symbol table. */
173 static asymbol
**syms
;
175 /* Number of symbols in `syms'. */
176 static long symcount
= 0;
178 /* The sorted symbol table. */
179 static asymbol
**sorted_syms
;
181 /* Number of symbols in `sorted_syms'. */
182 static long sorted_symcount
= 0;
184 /* The dynamic symbol table. */
185 static asymbol
**dynsyms
;
187 /* The synthetic symbol table. */
188 static asymbol
*synthsyms
;
189 static long synthcount
= 0;
191 /* Number of symbols in `dynsyms'. */
192 static long dynsymcount
= 0;
194 static bfd_byte
*stabs
;
195 static bfd_size_type stab_size
;
197 static bfd_byte
*strtab
;
198 static bfd_size_type stabstr_size
;
200 /* Handlers for -P/--private. */
201 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
203 OBJDUMP_PRIVATE_VECTORS
207 /* The list of detected jumps inside a function. */
208 static struct jump_info
*detected_jumps
= NULL
;
210 typedef enum unicode_display_type
218 } unicode_display_type
;
220 static unicode_display_type unicode_display
= unicode_default
;
222 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
224 usage (FILE *stream
, int status
)
226 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
227 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
228 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
229 fprintf (stream
, _("\
230 -a, --archive-headers Display archive header information\n"));
231 fprintf (stream
, _("\
232 -f, --file-headers Display the contents of the overall file header\n"));
233 fprintf (stream
, _("\
234 -p, --private-headers Display object format specific file header contents\n"));
235 fprintf (stream
, _("\
236 -P, --private=OPT,OPT... Display object format specific contents\n"));
237 fprintf (stream
, _("\
238 -h, --[section-]headers Display the contents of the section headers\n"));
239 fprintf (stream
, _("\
240 -x, --all-headers Display the contents of all headers\n"));
241 fprintf (stream
, _("\
242 -d, --disassemble Display assembler contents of executable sections\n"));
243 fprintf (stream
, _("\
244 -D, --disassemble-all Display assembler contents of all sections\n"));
245 fprintf (stream
, _("\
246 --disassemble=<sym> Display assembler contents from <sym>\n"));
247 fprintf (stream
, _("\
248 -S, --source Intermix source code with disassembly\n"));
249 fprintf (stream
, _("\
250 --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
251 fprintf (stream
, _("\
252 -s, --full-contents Display the full contents of all sections requested\n"));
253 fprintf (stream
, _("\
254 -g, --debugging Display debug information in object file\n"));
255 fprintf (stream
, _("\
256 -e, --debugging-tags Display debug information using ctags style\n"));
257 fprintf (stream
, _("\
258 -G, --stabs Display (in raw form) any STABS info in the file\n"));
259 fprintf (stream
, _("\
260 -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
261 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
262 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
263 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
265 Display the contents of DWARF debug sections\n"));
266 fprintf (stream
, _("\
267 -Wk,--dwarf=links Display the contents of sections that link to\n\
268 separate debuginfo files\n"));
269 #if DEFAULT_FOR_FOLLOW_LINKS
270 fprintf (stream
, _("\
271 -WK,--dwarf=follow-links\n\
272 Follow links to separate debug info files (default)\n"));
273 fprintf (stream
, _("\
274 -WN,--dwarf=no-follow-links\n\
275 Do not follow links to separate debug info files\n"));
277 fprintf (stream
, _("\
278 -WK,--dwarf=follow-links\n\
279 Follow links to separate debug info files\n"));
280 fprintf (stream
, _("\
281 -WN,--dwarf=no-follow-links\n\
282 Do not follow links to separate debug info files\n\
285 #if HAVE_LIBDEBUGINFOD
286 fprintf (stream
, _("\
287 -WD --dwarf=use-debuginfod\n\
288 When following links, also query debuginfod servers (default)\n"));
289 fprintf (stream
, _("\
290 -WE --dwarf=do-not-use-debuginfod\n\
291 When following links, do not query debuginfod servers\n"));
293 fprintf (stream
, _("\
294 -L, --process-links Display the contents of non-debug sections in\n\
295 separate debuginfo files. (Implies -WK)\n"));
297 fprintf (stream
, _("\
298 --ctf[=SECTION] Display CTF info from SECTION, (default `.ctf')\n"));
300 fprintf (stream
, _("\
301 -t, --syms Display the contents of the symbol table(s)\n"));
302 fprintf (stream
, _("\
303 -T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
304 fprintf (stream
, _("\
305 -r, --reloc Display the relocation entries in the file\n"));
306 fprintf (stream
, _("\
307 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
308 fprintf (stream
, _("\
309 @<file> Read options from <file>\n"));
310 fprintf (stream
, _("\
311 -v, --version Display this program's version number\n"));
312 fprintf (stream
, _("\
313 -i, --info List object formats and architectures supported\n"));
314 fprintf (stream
, _("\
315 -H, --help Display this information\n"));
319 const struct objdump_private_desc
* const *desc
;
321 fprintf (stream
, _("\n The following switches are optional:\n"));
322 fprintf (stream
, _("\
323 -b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
324 fprintf (stream
, _("\
325 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
326 fprintf (stream
, _("\
327 -j, --section=NAME Only display information for section NAME\n"));
328 fprintf (stream
, _("\
329 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
330 fprintf (stream
, _("\
331 -EB --endian=big Assume big endian format when disassembling\n"));
332 fprintf (stream
, _("\
333 -EL --endian=little Assume little endian format when disassembling\n"));
334 fprintf (stream
, _("\
335 --file-start-context Include context from start of file (with -S)\n"));
336 fprintf (stream
, _("\
337 -I, --include=DIR Add DIR to search list for source files\n"));
338 fprintf (stream
, _("\
339 -l, --line-numbers Include line numbers and filenames in output\n"));
340 fprintf (stream
, _("\
341 -F, --file-offsets Include file offsets when displaying information\n"));
342 fprintf (stream
, _("\
343 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n"));
344 display_demangler_styles (stream
, _("\
346 fprintf (stream
, _("\
347 --recurse-limit Enable a limit on recursion whilst demangling\n\
349 fprintf (stream
, _("\
350 --no-recurse-limit Disable a limit on recursion whilst demangling\n"));
351 fprintf (stream
, _("\
352 -w, --wide Format output for more than 80 columns\n"));
353 fprintf (stream
, _("\
354 -U[d|l|i|x|e|h] Controls the display of UTF-8 unicode characters\n\
355 --unicode=[default|locale|invalid|hex|escape|highlight]\n"));
356 fprintf (stream
, _("\
357 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
358 fprintf (stream
, _("\
359 --start-address=ADDR Only process data whose address is >= ADDR\n"));
360 fprintf (stream
, _("\
361 --stop-address=ADDR Only process data whose address is < ADDR\n"));
362 fprintf (stream
, _("\
363 --no-addresses Do not print address alongside disassembly\n"));
364 fprintf (stream
, _("\
365 --prefix-addresses Print complete address alongside disassembly\n"));
366 fprintf (stream
, _("\
367 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
368 fprintf (stream
, _("\
369 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
370 fprintf (stream
, _("\
371 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
372 fprintf (stream
, _("\
373 --special-syms Include special symbols in symbol dumps\n"));
374 fprintf (stream
, _("\
375 --inlines Print all inlines for source line (with -l)\n"));
376 fprintf (stream
, _("\
377 --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
378 fprintf (stream
, _("\
379 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
380 fprintf (stream
, _("\
381 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
382 fprintf (stream
, _("\
383 --dwarf-start=N Display DIEs starting at offset N\n"));
384 fprintf (stream
, _("\
385 --dwarf-check Make additional dwarf consistency checks.\n"));
387 fprintf (stream
, _("\
388 --ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
390 fprintf (stream
, _("\
391 --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
392 fprintf (stream
, _("\
393 --visualize-jumps=color Use colors in the ASCII art\n"));
394 fprintf (stream
, _("\
395 --visualize-jumps=extended-color\n\
396 Use extended 8-bit color codes\n"));
397 fprintf (stream
, _("\
398 --visualize-jumps=off Disable jump visualization\n\n"));
400 list_supported_targets (program_name
, stream
);
401 list_supported_architectures (program_name
, stream
);
403 disassembler_usage (stream
);
405 if (objdump_private_vectors
[0] != NULL
)
408 _("\nOptions supported for -P/--private switch:\n"));
409 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
410 (*desc
)->help (stream
);
413 if (REPORT_BUGS_TO
[0] && status
== 0)
414 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
418 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
422 OPTION_START_ADDRESS
,
432 OPTION_RECURSE_LIMIT
,
433 OPTION_NO_RECURSE_LIMIT
,
435 OPTION_SOURCE_COMMENT
,
440 OPTION_VISUALIZE_JUMPS
443 static struct option long_options
[]=
445 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
446 {"all-headers", no_argument
, NULL
, 'x'},
447 {"architecture", required_argument
, NULL
, 'm'},
448 {"archive-headers", no_argument
, NULL
, 'a'},
450 {"ctf", optional_argument
, NULL
, OPTION_CTF
},
451 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
453 {"debugging", no_argument
, NULL
, 'g'},
454 {"debugging-tags", no_argument
, NULL
, 'e'},
455 {"demangle", optional_argument
, NULL
, 'C'},
456 {"disassemble", optional_argument
, NULL
, 'd'},
457 {"disassemble-all", no_argument
, NULL
, 'D'},
458 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
459 {"disassembler-options", required_argument
, NULL
, 'M'},
460 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
461 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
462 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
463 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
464 {"dynamic-reloc", no_argument
, NULL
, 'R'},
465 {"dynamic-syms", no_argument
, NULL
, 'T'},
466 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
467 {"file-headers", no_argument
, NULL
, 'f'},
468 {"file-offsets", no_argument
, NULL
, 'F'},
469 {"file-start-context", no_argument
, &file_start_context
, 1},
470 {"full-contents", no_argument
, NULL
, 's'},
471 {"headers", no_argument
, NULL
, 'h'},
472 {"help", no_argument
, NULL
, 'H'},
473 {"include", required_argument
, NULL
, 'I'},
474 {"info", no_argument
, NULL
, 'i'},
475 {"inlines", no_argument
, 0, OPTION_INLINES
},
476 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
477 {"line-numbers", no_argument
, NULL
, 'l'},
478 {"no-addresses", no_argument
, &no_addresses
, 1},
479 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
480 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
481 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
482 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
483 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
484 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
485 {"private", required_argument
, NULL
, 'P'},
486 {"private-headers", no_argument
, NULL
, 'p'},
487 {"process-links", no_argument
, &process_links
, true},
488 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
489 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
490 {"reloc", no_argument
, NULL
, 'r'},
491 {"section", required_argument
, NULL
, 'j'},
492 {"section-headers", no_argument
, NULL
, 'h'},
493 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
494 {"source", no_argument
, NULL
, 'S'},
495 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
496 {"special-syms", no_argument
, &dump_special_syms
, 1},
497 {"stabs", no_argument
, NULL
, 'G'},
498 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
499 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
500 {"syms", no_argument
, NULL
, 't'},
501 {"target", required_argument
, NULL
, 'b'},
502 {"unicode", required_argument
, NULL
, 'U'},
503 {"version", no_argument
, NULL
, 'V'},
504 {"visualize-jumps", optional_argument
, 0, OPTION_VISUALIZE_JUMPS
},
505 {"wide", no_argument
, NULL
, 'w'},
506 {NULL
, no_argument
, NULL
, 0}
510 nonfatal (const char *msg
)
516 /* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
517 The conversion format is controlled by the unicode_display variable.
518 Returns the number of characters added to OUT.
519 Returns the number of bytes consumed from IN in CONSUMED.
520 Always consumes at least one byte and displays at least one character. */
523 display_utf8 (const unsigned char * in
, char * out
, unsigned int * consumed
)
525 char * orig_out
= out
;
526 unsigned int nchars
= 0;
529 if (unicode_display
== unicode_default
)
535 if ((in
[1] & 0xc0) != 0x80)
538 if ((in
[0] & 0x20) == 0)
544 if ((in
[2] & 0xc0) != 0x80)
547 if ((in
[0] & 0x10) == 0)
553 if ((in
[3] & 0xc0) != 0x80)
559 switch (unicode_display
)
562 /* Copy the bytes into the output buffer as is. */
563 memcpy (out
, in
, nchars
);
567 case unicode_invalid
:
569 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '<' : '{');
570 out
+= sprintf (out
, "0x");
571 for (j
= 0; j
< nchars
; j
++)
572 out
+= sprintf (out
, "%02x", in
[j
]);
573 out
+= sprintf (out
, "%c", unicode_display
== unicode_hex
? '>' : '}');
576 case unicode_highlight
:
578 out
+= sprintf (out
, "\x1B[31;47m"); /* Red. */
584 out
+= sprintf (out
, "\\u%02x%02x",
585 ((in
[0] & 0x1c) >> 2),
586 ((in
[0] & 0x03) << 6) | (in
[1] & 0x3f));
590 out
+= sprintf (out
, "\\u%02x%02x",
591 ((in
[0] & 0x0f) << 4) | ((in
[1] & 0x3c) >> 2),
592 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3f)));
596 out
+= sprintf (out
, "\\u%02x%02x%02x",
597 ((in
[0] & 0x07) << 6) | ((in
[1] & 0x3c) >> 2),
598 ((in
[1] & 0x03) << 6) | ((in
[2] & 0x3c) >> 2),
599 ((in
[2] & 0x03) << 6) | ((in
[3] & 0x3f)));
606 if (unicode_display
== unicode_highlight
&& isatty (1))
607 out
+= sprintf (out
, "\033[0m"); /* Default colour. */
616 return out
- orig_out
;
619 /* Not a valid UTF-8 sequence. */
625 /* Returns a version of IN with any control characters
626 replaced by escape sequences. Uses a static buffer
629 If unicode display is enabled, then also handles the
630 conversion of unicode characters. */
633 sanitize_string (const char * in
)
635 static char * buffer
= NULL
;
636 static size_t buffer_len
= 0;
637 const char * original
= in
;
644 /* See if any conversion is necessary. In the majority
645 of cases it will not be needed. */
648 unsigned char c
= *in
++;
656 if (unicode_display
!= unicode_default
&& c
>= 0xc0)
661 /* Copy the input, translating as needed. */
663 if (buffer_len
< (strlen (in
) * 9))
665 free ((void *) buffer
);
666 buffer_len
= strlen (in
) * 9;
667 buffer
= xmalloc (buffer_len
+ 1);
673 unsigned char c
= *in
++;
683 else if (unicode_display
!= unicode_default
&& c
>= 0xc0)
685 unsigned int num_consumed
;
687 out
+= display_utf8 ((const unsigned char *)(in
- 1), out
, & num_consumed
);
688 in
+= num_consumed
- 1;
700 /* Returns TRUE if the specified section should be dumped. */
703 process_section_p (asection
* section
)
707 if (only_list
== NULL
)
710 for (only
= only_list
; only
; only
= only
->next
)
711 if (strcmp (only
->name
, section
->name
) == 0)
720 /* Add an entry to the 'only' list. */
723 add_only (char * name
)
727 /* First check to make sure that we do not
728 already have an entry for this name. */
729 for (only
= only_list
; only
; only
= only
->next
)
730 if (strcmp (only
->name
, name
) == 0)
733 only
= xmalloc (sizeof * only
);
736 only
->next
= only_list
;
740 /* Release the memory used by the 'only' list.
741 PR 11225: Issue a warning message for unseen sections.
742 Only do this if none of the sections were seen. This is mainly to support
743 tools like the GAS testsuite where an object file is dumped with a list of
744 generic section names known to be present in a range of different file
748 free_only_list (void)
750 bool at_least_one_seen
= false;
754 if (only_list
== NULL
)
757 for (only
= only_list
; only
; only
= only
->next
)
760 at_least_one_seen
= true;
764 for (only
= only_list
; only
; only
= next
)
766 if (! at_least_one_seen
)
768 non_fatal (_("section '%s' mentioned in a -j option, "
769 "but not found in any input file"),
780 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
783 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
784 int longest_section_name
= *((int *) data
);
786 /* Ignore linker created section. See elfNN_ia64_object_p in
788 if (section
->flags
& SEC_LINKER_CREATED
)
791 /* PR 10413: Skip sections that we are ignoring. */
792 if (! process_section_p (section
))
795 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
796 sanitize_string (bfd_section_name (section
)),
797 (unsigned long) bfd_section_size (section
) / opb
);
798 bfd_printf_vma (abfd
, bfd_section_vma (section
));
800 bfd_printf_vma (abfd
, section
->lma
);
801 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
802 bfd_section_alignment (section
));
808 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
810 PF (SEC_HAS_CONTENTS
, "CONTENTS");
811 PF (SEC_ALLOC
, "ALLOC");
812 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
813 PF (SEC_LOAD
, "LOAD");
814 PF (SEC_RELOC
, "RELOC");
815 PF (SEC_READONLY
, "READONLY");
816 PF (SEC_CODE
, "CODE");
817 PF (SEC_DATA
, "DATA");
819 PF (SEC_DEBUGGING
, "DEBUGGING");
820 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
821 PF (SEC_EXCLUDE
, "EXCLUDE");
822 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
823 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
825 PF (SEC_TIC54X_BLOCK
, "BLOCK");
826 PF (SEC_TIC54X_CLINK
, "CLINK");
828 PF (SEC_SMALL_DATA
, "SMALL_DATA");
829 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
831 PF (SEC_COFF_SHARED
, "SHARED");
832 PF (SEC_COFF_NOREAD
, "NOREAD");
834 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
836 PF (SEC_ELF_OCTETS
, "OCTETS");
837 PF (SEC_ELF_PURECODE
, "PURECODE");
839 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
840 PF (SEC_GROUP
, "GROUP");
841 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
843 PF (SEC_MEP_VLIW
, "VLIW");
846 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
849 struct coff_comdat_info
*comdat
;
851 switch (section
->flags
& SEC_LINK_DUPLICATES
)
855 case SEC_LINK_DUPLICATES_DISCARD
:
856 ls
= "LINK_ONCE_DISCARD";
858 case SEC_LINK_DUPLICATES_ONE_ONLY
:
859 ls
= "LINK_ONCE_ONE_ONLY";
861 case SEC_LINK_DUPLICATES_SAME_SIZE
:
862 ls
= "LINK_ONCE_SAME_SIZE";
864 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
865 ls
= "LINK_ONCE_SAME_CONTENTS";
868 printf ("%s%s", comma
, ls
);
870 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
872 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
881 /* Called on each SECTION in ABFD, update the int variable pointed to by
882 DATA which contains the string length of the longest section name. */
885 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
886 asection
*section
, void *data
)
888 int *longest_so_far
= (int *) data
;
892 /* Ignore linker created section. */
893 if (section
->flags
& SEC_LINKER_CREATED
)
896 /* Skip sections that we are ignoring. */
897 if (! process_section_p (section
))
900 name
= bfd_section_name (section
);
901 len
= (int) strlen (name
);
902 if (len
> *longest_so_far
)
903 *longest_so_far
= len
;
907 dump_headers (bfd
*abfd
)
909 /* The default width of 13 is just an arbitrary choice. */
910 int max_section_name_length
= 13;
916 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
917 if (bfd_get_arch_size (abfd
) == 32)
923 printf (_("Sections:\n"));
926 bfd_map_over_sections (abfd
, find_longest_section_name
,
927 &max_section_name_length
);
929 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
930 max_section_name_length
, "Name",
931 bfd_vma_width
, "VMA",
932 bfd_vma_width
, "LMA");
935 printf (_(" Flags"));
938 bfd_map_over_sections (abfd
, dump_section_header
,
939 &max_section_name_length
);
943 slurp_symtab (bfd
*abfd
)
948 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
954 storage
= bfd_get_symtab_upper_bound (abfd
);
957 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
958 bfd_fatal (_("error message was"));
963 off_t filesize
= bfd_get_file_size (abfd
);
967 && filesize
< storage
968 /* The MMO file format supports its own special compression
969 technique, so its sections can be larger than the file size. */
970 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
972 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
973 _("error: symbol table size (%#lx) "
974 "is larger than filesize (%#lx)"),
975 storage
, (long) filesize
);
981 sy
= (asymbol
**) xmalloc (storage
);
984 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
986 bfd_fatal (bfd_get_filename (abfd
));
990 /* Read in the dynamic symbols. */
993 slurp_dynamic_symtab (bfd
*abfd
)
998 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1001 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
1003 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
1009 bfd_fatal (bfd_get_filename (abfd
));
1013 sy
= (asymbol
**) xmalloc (storage
);
1015 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
1016 if (dynsymcount
< 0)
1017 bfd_fatal (bfd_get_filename (abfd
));
1021 /* Some symbol names are significant and should be kept in the
1022 table of sorted symbol names, even if they are marked as
1023 debugging/section symbols. */
1026 is_significant_symbol_name (const char * name
)
1028 return startswith (name
, ".plt") || startswith (name
, ".got");
1031 /* Filter out (in place) symbols that are useless for disassembly.
1032 COUNT is the number of elements in SYMBOLS.
1033 Return the number of useful symbols. */
1036 remove_useless_symbols (asymbol
**symbols
, long count
)
1038 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
1040 while (--count
>= 0)
1042 asymbol
*sym
= *in_ptr
++;
1044 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
1046 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
1047 && ! is_significant_symbol_name (sym
->name
))
1049 if (bfd_is_und_section (sym
->section
)
1050 || bfd_is_com_section (sym
->section
))
1055 return out_ptr
- symbols
;
1058 static const asection
*compare_section
;
1060 /* Sort symbols into value order. */
1063 compare_symbols (const void *ap
, const void *bp
)
1065 const asymbol
*a
= * (const asymbol
**) ap
;
1066 const asymbol
*b
= * (const asymbol
**) bp
;
1071 bool as
, af
, bs
, bf
;
1075 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
1077 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
1080 /* Prefer symbols from the section currently being disassembled.
1081 Don't sort symbols from other sections by section, since there
1082 isn't much reason to prefer one section over another otherwise.
1083 See sym_ok comment for why we compare by section name. */
1084 as
= strcmp (compare_section
->name
, a
->section
->name
) == 0;
1085 bs
= strcmp (compare_section
->name
, b
->section
->name
) == 0;
1091 an
= bfd_asymbol_name (a
);
1092 bn
= bfd_asymbol_name (b
);
1096 /* The symbols gnu_compiled and gcc2_compiled convey no real
1097 information, so put them after other symbols with the same value. */
1098 af
= (strstr (an
, "gnu_compiled") != NULL
1099 || strstr (an
, "gcc2_compiled") != NULL
);
1100 bf
= (strstr (bn
, "gnu_compiled") != NULL
1101 || strstr (bn
, "gcc2_compiled") != NULL
);
1108 /* We use a heuristic for the file name, to try to sort it after
1109 more useful symbols. It may not work on non Unix systems, but it
1110 doesn't really matter; the only difference is precisely which
1111 symbol names get printed. */
1113 #define file_symbol(s, sn, snl) \
1114 (((s)->flags & BSF_FILE) != 0 \
1116 && (sn)[(snl) - 2] == '.' \
1117 && ((sn)[(snl) - 1] == 'o' \
1118 || (sn)[(snl) - 1] == 'a')))
1120 af
= file_symbol (a
, an
, anl
);
1121 bf
= file_symbol (b
, bn
, bnl
);
1128 /* Sort function and object symbols before global symbols before
1129 local symbols before section symbols before debugging symbols. */
1134 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
1136 if ((aflags
& BSF_DEBUGGING
) != 0)
1141 if ((aflags
& BSF_SECTION_SYM
) != (bflags
& BSF_SECTION_SYM
))
1143 if ((aflags
& BSF_SECTION_SYM
) != 0)
1148 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
1150 if ((aflags
& BSF_FUNCTION
) != 0)
1155 if ((aflags
& BSF_OBJECT
) != (bflags
& BSF_OBJECT
))
1157 if ((aflags
& BSF_OBJECT
) != 0)
1162 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
1164 if ((aflags
& BSF_LOCAL
) != 0)
1169 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
1171 if ((aflags
& BSF_GLOBAL
) != 0)
1177 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
1178 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
1183 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1184 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
1186 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1187 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
1189 return asz
> bsz
? -1 : 1;
1192 /* Symbols that start with '.' might be section names, so sort them
1193 after symbols that don't start with '.'. */
1194 if (an
[0] == '.' && bn
[0] != '.')
1196 if (an
[0] != '.' && bn
[0] == '.')
1199 /* Finally, if we can't distinguish them in any other way, try to
1200 get consistent results by sorting the symbols by name. */
1201 return strcmp (an
, bn
);
1204 /* Sort relocs into address order. */
1207 compare_relocs (const void *ap
, const void *bp
)
1209 const arelent
*a
= * (const arelent
**) ap
;
1210 const arelent
*b
= * (const arelent
**) bp
;
1212 if (a
->address
> b
->address
)
1214 else if (a
->address
< b
->address
)
1217 /* So that associated relocations tied to the same address show up
1218 in the correct order, we don't do any further sorting. */
1227 /* Print an address (VMA) to the output stream in INFO.
1228 If SKIP_ZEROES is TRUE, omit leading zeroes. */
1231 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
1236 struct objdump_disasm_info
*aux
;
1238 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1239 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
1244 for (p
= buf
; *p
== '0'; ++p
)
1249 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
1252 /* Print the name of a symbol. */
1255 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
1259 const char *name
, *version_string
= NULL
;
1260 bool hidden
= false;
1263 name
= bfd_asymbol_name (sym
);
1264 if (do_demangle
&& name
[0] != '\0')
1266 /* Demangle the name. */
1267 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
1272 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1273 version_string
= bfd_get_symbol_version_string (abfd
, sym
, true,
1276 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1279 name
= sanitize_string (name
);
1283 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1284 if (version_string
&& *version_string
!= '\0')
1285 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1290 printf ("%s", name
);
1291 if (version_string
&& *version_string
!= '\0')
1292 printf (hidden
? "@%s" : "@@%s", version_string
);
1300 sym_ok (bool want_section
,
1301 bfd
*abfd ATTRIBUTE_UNUSED
,
1304 struct disassemble_info
*inf
)
1308 /* NB: An object file can have different sections with the same
1309 section name. Compare compare section pointers if they have
1311 if (sorted_syms
[place
]->section
->owner
== sec
->owner
1312 && sorted_syms
[place
]->section
!= sec
)
1315 /* Note - we cannot just compare section pointers because they could
1316 be different, but the same... Ie the symbol that we are trying to
1317 find could have come from a separate debug info file. Under such
1318 circumstances the symbol will be associated with a section in the
1319 debug info file, whilst the section we want is in a normal file.
1320 So the section pointers will be different, but the section names
1321 will be the same. */
1322 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1323 bfd_section_name (sec
)) != 0)
1327 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1330 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1331 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1332 require the symbol to be in the section. Returns NULL if there is no
1333 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1334 of the symbol in sorted_syms. */
1337 find_symbol_for_address (bfd_vma vma
,
1338 struct disassemble_info
*inf
,
1341 /* @@ Would it speed things up to cache the last two symbols returned,
1342 and maybe their address ranges? For many processors, only one memory
1343 operand can be present at a time, so the 2-entry cache wouldn't be
1344 constantly churned by code doing heavy memory accesses. */
1346 /* Indices in `sorted_syms'. */
1348 long max_count
= sorted_symcount
;
1350 struct objdump_disasm_info
*aux
;
1357 if (sorted_symcount
< 1)
1360 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1363 opb
= inf
->octets_per_byte
;
1365 /* Perform a binary search looking for the closest symbol to the
1366 required value. We are searching the range (min, max_count]. */
1367 while (min
+ 1 < max_count
)
1371 thisplace
= (max_count
+ min
) / 2;
1372 sym
= sorted_syms
[thisplace
];
1374 if (bfd_asymbol_value (sym
) > vma
)
1375 max_count
= thisplace
;
1376 else if (bfd_asymbol_value (sym
) < vma
)
1385 /* The symbol we want is now in min, the low end of the range we
1386 were searching. If there are several symbols with the same
1387 value, we want the first one. */
1389 while (thisplace
> 0
1390 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1391 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
1394 /* Prefer a symbol in the current section if we have multple symbols
1395 with the same value, as can occur with overlays or zero size
1398 while (min
< max_count
1399 && (bfd_asymbol_value (sorted_syms
[min
])
1400 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1402 if (sym_ok (true, abfd
, min
, sec
, inf
))
1409 return sorted_syms
[thisplace
];
1414 /* If the file is relocatable, and the symbol could be from this
1415 section, prefer a symbol from this section over symbols from
1416 others, even if the other symbol's value might be closer.
1418 Note that this may be wrong for some symbol references if the
1419 sections have overlapping memory ranges, but in that case there's
1420 no way to tell what's desired without looking at the relocation
1423 Also give the target a chance to reject symbols. */
1424 want_section
= (aux
->require_sec
1425 || ((abfd
->flags
& HAS_RELOC
) != 0
1426 && vma
>= bfd_section_vma (sec
)
1427 && vma
< (bfd_section_vma (sec
)
1428 + bfd_section_size (sec
) / opb
)));
1430 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1433 long newplace
= sorted_symcount
;
1435 for (i
= min
- 1; i
>= 0; i
--)
1437 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1439 if (newplace
== sorted_symcount
)
1442 if (bfd_asymbol_value (sorted_syms
[i
])
1443 != bfd_asymbol_value (sorted_syms
[newplace
]))
1446 /* Remember this symbol and keep searching until we reach
1447 an earlier address. */
1452 if (newplace
!= sorted_symcount
)
1453 thisplace
= newplace
;
1456 /* We didn't find a good symbol with a smaller value.
1457 Look for one with a larger value. */
1458 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1460 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1468 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1469 /* There is no suitable symbol. */
1473 /* If we have not found an exact match for the specified address
1474 and we have dynamic relocations available, then we can produce
1475 a better result by matching a relocation to the address and
1476 using the symbol associated with that relocation. */
1477 rel_count
= inf
->dynrelcount
;
1479 && sorted_syms
[thisplace
]->value
!= vma
1481 && inf
->dynrelbuf
!= NULL
1482 && inf
->dynrelbuf
[0]->address
<= vma
1483 && inf
->dynrelbuf
[rel_count
- 1]->address
>= vma
1484 /* If we have matched a synthetic symbol, then stick with that. */
1485 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1488 arelent
** rel_high
;
1490 rel_low
= inf
->dynrelbuf
;
1491 rel_high
= rel_low
+ rel_count
- 1;
1492 while (rel_low
<= rel_high
)
1494 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1495 arelent
* rel
= *rel_mid
;
1497 if (rel
->address
== vma
)
1499 /* Absolute relocations do not provide a more helpful
1500 symbolic address. Find a non-absolute relocation
1501 with the same address. */
1502 arelent
**rel_vma
= rel_mid
;
1504 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1508 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1512 if (rel
->sym_ptr_ptr
!= NULL
1513 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1516 * place
= thisplace
;
1517 return * rel
->sym_ptr_ptr
;
1523 if (vma
< rel
->address
)
1525 else if (vma
>= rel_mid
[1]->address
)
1526 rel_low
= rel_mid
+ 1;
1535 return sorted_syms
[thisplace
];
1538 /* Print an address and the offset to the nearest symbol. */
1541 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1542 bfd_vma vma
, struct disassemble_info
*inf
,
1547 objdump_print_value (vma
, inf
, skip_zeroes
);
1548 (*inf
->fprintf_func
) (inf
->stream
, " ");
1555 (*inf
->fprintf_func
) (inf
->stream
, "<%s",
1556 sanitize_string (bfd_section_name (sec
)));
1557 secaddr
= bfd_section_vma (sec
);
1560 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1561 objdump_print_value (secaddr
- vma
, inf
, true);
1563 else if (vma
> secaddr
)
1565 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1566 objdump_print_value (vma
- secaddr
, inf
, true);
1568 (*inf
->fprintf_func
) (inf
->stream
, ">");
1572 (*inf
->fprintf_func
) (inf
->stream
, "<");
1574 objdump_print_symname (abfd
, inf
, sym
);
1576 if (bfd_asymbol_value (sym
) == vma
)
1578 /* Undefined symbols in an executables and dynamic objects do not have
1579 a value associated with them, so it does not make sense to display
1580 an offset relative to them. Normally we would not be provided with
1581 this kind of symbol, but the target backend might choose to do so,
1582 and the code in find_symbol_for_address might return an as yet
1583 unresolved symbol associated with a dynamic reloc. */
1584 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1585 && bfd_is_und_section (sym
->section
))
1587 else if (bfd_asymbol_value (sym
) > vma
)
1589 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1590 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, true);
1592 else if (vma
> bfd_asymbol_value (sym
))
1594 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1595 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, true);
1598 (*inf
->fprintf_func
) (inf
->stream
, ">");
1601 if (display_file_offsets
)
1602 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1603 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1606 /* Print an address (VMA), symbolically if possible.
1607 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1610 objdump_print_addr (bfd_vma vma
,
1611 struct disassemble_info
*inf
,
1614 struct objdump_disasm_info
*aux
;
1615 asymbol
*sym
= NULL
;
1616 bool skip_find
= false;
1618 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1620 if (sorted_symcount
< 1)
1624 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1625 objdump_print_value (vma
, inf
, skip_zeroes
);
1628 if (display_file_offsets
)
1629 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1630 (long int) (inf
->section
->filepos
1631 + (vma
- inf
->section
->vma
)));
1635 if (aux
->reloc
!= NULL
1636 && aux
->reloc
->sym_ptr_ptr
!= NULL
1637 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1639 sym
= * aux
->reloc
->sym_ptr_ptr
;
1641 /* Adjust the vma to the reloc. */
1642 vma
+= bfd_asymbol_value (sym
);
1644 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1649 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1651 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1655 /* Print VMA to INFO. This function is passed to the disassembler
1659 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1661 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1664 /* Determine if the given address has a symbol associated with it. */
1667 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1671 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1672 if (sym
!= NULL
&& bfd_asymbol_value (sym
) == vma
)
1678 /* Hold the last function name and the last line number we displayed
1679 in a disassembly. */
1681 static char *prev_functionname
;
1682 static unsigned int prev_line
;
1683 static unsigned int prev_discriminator
;
1685 /* We keep a list of all files that we have seen when doing a
1686 disassembly with source, so that we know how much of the file to
1687 display. This can be important for inlined functions. */
1689 struct print_file_list
1691 struct print_file_list
*next
;
1692 const char *filename
;
1693 const char *modname
;
1696 const char **linemap
;
1699 unsigned max_printed
;
1703 static struct print_file_list
*print_files
;
1705 /* The number of preceding context lines to show when we start
1706 displaying a file for the first time. */
1708 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1710 /* Read a complete file into memory. */
1713 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1716 int ps
= getpagesize ();
1720 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1724 if (fstat (fd
, fst
) < 0)
1729 *size
= fst
->st_size
;
1731 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1732 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1733 if (map
!= (char *) -1L)
1739 map
= (const char *) malloc (*size
);
1740 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1742 free ((void *) map
);
1749 #define line_map_decrease 5
1751 /* Precompute array of lines for a mapped file. */
1753 static const char **
1754 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1756 const char *p
, *lstart
, *end
;
1757 int chars_per_line
= 45; /* First iteration will use 40. */
1758 unsigned int lineno
;
1759 const char **linemap
= NULL
;
1760 unsigned long line_map_size
= 0;
1766 for (p
= map
; p
< end
; p
++)
1770 if (p
+ 1 < end
&& p
[1] == '\r')
1773 else if (*p
== '\r')
1775 if (p
+ 1 < end
&& p
[1] == '\n')
1781 /* End of line found. */
1783 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1785 unsigned long newsize
;
1787 chars_per_line
-= line_map_decrease
;
1788 if (chars_per_line
<= 1)
1790 line_map_size
= size
/ chars_per_line
+ 1;
1791 if (line_map_size
< lineno
+ 1)
1792 line_map_size
= lineno
+ 1;
1793 newsize
= line_map_size
* sizeof (char *);
1794 linemap
= (const char **) xrealloc (linemap
, newsize
);
1797 linemap
[lineno
++] = lstart
;
1805 /* Tries to open MODNAME, and if successful adds a node to print_files
1806 linked list and returns that node. Returns NULL on failure. */
1808 static struct print_file_list
*
1809 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1811 struct print_file_list
*p
;
1813 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1815 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1822 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1825 p
->filename
= origname
;
1826 p
->modname
= modname
;
1827 p
->next
= print_files
;
1833 /* If the source file, as described in the symtab, is not found
1834 try to locate it in one of the paths specified with -I
1835 If found, add location to print_files linked list. */
1837 static struct print_file_list
*
1838 update_source_path (const char *filename
, bfd
*abfd
)
1840 struct print_file_list
*p
;
1845 p
= try_print_file_open (filename
, filename
, &fst
);
1848 if (include_path_count
== 0)
1851 /* Get the name of the file. */
1852 fname
= lbasename (filename
);
1854 /* If file exists under a new path, we need to add it to the list
1855 so that show_line knows about it. */
1856 for (i
= 0; i
< include_path_count
; i
++)
1858 char *modname
= concat (include_paths
[i
], "/", fname
,
1861 p
= try_print_file_open (filename
, modname
, &fst
);
1871 long mtime
= bfd_get_mtime (abfd
);
1873 if (fst
.st_mtime
> mtime
)
1874 warn (_("source file %s is more recent than object file\n"),
1881 /* Print a source file line. */
1884 print_line (struct print_file_list
*p
, unsigned int linenum
)
1890 if (linenum
>= p
->maxline
)
1892 l
= p
->linemap
[linenum
];
1893 if (source_comment
!= NULL
&& strlen (l
) > 0)
1894 printf ("%s", source_comment
);
1895 len
= strcspn (l
, "\n\r");
1896 /* Test fwrite return value to quiet glibc warning. */
1897 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1901 /* Print a range of source code lines. */
1904 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1908 while (start
<= end
)
1910 print_line (p
, start
);
1915 /* Show the line number, or the source line, in a disassembly
1919 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1921 const char *filename
;
1922 const char *functionname
;
1923 unsigned int linenumber
;
1924 unsigned int discriminator
;
1928 if (! with_line_numbers
&& ! with_source_code
)
1931 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1932 &filename
, &functionname
,
1933 &linenumber
, &discriminator
))
1936 if (filename
!= NULL
&& *filename
== '\0')
1938 if (functionname
!= NULL
&& *functionname
== '\0')
1939 functionname
= NULL
;
1942 && IS_ABSOLUTE_PATH (filename
)
1946 const char *fname
= filename
;
1948 path
= xmalloc (prefix_length
+ 1 + strlen (filename
));
1951 memcpy (path
, prefix
, prefix_length
);
1952 path_up
= path
+ prefix_length
;
1954 /* Build relocated filename, stripping off leading directories
1955 from the initial filename if requested. */
1956 if (prefix_strip
> 0)
1961 /* Skip selected directory levels. */
1962 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1963 if (IS_DIR_SEPARATOR (*s
))
1970 /* Update complete filename. */
1971 strcpy (path_up
, fname
);
1979 if (with_line_numbers
)
1981 if (functionname
!= NULL
1982 && (prev_functionname
== NULL
1983 || strcmp (functionname
, prev_functionname
) != 0))
1985 char *demangle_alloc
= NULL
;
1986 if (do_demangle
&& functionname
[0] != '\0')
1988 /* Demangle the name. */
1989 demangle_alloc
= bfd_demangle (abfd
, functionname
,
1993 /* Demangling adds trailing parens, so don't print those. */
1994 if (demangle_alloc
!= NULL
)
1995 printf ("%s:\n", sanitize_string (demangle_alloc
));
1997 printf ("%s():\n", sanitize_string (functionname
));
2000 free (demangle_alloc
);
2003 && (linenumber
!= prev_line
2004 || discriminator
!= prev_discriminator
))
2006 if (discriminator
> 0)
2007 printf ("%s:%u (discriminator %u)\n",
2008 filename
== NULL
? "???" : sanitize_string (filename
),
2009 linenumber
, discriminator
);
2011 printf ("%s:%u\n", filename
== NULL
2012 ? "???" : sanitize_string (filename
),
2017 const char *filename2
;
2018 const char *functionname2
;
2021 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
2024 printf ("inlined by %s:%u",
2025 sanitize_string (filename2
), line2
);
2026 printf (" (%s)\n", sanitize_string (functionname2
));
2031 if (with_source_code
2035 struct print_file_list
**pp
, *p
;
2038 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2039 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
2046 filename
= xstrdup (filename
);
2047 p
= update_source_path (filename
, abfd
);
2050 if (p
!= NULL
&& linenumber
!= p
->last_line
)
2052 if (file_start_context
&& p
->first
)
2056 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
2057 if (l
>= linenumber
)
2059 if (p
->max_printed
>= l
)
2061 if (p
->max_printed
< linenumber
)
2062 l
= p
->max_printed
+ 1;
2067 dump_lines (p
, l
, linenumber
);
2068 if (p
->max_printed
< linenumber
)
2069 p
->max_printed
= linenumber
;
2070 p
->last_line
= linenumber
;
2075 if (functionname
!= NULL
2076 && (prev_functionname
== NULL
2077 || strcmp (functionname
, prev_functionname
) != 0))
2079 if (prev_functionname
!= NULL
)
2080 free (prev_functionname
);
2081 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
2082 strcpy (prev_functionname
, functionname
);
2085 if (linenumber
> 0 && linenumber
!= prev_line
)
2086 prev_line
= linenumber
;
2088 if (discriminator
!= prev_discriminator
)
2089 prev_discriminator
= discriminator
;
2095 /* Pseudo FILE object for strings. */
2103 /* sprintf to a "stream". */
2105 static int ATTRIBUTE_PRINTF_2
2106 objdump_sprintf (SFILE
*f
, const char *format
, ...)
2113 size_t space
= f
->alloc
- f
->pos
;
2115 va_start (args
, format
);
2116 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
2122 f
->alloc
= (f
->alloc
+ n
) * 2;
2123 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
2130 /* Code for generating (colored) diagrams of control flow start and end
2133 /* Structure used to store the properties of a jump. */
2137 /* The next jump, or NULL if this is the last object. */
2138 struct jump_info
*next
;
2139 /* The previous jump, or NULL if this is the first object. */
2140 struct jump_info
*prev
;
2141 /* The start addresses of the jump. */
2144 /* The list of start addresses. */
2146 /* The number of elements. */
2148 /* The maximum number of elements that fit into the array. */
2151 /* The end address of the jump. */
2153 /* The drawing level of the jump. */
2157 /* Construct a jump object for a jump from start
2158 to end with the corresponding level. */
2160 static struct jump_info
*
2161 jump_info_new (bfd_vma start
, bfd_vma end
, int level
)
2163 struct jump_info
*result
= xmalloc (sizeof (struct jump_info
));
2165 result
->next
= NULL
;
2166 result
->prev
= NULL
;
2167 result
->start
.addresses
= xmalloc (sizeof (bfd_vma
*) * 2);
2168 result
->start
.addresses
[0] = start
;
2169 result
->start
.count
= 1;
2170 result
->start
.max_count
= 2;
2172 result
->level
= level
;
2177 /* Free a jump object and return the next object
2178 or NULL if this was the last one. */
2180 static struct jump_info
*
2181 jump_info_free (struct jump_info
*ji
)
2183 struct jump_info
*result
= NULL
;
2188 if (ji
->start
.addresses
)
2189 free (ji
->start
.addresses
);
2196 /* Get the smallest value of all start and end addresses. */
2199 jump_info_min_address (const struct jump_info
*ji
)
2201 bfd_vma min_address
= ji
->end
;
2204 for (i
= ji
->start
.count
; i
-- > 0;)
2205 if (ji
->start
.addresses
[i
] < min_address
)
2206 min_address
= ji
->start
.addresses
[i
];
2210 /* Get the largest value of all start and end addresses. */
2213 jump_info_max_address (const struct jump_info
*ji
)
2215 bfd_vma max_address
= ji
->end
;
2218 for (i
= ji
->start
.count
; i
-- > 0;)
2219 if (ji
->start
.addresses
[i
] > max_address
)
2220 max_address
= ji
->start
.addresses
[i
];
2224 /* Get the target address of a jump. */
2227 jump_info_end_address (const struct jump_info
*ji
)
2232 /* Test if an address is one of the start addresses of a jump. */
2235 jump_info_is_start_address (const struct jump_info
*ji
, bfd_vma address
)
2237 bool result
= false;
2240 for (i
= ji
->start
.count
; i
-- > 0;)
2241 if (address
== ji
->start
.addresses
[i
])
2250 /* Test if an address is the target address of a jump. */
2253 jump_info_is_end_address (const struct jump_info
*ji
, bfd_vma address
)
2255 return (address
== ji
->end
);
2258 /* Get the difference between the smallest and largest address of a jump. */
2261 jump_info_size (const struct jump_info
*ji
)
2263 return jump_info_max_address (ji
) - jump_info_min_address (ji
);
2266 /* Unlink a jump object from a list. */
2269 jump_info_unlink (struct jump_info
*node
,
2270 struct jump_info
**base
)
2273 node
->next
->prev
= node
->prev
;
2275 node
->prev
->next
= node
->next
;
2282 /* Insert unlinked jump info node into a list. */
2285 jump_info_insert (struct jump_info
*node
,
2286 struct jump_info
*target
,
2287 struct jump_info
**base
)
2289 node
->next
= target
;
2290 node
->prev
= target
->prev
;
2291 target
->prev
= node
;
2293 node
->prev
->next
= node
;
2298 /* Add unlinked node to the front of a list. */
2301 jump_info_add_front (struct jump_info
*node
,
2302 struct jump_info
**base
)
2306 node
->next
->prev
= node
;
2311 /* Move linked node to target position. */
2314 jump_info_move_linked (struct jump_info
*node
,
2315 struct jump_info
*target
,
2316 struct jump_info
**base
)
2319 jump_info_unlink (node
, base
);
2320 /* Insert node at target position. */
2321 jump_info_insert (node
, target
, base
);
2324 /* Test if two jumps intersect. */
2327 jump_info_intersect (const struct jump_info
*a
,
2328 const struct jump_info
*b
)
2330 return ((jump_info_max_address (a
) >= jump_info_min_address (b
))
2331 && (jump_info_min_address (a
) <= jump_info_max_address (b
)));
2334 /* Merge two compatible jump info objects. */
2337 jump_info_merge (struct jump_info
**base
)
2339 struct jump_info
*a
;
2341 for (a
= *base
; a
; a
= a
->next
)
2343 struct jump_info
*b
;
2345 for (b
= a
->next
; b
; b
= b
->next
)
2347 /* Merge both jumps into one. */
2348 if (a
->end
== b
->end
)
2350 /* Reallocate addresses. */
2351 size_t needed_size
= a
->start
.count
+ b
->start
.count
;
2354 if (needed_size
> a
->start
.max_count
)
2356 a
->start
.max_count
+= b
->start
.max_count
;
2357 a
->start
.addresses
=
2358 xrealloc (a
->start
.addresses
,
2359 a
->start
.max_count
* sizeof (bfd_vma
*));
2362 /* Append start addresses. */
2363 for (i
= 0; i
< b
->start
.count
; ++i
)
2364 a
->start
.addresses
[a
->start
.count
++] =
2365 b
->start
.addresses
[i
];
2367 /* Remove and delete jump. */
2368 struct jump_info
*tmp
= b
->prev
;
2369 jump_info_unlink (b
, base
);
2377 /* Sort jumps by their size and starting point using a stable
2378 minsort. This could be improved if sorting performance is
2379 an issue, for example by using mergesort. */
2382 jump_info_sort (struct jump_info
**base
)
2384 struct jump_info
*current_element
= *base
;
2386 while (current_element
)
2388 struct jump_info
*best_match
= current_element
;
2389 struct jump_info
*runner
= current_element
->next
;
2390 bfd_vma best_size
= jump_info_size (best_match
);
2394 bfd_vma runner_size
= jump_info_size (runner
);
2396 if ((runner_size
< best_size
)
2397 || ((runner_size
== best_size
)
2398 && (jump_info_min_address (runner
)
2399 < jump_info_min_address (best_match
))))
2401 best_match
= runner
;
2402 best_size
= runner_size
;
2405 runner
= runner
->next
;
2408 if (best_match
== current_element
)
2409 current_element
= current_element
->next
;
2411 jump_info_move_linked (best_match
, current_element
, base
);
2415 /* Visualize all jumps at a given address. */
2418 jump_info_visualize_address (bfd_vma address
,
2421 uint8_t *color_buffer
)
2423 struct jump_info
*ji
= detected_jumps
;
2424 size_t len
= (max_level
+ 1) * 3;
2426 /* Clear line buffer. */
2427 memset (line_buffer
, ' ', len
);
2428 memset (color_buffer
, 0, len
);
2430 /* Iterate over jumps and add their ASCII art. */
2433 /* Discard jumps that are never needed again. */
2434 if (jump_info_max_address (ji
) < address
)
2436 struct jump_info
*tmp
= ji
;
2439 jump_info_unlink (tmp
, &detected_jumps
);
2440 jump_info_free (tmp
);
2444 /* This jump intersects with the current address. */
2445 if (jump_info_min_address (ji
) <= address
)
2447 /* Hash target address to get an even
2448 distribution between all values. */
2449 bfd_vma hash_address
= jump_info_end_address (ji
);
2450 uint8_t color
= iterative_hash_object (hash_address
, 0);
2451 /* Fetch line offset. */
2452 int offset
= (max_level
- ji
->level
) * 3;
2454 /* Draw start line. */
2455 if (jump_info_is_start_address (ji
, address
))
2457 size_t i
= offset
+ 1;
2459 for (; i
< len
- 1; ++i
)
2460 if (line_buffer
[i
] == ' ')
2462 line_buffer
[i
] = '-';
2463 color_buffer
[i
] = color
;
2466 if (line_buffer
[i
] == ' ')
2468 line_buffer
[i
] = '-';
2469 color_buffer
[i
] = color
;
2471 else if (line_buffer
[i
] == '>')
2473 line_buffer
[i
] = 'X';
2474 color_buffer
[i
] = color
;
2477 if (line_buffer
[offset
] == ' ')
2479 if (address
<= ji
->end
)
2480 line_buffer
[offset
] =
2481 (jump_info_min_address (ji
) == address
) ? '/': '+';
2483 line_buffer
[offset
] =
2484 (jump_info_max_address (ji
) == address
) ? '\\': '+';
2485 color_buffer
[offset
] = color
;
2488 /* Draw jump target. */
2489 else if (jump_info_is_end_address (ji
, address
))
2491 size_t i
= offset
+ 1;
2493 for (; i
< len
- 1; ++i
)
2494 if (line_buffer
[i
] == ' ')
2496 line_buffer
[i
] = '-';
2497 color_buffer
[i
] = color
;
2500 if (line_buffer
[i
] == ' ')
2502 line_buffer
[i
] = '>';
2503 color_buffer
[i
] = color
;
2505 else if (line_buffer
[i
] == '-')
2507 line_buffer
[i
] = 'X';
2508 color_buffer
[i
] = color
;
2511 if (line_buffer
[offset
] == ' ')
2513 if (jump_info_min_address (ji
) < address
)
2514 line_buffer
[offset
] =
2515 (jump_info_max_address (ji
) > address
) ? '>' : '\\';
2517 line_buffer
[offset
] = '/';
2518 color_buffer
[offset
] = color
;
2521 /* Draw intermediate line segment. */
2522 else if (line_buffer
[offset
] == ' ')
2524 line_buffer
[offset
] = '|';
2525 color_buffer
[offset
] = color
;
2533 /* Clone of disassemble_bytes to detect jumps inside a function. */
2534 /* FIXME: is this correct? Can we strip it down even further? */
2536 static struct jump_info
*
2537 disassemble_jumps (struct disassemble_info
* inf
,
2538 disassembler_ftype disassemble_fn
,
2539 bfd_vma start_offset
,
2540 bfd_vma stop_offset
,
2543 arelent
** relppend
)
2545 struct objdump_disasm_info
*aux
;
2546 struct jump_info
*jumps
= NULL
;
2548 bfd_vma addr_offset
;
2549 unsigned int opb
= inf
->octets_per_byte
;
2553 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2554 section
= inf
->section
;
2557 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2560 inf
->insn_info_valid
= 0;
2561 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2562 inf
->stream
= &sfile
;
2564 addr_offset
= start_offset
;
2565 while (addr_offset
< stop_offset
)
2567 int previous_octets
;
2569 /* Remember the length of the previous instruction. */
2570 previous_octets
= octets
;
2574 inf
->bytes_per_line
= 0;
2575 inf
->bytes_per_chunk
= 0;
2576 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2577 | (wide_output
? WIDE_OUTPUT
: 0));
2579 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2581 if (inf
->disassembler_needs_relocs
2582 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2583 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2584 && *relppp
< relppend
)
2586 bfd_signed_vma distance_to_rel
;
2588 distance_to_rel
= (**relppp
)->address
- (rel_offset
+ addr_offset
);
2590 /* Check to see if the current reloc is associated with
2591 the instruction that we are about to disassemble. */
2592 if (distance_to_rel
== 0
2593 /* FIXME: This is wrong. We are trying to catch
2594 relocs that are addressed part way through the
2595 current instruction, as might happen with a packed
2596 VLIW instruction. Unfortunately we do not know the
2597 length of the current instruction since we have not
2598 disassembled it yet. Instead we take a guess based
2599 upon the length of the previous instruction. The
2600 proper solution is to have a new target-specific
2601 disassembler function which just returns the length
2602 of an instruction at a given address without trying
2603 to display its disassembly. */
2604 || (distance_to_rel
> 0
2605 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
2607 inf
->flags
|= INSN_HAS_RELOC
;
2611 if (! disassemble_all
2612 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2613 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2614 /* Set a stop_vma so that the disassembler will not read
2615 beyond the next symbol. We assume that symbols appear on
2616 the boundaries between instructions. We only do this when
2617 disassembling code of course, and when -D is in effect. */
2618 inf
->stop_vma
= section
->vma
+ stop_offset
;
2620 inf
->stop_offset
= stop_offset
;
2622 /* Extract jump information. */
2623 inf
->insn_info_valid
= 0;
2624 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2625 /* Test if a jump was detected. */
2626 if (inf
->insn_info_valid
2627 && ((inf
->insn_type
== dis_branch
)
2628 || (inf
->insn_type
== dis_condbranch
)
2629 || (inf
->insn_type
== dis_jsr
)
2630 || (inf
->insn_type
== dis_condjsr
))
2631 && (inf
->target
>= section
->vma
+ start_offset
)
2632 && (inf
->target
< section
->vma
+ stop_offset
))
2634 struct jump_info
*ji
=
2635 jump_info_new (section
->vma
+ addr_offset
, inf
->target
, -1);
2636 jump_info_add_front (ji
, &jumps
);
2641 addr_offset
+= octets
/ opb
;
2644 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2645 inf
->stream
= stdout
;
2647 free (sfile
.buffer
);
2650 jump_info_merge (&jumps
);
2651 /* Process jumps. */
2652 jump_info_sort (&jumps
);
2654 /* Group jumps by level. */
2655 struct jump_info
*last_jump
= jumps
;
2660 /* The last jump is part of the next group. */
2661 struct jump_info
*base
= last_jump
;
2662 /* Increment level. */
2663 base
->level
= ++max_level
;
2665 /* Find jumps that can be combined on the same
2666 level, with the largest jumps tested first.
2667 This has the advantage that large jumps are on
2668 lower levels and do not intersect with small
2669 jumps that get grouped on higher levels. */
2670 struct jump_info
*exchange_item
= last_jump
->next
;
2671 struct jump_info
*it
= exchange_item
;
2673 for (; it
; it
= it
->next
)
2675 /* Test if the jump intersects with any
2676 jump from current group. */
2678 struct jump_info
*it_collision
;
2680 for (it_collision
= base
;
2681 it_collision
!= exchange_item
;
2682 it_collision
= it_collision
->next
)
2684 /* This jump intersects so we leave it out. */
2685 if (jump_info_intersect (it_collision
, it
))
2692 /* Add jump to group. */
2695 /* Move current element to the front. */
2696 if (it
!= exchange_item
)
2698 struct jump_info
*save
= it
->prev
;
2699 jump_info_move_linked (it
, exchange_item
, &jumps
);
2705 last_jump
= exchange_item
;
2706 exchange_item
= exchange_item
->next
;
2708 last_jump
->level
= max_level
;
2712 /* Move to next group. */
2713 last_jump
= exchange_item
;
2719 /* The number of zeroes we want to see before we start skipping them.
2720 The number is arbitrarily chosen. */
2722 #define DEFAULT_SKIP_ZEROES 8
2724 /* The number of zeroes to skip at the end of a section. If the
2725 number of zeroes at the end is between SKIP_ZEROES_AT_END and
2726 SKIP_ZEROES, they will be disassembled. If there are fewer than
2727 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
2728 attempt to avoid disassembling zeroes inserted by section
2731 #define DEFAULT_SKIP_ZEROES_AT_END 3
2734 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
2739 /* Print out jump visualization. */
2742 print_jump_visualisation (bfd_vma addr
, int max_level
, char *line_buffer
,
2743 uint8_t *color_buffer
)
2748 jump_info_visualize_address (addr
, max_level
, line_buffer
, color_buffer
);
2750 size_t line_buffer_size
= strlen (line_buffer
);
2751 char last_color
= 0;
2754 for (i
= 0; i
<= line_buffer_size
; ++i
)
2758 uint8_t color
= (i
< line_buffer_size
) ? color_buffer
[i
]: 0;
2760 if (color
!= last_color
)
2763 if (extended_color_output
)
2764 /* Use extended 8bit color, but
2765 do not choose dark colors. */
2766 printf ("\033[38;5;%dm", 124 + (color
% 108));
2768 /* Use simple terminal colors. */
2769 printf ("\033[%dm", 31 + (color
% 7));
2776 putchar ((i
< line_buffer_size
) ? line_buffer
[i
]: ' ');
2780 /* Disassemble some data in memory between given values. */
2783 disassemble_bytes (struct disassemble_info
*inf
,
2784 disassembler_ftype disassemble_fn
,
2787 bfd_vma start_offset
,
2788 bfd_vma stop_offset
,
2793 struct objdump_disasm_info
*aux
;
2795 unsigned int octets_per_line
;
2796 unsigned int skip_addr_chars
;
2797 bfd_vma addr_offset
;
2798 unsigned int opb
= inf
->octets_per_byte
;
2799 unsigned int skip_zeroes
= inf
->skip_zeroes
;
2800 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
2804 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
2805 section
= inf
->section
;
2808 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
2812 octets_per_line
= insn_width
;
2814 octets_per_line
= 4;
2816 octets_per_line
= 16;
2818 /* Figure out how many characters to skip at the start of an
2819 address, to make the disassembly look nicer. We discard leading
2820 zeroes in chunks of 4, ensuring that there is always a leading
2822 skip_addr_chars
= 0;
2823 if (!no_addresses
&& !prefix_addresses
)
2827 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
2829 while (buf
[skip_addr_chars
] == '0')
2832 /* Don't discard zeros on overflow. */
2833 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
2834 skip_addr_chars
= 0;
2836 if (skip_addr_chars
!= 0)
2837 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
2840 inf
->insn_info_valid
= 0;
2842 /* Determine maximum level. */
2843 uint8_t *color_buffer
= NULL
;
2844 char *line_buffer
= NULL
;
2847 /* Some jumps were detected. */
2850 struct jump_info
*ji
;
2852 /* Find maximum jump level. */
2853 for (ji
= detected_jumps
; ji
; ji
= ji
->next
)
2855 if (ji
->level
> max_level
)
2856 max_level
= ji
->level
;
2859 /* Allocate buffers. */
2860 size_t len
= (max_level
+ 1) * 3 + 1;
2861 line_buffer
= xmalloc (len
);
2862 line_buffer
[len
- 1] = 0;
2863 color_buffer
= xmalloc (len
);
2864 color_buffer
[len
- 1] = 0;
2867 addr_offset
= start_offset
;
2868 while (addr_offset
< stop_offset
)
2870 bool need_nl
= false;
2874 /* Make sure we don't use relocs from previous instructions. */
2877 /* If we see more than SKIP_ZEROES octets of zeroes, we just
2879 if (! disassemble_zeroes
)
2880 for (; addr_offset
* opb
+ octets
< stop_offset
* opb
; octets
++)
2881 if (data
[addr_offset
* opb
+ octets
] != 0)
2883 if (! disassemble_zeroes
2884 && (inf
->insn_info_valid
== 0
2885 || inf
->branch_delay_insns
== 0)
2886 && (octets
>= skip_zeroes
2887 || (addr_offset
* opb
+ octets
== stop_offset
* opb
2888 && octets
< skip_zeroes_at_end
)))
2890 /* If there are more nonzero octets to follow, we only skip
2891 zeroes in multiples of 4, to try to avoid running over
2892 the start of an instruction which happens to start with
2894 if (addr_offset
* opb
+ octets
!= stop_offset
* opb
)
2897 /* If we are going to display more data, and we are displaying
2898 file offsets, then tell the user how many zeroes we skip
2899 and the file offset from where we resume dumping. */
2900 if (display_file_offsets
2901 && addr_offset
+ octets
/ opb
< stop_offset
)
2902 printf (_("\t... (skipping %lu zeroes, "
2903 "resuming at file offset: 0x%lx)\n"),
2904 (unsigned long) (octets
/ opb
),
2905 (unsigned long) (section
->filepos
2906 + addr_offset
+ octets
/ opb
));
2913 unsigned int bpc
= 0;
2914 unsigned int pb
= 0;
2916 if (with_line_numbers
|| with_source_code
)
2917 show_line (aux
->abfd
, section
, addr_offset
);
2921 else if (!prefix_addresses
)
2925 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
2926 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2930 printf ("%s:\t", buf
+ skip_addr_chars
);
2934 aux
->require_sec
= true;
2935 objdump_print_address (section
->vma
+ addr_offset
, inf
);
2936 aux
->require_sec
= false;
2940 print_jump_visualisation (section
->vma
+ addr_offset
,
2941 max_level
, line_buffer
,
2949 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2950 inf
->stream
= &sfile
;
2951 inf
->bytes_per_line
= 0;
2952 inf
->bytes_per_chunk
= 0;
2953 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
2954 | (wide_output
? WIDE_OUTPUT
: 0));
2956 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
2958 if (inf
->disassembler_needs_relocs
2959 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
2960 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
2961 && *relppp
< relppend
)
2963 bfd_signed_vma distance_to_rel
;
2964 int max_reloc_offset
2965 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2967 distance_to_rel
= ((**relppp
)->address
- rel_offset
2971 if (distance_to_rel
> 0
2972 && (max_reloc_offset
< 0
2973 || distance_to_rel
<= max_reloc_offset
))
2975 /* This reloc *might* apply to the current insn,
2976 starting somewhere inside it. Discover the length
2977 of the current insn so that the check below will
2980 insn_size
= insn_width
;
2983 /* We find the length by calling the dissassembler
2984 function with a dummy print handler. This should
2985 work unless the disassembler is not expecting to
2986 be called multiple times for the same address.
2988 This does mean disassembling the instruction
2989 twice, but we only do this when there is a high
2990 probability that there is a reloc that will
2991 affect the instruction. */
2992 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2993 insn_size
= disassemble_fn (section
->vma
2994 + addr_offset
, inf
);
2995 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2999 /* Check to see if the current reloc is associated with
3000 the instruction that we are about to disassemble. */
3001 if (distance_to_rel
== 0
3002 || (distance_to_rel
> 0
3003 && distance_to_rel
< insn_size
/ (int) opb
))
3005 inf
->flags
|= INSN_HAS_RELOC
;
3006 aux
->reloc
= **relppp
;
3010 if (! disassemble_all
3011 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3012 == (SEC_CODE
| SEC_HAS_CONTENTS
)))
3013 /* Set a stop_vma so that the disassembler will not read
3014 beyond the next symbol. We assume that symbols appear on
3015 the boundaries between instructions. We only do this when
3016 disassembling code of course, and when -D is in effect. */
3017 inf
->stop_vma
= section
->vma
+ stop_offset
;
3019 inf
->stop_offset
= stop_offset
;
3020 insn_size
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
3024 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
3025 inf
->stream
= stdout
;
3026 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
3027 octets_per_line
= inf
->bytes_per_line
;
3028 if (insn_size
< (int) opb
)
3031 printf ("%s\n", sfile
.buffer
);
3034 non_fatal (_("disassemble_fn returned length %d"),
3045 octets
= octets_per_line
;
3046 if (addr_offset
+ octets
/ opb
> stop_offset
)
3047 octets
= (stop_offset
- addr_offset
) * opb
;
3049 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
3051 if (ISPRINT (data
[j
]))
3052 buf
[j
- addr_offset
* opb
] = data
[j
];
3054 buf
[j
- addr_offset
* opb
] = '.';
3056 buf
[j
- addr_offset
* opb
] = '\0';
3059 if (prefix_addresses
3061 : show_raw_insn
>= 0)
3065 /* If ! prefix_addresses and ! wide_output, we print
3066 octets_per_line octets per line. */
3068 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
3069 pb
= octets_per_line
;
3071 if (inf
->bytes_per_chunk
)
3072 bpc
= inf
->bytes_per_chunk
;
3076 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3078 /* PR 21580: Check for a buffer ending early. */
3079 if (j
+ bpc
<= stop_offset
* opb
)
3083 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3085 for (k
= bpc
; k
-- != 0; )
3086 printf ("%02x", (unsigned) data
[j
+ k
]);
3090 for (k
= 0; k
< bpc
; k
++)
3091 printf ("%02x", (unsigned) data
[j
+ k
]);
3097 for (; pb
< octets_per_line
; pb
+= bpc
)
3101 for (k
= 0; k
< bpc
; k
++)
3106 /* Separate raw data from instruction by extra space. */
3116 printf ("%s", sfile
.buffer
);
3118 if (prefix_addresses
3120 : show_raw_insn
>= 0)
3128 j
= addr_offset
* opb
+ pb
;
3134 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
3135 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
3139 printf ("%s:\t", buf
+ skip_addr_chars
);
3142 print_jump_visualisation (section
->vma
+ j
/ opb
,
3143 max_level
, line_buffer
,
3146 pb
+= octets_per_line
;
3149 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
3151 /* PR 21619: Check for a buffer ending early. */
3152 if (j
+ bpc
<= stop_offset
* opb
)
3156 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
3158 for (k
= bpc
; k
-- != 0; )
3159 printf ("%02x", (unsigned) data
[j
+ k
]);
3163 for (k
= 0; k
< bpc
; k
++)
3164 printf ("%02x", (unsigned) data
[j
+ k
]);
3178 while ((*relppp
) < relppend
3179 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
3181 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
3194 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
3199 if (q
->howto
== NULL
)
3200 printf ("*unknown*\t");
3201 else if (q
->howto
->name
)
3202 printf ("%s\t", q
->howto
->name
);
3204 printf ("%d\t", q
->howto
->type
);
3206 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
3207 printf ("*unknown*");
3210 const char *sym_name
;
3212 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
3213 if (sym_name
!= NULL
&& *sym_name
!= '\0')
3214 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
3219 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
3220 sym_name
= bfd_section_name (sym_sec
);
3221 if (sym_name
== NULL
|| *sym_name
== '\0')
3222 sym_name
= "*unknown*";
3223 printf ("%s", sanitize_string (sym_name
));
3229 bfd_vma addend
= q
->addend
;
3230 if ((bfd_signed_vma
) addend
< 0)
3237 objdump_print_value (addend
, inf
, true);
3249 addr_offset
+= octets
/ opb
;
3252 free (sfile
.buffer
);
3254 free (color_buffer
);
3258 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
3260 const struct elf_backend_data
*bed
;
3261 bfd_vma sign_adjust
= 0;
3262 struct disassemble_info
*pinfo
= (struct disassemble_info
*) inf
;
3263 struct objdump_disasm_info
*paux
;
3264 unsigned int opb
= pinfo
->octets_per_byte
;
3265 bfd_byte
*data
= NULL
;
3266 bfd_size_type datasize
= 0;
3267 arelent
**rel_pp
= NULL
;
3268 arelent
**rel_ppstart
= NULL
;
3269 arelent
**rel_ppend
;
3270 bfd_vma stop_offset
;
3271 asymbol
*sym
= NULL
;
3275 unsigned long addr_offset
;
3279 stop_offset_reached
,
3284 /* Sections that do not contain machine
3285 code are not normally disassembled. */
3286 if (! disassemble_all
3287 && only_list
== NULL
3288 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
3289 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
3292 if (! process_section_p (section
))
3295 datasize
= bfd_section_size (section
);
3299 if (start_address
== (bfd_vma
) -1
3300 || start_address
< section
->vma
)
3303 addr_offset
= start_address
- section
->vma
;
3305 if (stop_address
== (bfd_vma
) -1)
3306 stop_offset
= datasize
/ opb
;
3309 if (stop_address
< section
->vma
)
3312 stop_offset
= stop_address
- section
->vma
;
3313 if (stop_offset
> datasize
/ opb
)
3314 stop_offset
= datasize
/ opb
;
3317 if (addr_offset
>= stop_offset
)
3320 /* Decide which set of relocs to use. Load them if necessary. */
3321 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
3322 if (pinfo
->dynrelbuf
&& dump_dynamic_reloc_info
)
3324 rel_pp
= pinfo
->dynrelbuf
;
3325 rel_count
= pinfo
->dynrelcount
;
3326 /* Dynamic reloc addresses are absolute, non-dynamic are section
3327 relative. REL_OFFSET specifies the reloc address corresponding
3328 to the start of this section. */
3329 rel_offset
= section
->vma
;
3337 if ((section
->flags
& SEC_RELOC
) != 0
3338 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
3342 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3344 bfd_fatal (bfd_get_filename (abfd
));
3348 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
3349 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
3351 bfd_fatal (bfd_get_filename (abfd
));
3353 /* Sort the relocs by address. */
3354 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
3358 rel_ppend
= PTR_ADD (rel_pp
, rel_count
);
3360 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
3362 non_fatal (_("Reading section %s failed because: %s"),
3363 section
->name
, bfd_errmsg (bfd_get_error ()));
3367 pinfo
->buffer
= data
;
3368 pinfo
->buffer_vma
= section
->vma
;
3369 pinfo
->buffer_length
= datasize
;
3370 pinfo
->section
= section
;
3372 /* Sort the symbols into value and section order. */
3373 compare_section
= section
;
3374 if (sorted_symcount
> 1)
3375 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
3377 /* Skip over the relocs belonging to addresses below the
3379 while (rel_pp
< rel_ppend
3380 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
3383 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
3385 /* Find the nearest symbol forwards from our current position. */
3386 paux
->require_sec
= true;
3387 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
3388 (struct disassemble_info
*) inf
,
3390 paux
->require_sec
= false;
3392 /* PR 9774: If the target used signed addresses then we must make
3393 sure that we sign extend the value that we calculate for 'addr'
3394 in the loop below. */
3395 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3396 && (bed
= get_elf_backend_data (abfd
)) != NULL
3397 && bed
->sign_extend_vma
)
3398 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
3400 /* Disassemble a block of instructions up to the address associated with
3401 the symbol we have just found. Then print the symbol and find the
3402 next symbol on. Repeat until we have disassembled the entire section
3403 or we have reached the end of the address range we are interested in. */
3404 do_print
= paux
->symbol
== NULL
;
3405 loop_until
= stop_offset_reached
;
3407 while (addr_offset
< stop_offset
)
3411 bfd_vma nextstop_offset
;
3414 addr
= section
->vma
+ addr_offset
;
3415 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
3417 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
3422 (x
< sorted_symcount
3423 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
3427 pinfo
->symbols
= sorted_syms
+ place
;
3428 pinfo
->num_symbols
= x
- place
;
3429 pinfo
->symtab_pos
= place
;
3433 pinfo
->symbols
= NULL
;
3434 pinfo
->num_symbols
= 0;
3435 pinfo
->symtab_pos
= -1;
3438 /* If we are only disassembling from a specific symbol,
3439 check to see if we should start or stop displaying. */
3440 if (sym
&& paux
->symbol
)
3444 /* See if we should stop printing. */
3448 if (sym
->flags
& BSF_FUNCTION
)
3452 case stop_offset_reached
:
3453 /* Handled by the while loop. */
3457 /* FIXME: There is an implicit assumption here
3458 that the name of sym is different from
3460 if (! bfd_is_local_label (abfd
, sym
))
3467 const char * name
= bfd_asymbol_name (sym
);
3468 char * alloc
= NULL
;
3470 if (do_demangle
&& name
[0] != '\0')
3472 /* Demangle the name. */
3473 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
3478 /* We are not currently printing. Check to see
3479 if the current symbol matches the requested symbol. */
3480 if (streq (name
, paux
->symbol
))
3484 if (sym
->flags
& BSF_FUNCTION
)
3486 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3487 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
3489 /* Sym is a function symbol with a size associated
3490 with it. Turn on automatic disassembly for the
3491 next VALUE bytes. */
3492 stop_offset
= addr_offset
3493 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
3494 loop_until
= stop_offset_reached
;
3498 /* Otherwise we need to tell the loop heuristic to
3499 loop until the next function symbol is encountered. */
3500 loop_until
= function_sym
;
3505 /* Otherwise loop until the next symbol is encountered. */
3506 loop_until
= next_sym
;
3514 if (! prefix_addresses
&& do_print
)
3516 pinfo
->fprintf_func (pinfo
->stream
, "\n");
3517 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
3519 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
3522 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3524 else if (sym
== NULL
)
3528 #define is_valid_next_sym(SYM) \
3529 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
3530 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
3531 && pinfo->symbol_is_valid (SYM, pinfo))
3533 /* Search forward for the next appropriate symbol in
3534 SECTION. Note that all the symbols are sorted
3535 together into one big array, and that some sections
3536 may have overlapping addresses. */
3537 while (place
< sorted_symcount
3538 && ! is_valid_next_sym (sorted_syms
[place
]))
3541 if (place
>= sorted_symcount
)
3544 nextsym
= sorted_syms
[place
];
3547 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
3548 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
3549 else if (nextsym
== NULL
)
3550 nextstop_offset
= stop_offset
;
3552 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
3554 if (nextstop_offset
> stop_offset
3555 || nextstop_offset
<= addr_offset
)
3556 nextstop_offset
= stop_offset
;
3558 /* If a symbol is explicitly marked as being an object
3559 rather than a function, just dump the bytes without
3560 disassembling them. */
3563 || sym
->section
!= section
3564 || bfd_asymbol_value (sym
) > addr
3565 || ((sym
->flags
& BSF_OBJECT
) == 0
3566 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
3568 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
3570 || (sym
->flags
& BSF_FUNCTION
) != 0)
3577 /* Resolve symbol name. */
3578 if (visualize_jumps
&& abfd
&& sym
&& sym
->name
)
3580 struct disassemble_info di
;
3583 sf
.alloc
= strlen (sym
->name
) + 40;
3584 sf
.buffer
= (char*) xmalloc (sf
.alloc
);
3586 di
.fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
3589 objdump_print_symname (abfd
, &di
, sym
);
3591 /* Fetch jump information. */
3592 detected_jumps
= disassemble_jumps
3593 (pinfo
, paux
->disassemble_fn
,
3594 addr_offset
, nextstop_offset
,
3595 rel_offset
, &rel_pp
, rel_ppend
);
3597 /* Free symbol name. */
3601 /* Add jumps to output. */
3602 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
3603 addr_offset
, nextstop_offset
,
3604 rel_offset
, &rel_pp
, rel_ppend
);
3607 while (detected_jumps
)
3609 detected_jumps
= jump_info_free (detected_jumps
);
3613 addr_offset
= nextstop_offset
;
3619 if (rel_ppstart
!= NULL
)
3623 /* Disassemble the contents of an object file. */
3626 disassemble_data (bfd
*abfd
)
3628 struct disassemble_info disasm_info
;
3629 struct objdump_disasm_info aux
;
3633 prev_functionname
= NULL
;
3635 prev_discriminator
= 0;
3637 /* We make a copy of syms to sort. We don't want to sort syms
3638 because that will screw up the relocs. */
3639 sorted_symcount
= symcount
? symcount
: dynsymcount
;
3640 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
3641 * sizeof (asymbol
*));
3642 if (sorted_symcount
!= 0)
3644 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
3645 sorted_symcount
* sizeof (asymbol
*));
3647 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
3650 for (i
= 0; i
< synthcount
; ++i
)
3652 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
3656 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
3658 disasm_info
.application_data
= (void *) &aux
;
3660 aux
.require_sec
= false;
3661 disasm_info
.dynrelbuf
= NULL
;
3662 disasm_info
.dynrelcount
= 0;
3664 aux
.symbol
= disasm_sym
;
3666 disasm_info
.print_address_func
= objdump_print_address
;
3667 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
3669 if (machine
!= NULL
)
3671 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
3674 fatal (_("can't use supplied machine %s"), machine
);
3676 abfd
->arch_info
= inf
;
3679 if (endian
!= BFD_ENDIAN_UNKNOWN
)
3681 struct bfd_target
*xvec
;
3683 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
3684 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
3685 xvec
->byteorder
= endian
;
3689 /* Use libopcodes to locate a suitable disassembler. */
3690 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
3691 bfd_big_endian (abfd
),
3692 bfd_get_mach (abfd
), abfd
);
3693 if (!aux
.disassemble_fn
)
3695 non_fatal (_("can't disassemble for architecture %s\n"),
3696 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
3701 disasm_info
.flavour
= bfd_get_flavour (abfd
);
3702 disasm_info
.arch
= bfd_get_arch (abfd
);
3703 disasm_info
.mach
= bfd_get_mach (abfd
);
3704 disasm_info
.disassembler_options
= disassembler_options
;
3705 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
3706 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
3707 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
3708 disasm_info
.disassembler_needs_relocs
= false;
3710 if (bfd_big_endian (abfd
))
3711 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
3712 else if (bfd_little_endian (abfd
))
3713 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
3715 /* ??? Aborting here seems too drastic. We could default to big or little
3717 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
3719 disasm_info
.endian_code
= disasm_info
.endian
;
3721 /* Allow the target to customize the info structure. */
3722 disassemble_init_for_target (& disasm_info
);
3724 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
3725 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3727 if (relsize
< 0 && dump_dynamic_reloc_info
)
3728 bfd_fatal (bfd_get_filename (abfd
));
3732 disasm_info
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
3733 disasm_info
.dynrelcount
3734 = bfd_canonicalize_dynamic_reloc (abfd
, disasm_info
.dynrelbuf
, dynsyms
);
3735 if (disasm_info
.dynrelcount
< 0)
3736 bfd_fatal (bfd_get_filename (abfd
));
3738 /* Sort the relocs by address. */
3739 qsort (disasm_info
.dynrelbuf
, disasm_info
.dynrelcount
, sizeof (arelent
*),
3743 disasm_info
.symtab
= sorted_syms
;
3744 disasm_info
.symtab_size
= sorted_symcount
;
3746 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
3748 free (disasm_info
.dynrelbuf
);
3749 disasm_info
.dynrelbuf
= NULL
;
3751 disassemble_free_target (&disasm_info
);
3755 load_specific_debug_section (enum dwarf_section_display_enum debug
,
3756 asection
*sec
, void *file
)
3758 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3759 bfd
*abfd
= (bfd
*) file
;
3765 if (section
->start
!= NULL
)
3767 /* If it is already loaded, do nothing. */
3768 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3770 free (section
->start
);
3773 section
->filename
= bfd_get_filename (abfd
);
3774 section
->reloc_info
= NULL
;
3775 section
->num_relocs
= 0;
3776 section
->address
= bfd_section_vma (sec
);
3777 section
->size
= bfd_section_size (sec
);
3778 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
3779 alloced
= amt
= section
->size
+ 1;
3780 if (alloced
!= amt
|| alloced
== 0)
3782 section
->start
= NULL
;
3783 free_debug_section (debug
);
3784 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
3785 sanitize_string (section
->name
),
3786 (unsigned long long) section
->size
);
3790 section
->start
= contents
= xmalloc (alloced
);
3791 /* Ensure any string section has a terminating NUL. */
3792 section
->start
[section
->size
] = 0;
3794 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3795 && debug_displays
[debug
].relocate
)
3797 ret
= bfd_simple_get_relocated_section_contents (abfd
,
3803 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
3807 unsigned long reloc_count
;
3810 relocs
= (arelent
**) xmalloc (reloc_size
);
3812 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
3813 if (reloc_count
== 0)
3817 section
->reloc_info
= relocs
;
3818 section
->num_relocs
= reloc_count
;
3824 ret
= bfd_get_full_section_contents (abfd
, sec
, &contents
);
3828 free_debug_section (debug
);
3829 printf (_("\nCan't get contents for section '%s'.\n"),
3830 sanitize_string (section
->name
));
3838 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
3843 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
3846 relocs
= (arelent
**) dsec
->reloc_info
;
3848 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
3849 if (rp
->address
== offset
)
3856 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
3858 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3859 bfd
*abfd
= (bfd
*) file
;
3863 if (!dump_any_debugging
)
3866 /* If it is already loaded, do nothing. */
3867 if (section
->start
!= NULL
)
3869 if (streq (section
->filename
, bfd_get_filename (abfd
)))
3872 /* Locate the debug section. */
3873 name
= section
->uncompressed_name
;
3874 sec
= bfd_get_section_by_name (abfd
, name
);
3877 name
= section
->compressed_name
;
3879 sec
= bfd_get_section_by_name (abfd
, name
);
3883 name
= section
->xcoff_name
;
3885 sec
= bfd_get_section_by_name (abfd
, name
);
3890 section
->name
= name
;
3891 return load_specific_debug_section (debug
, sec
, file
);
3895 free_debug_section (enum dwarf_section_display_enum debug
)
3897 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
3899 free ((char *) section
->start
);
3900 section
->start
= NULL
;
3901 section
->address
= 0;
3906 close_debug_file (void * file
)
3908 bfd
* abfd
= (bfd
*) file
;
3914 open_debug_file (const char * pathname
)
3918 data
= bfd_openr (pathname
, NULL
);
3922 if (! bfd_check_format (data
, bfd_object
))
3928 #if HAVE_LIBDEBUGINFOD
3929 /* Return a hex string represention of the build-id. */
3932 get_build_id (void * data
)
3935 char * build_id_str
;
3936 bfd
* abfd
= (bfd
*) data
;
3937 const struct bfd_build_id
* build_id
;
3939 build_id
= abfd
->build_id
;
3940 if (build_id
== NULL
)
3943 build_id_str
= malloc (build_id
->size
* 2 + 1);
3944 if (build_id_str
== NULL
)
3947 for (i
= 0; i
< build_id
->size
; i
++)
3948 sprintf (build_id_str
+ (i
* 2), "%02x", build_id
->data
[i
]);
3949 build_id_str
[build_id
->size
* 2] = '\0';
3951 return (unsigned char *)build_id_str
;
3953 #endif /* HAVE_LIBDEBUGINFOD */
3956 dump_dwarf_section (bfd
*abfd
, asection
*section
,
3959 const char *name
= bfd_section_name (section
);
3962 bool is_mainfile
= *(bool *) arg
;
3967 if (!is_mainfile
&& !process_links
3968 && (section
->flags
& SEC_DEBUGGING
) == 0)
3971 if (startswith (name
, ".gnu.linkonce.wi."))
3972 match
= ".debug_info";
3976 for (i
= 0; i
< max
; i
++)
3977 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
3978 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0
3979 || strcmp (debug_displays
[i
].section
.xcoff_name
, match
) == 0)
3980 && debug_displays
[i
].enabled
!= NULL
3981 && *debug_displays
[i
].enabled
)
3983 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
3985 if (strcmp (sec
->uncompressed_name
, match
) == 0)
3986 sec
->name
= sec
->uncompressed_name
;
3987 else if (strcmp (sec
->compressed_name
, match
) == 0)
3988 sec
->name
= sec
->compressed_name
;
3990 sec
->name
= sec
->xcoff_name
;
3991 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
3994 debug_displays
[i
].display (sec
, abfd
);
3996 if (i
!= info
&& i
!= abbrev
)
3997 free_debug_section ((enum dwarf_section_display_enum
) i
);
4003 /* Dump the dwarf debugging information. */
4006 dump_dwarf (bfd
*abfd
, bool is_mainfile
)
4008 /* The byte_get pointer should have been set at the start of dump_bfd(). */
4009 if (byte_get
== NULL
)
4011 warn (_("File %s does not contain any dwarf debug information\n"),
4012 bfd_get_filename (abfd
));
4016 switch (bfd_get_arch (abfd
))
4019 /* S12Z has a 24 bit address space. But the only known
4020 producer of dwarf_info encodes addresses into 32 bits. */
4025 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
4029 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
4030 bfd_get_mach (abfd
));
4032 bfd_map_over_sections (abfd
, dump_dwarf_section
, (void *) &is_mainfile
);
4035 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
4036 it. Return NULL on failure. */
4039 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
4040 bfd_size_type
*entsize_ptr
)
4045 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
4046 if (stabsect
== NULL
)
4048 printf (_("No %s section present\n\n"),
4049 sanitize_string (sect_name
));
4053 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
4055 non_fatal (_("reading %s section of %s failed: %s"),
4056 sect_name
, bfd_get_filename (abfd
),
4057 bfd_errmsg (bfd_get_error ()));
4063 *size_ptr
= bfd_section_size (stabsect
);
4065 *entsize_ptr
= stabsect
->entsize
;
4070 /* Stabs entries use a 12 byte format:
4071 4 byte string table index
4073 1 byte stab other field
4074 2 byte stab desc field
4076 FIXME: This will have to change for a 64 bit object format. */
4078 #define STRDXOFF (0)
4080 #define OTHEROFF (5)
4083 #define STABSIZE (12)
4085 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
4086 using string table section STRSECT_NAME (in `strtab'). */
4089 print_section_stabs (bfd
*abfd
,
4090 const char *stabsect_name
,
4091 unsigned *string_offset_ptr
)
4094 unsigned file_string_table_offset
= 0;
4095 unsigned next_file_string_table_offset
= *string_offset_ptr
;
4096 bfd_byte
*stabp
, *stabs_end
;
4099 stabs_end
= stabp
+ stab_size
;
4101 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
4102 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
4104 /* Loop through all symbols and print them.
4106 We start the index at -1 because there is a dummy symbol on
4107 the front of stabs-in-{coff,elf} sections that supplies sizes. */
4108 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
4112 unsigned char type
, other
;
4113 unsigned short desc
;
4116 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
4117 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
4118 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
4119 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
4120 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
4122 printf ("\n%-6d ", i
);
4123 /* Either print the stab name, or, if unnamed, print its number
4124 again (makes consistent formatting for tools like awk). */
4125 name
= bfd_get_stab_name (type
);
4127 printf ("%-6s", sanitize_string (name
));
4128 else if (type
== N_UNDF
)
4131 printf ("%-6d", type
);
4132 printf (" %-6d %-6d ", other
, desc
);
4133 bfd_printf_vma (abfd
, value
);
4134 printf (" %-6lu", strx
);
4136 /* Symbols with type == 0 (N_UNDF) specify the length of the
4137 string table associated with this file. We use that info
4138 to know how to relocate the *next* file's string table indices. */
4141 file_string_table_offset
= next_file_string_table_offset
;
4142 next_file_string_table_offset
+= value
;
4146 bfd_size_type amt
= strx
+ file_string_table_offset
;
4148 /* Using the (possibly updated) string table offset, print the
4149 string (if any) associated with this symbol. */
4150 if (amt
< stabstr_size
)
4151 /* PR 17512: file: 079-79389-0.001:0.1.
4152 FIXME: May need to sanitize this string before displaying. */
4153 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
4159 *string_offset_ptr
= next_file_string_table_offset
;
4164 const char * section_name
;
4165 const char * string_section_name
;
4166 unsigned string_offset
;
4171 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
4174 stab_section_names
* sought
= (stab_section_names
*) names
;
4176 /* Check for section names for which stabsect_name is a prefix, to
4177 handle .stab.N, etc. */
4178 len
= strlen (sought
->section_name
);
4180 /* If the prefix matches, and the files section name ends with a
4181 nul or a digit, then we match. I.e., we want either an exact
4182 match or a section followed by a number. */
4183 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
4184 && (section
->name
[len
] == 0
4185 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
4188 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
4189 &stabstr_size
, NULL
);
4193 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
4195 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
4201 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
4203 stab_section_names s
;
4205 s
.section_name
= stabsect_name
;
4206 s
.string_section_name
= strsect_name
;
4207 s
.string_offset
= 0;
4209 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
4215 /* Dump the any sections containing stabs debugging information. */
4218 dump_stabs (bfd
*abfd
)
4220 dump_stabs_section (abfd
, ".stab", ".stabstr");
4221 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
4222 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
4225 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
4227 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
4231 dump_bfd_header (bfd
*abfd
)
4235 printf (_("architecture: %s, "),
4236 bfd_printable_arch_mach (bfd_get_arch (abfd
),
4237 bfd_get_mach (abfd
)));
4238 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
4240 #define PF(x, y) if (abfd->flags & x) {printf ("%s%s", comma, y); comma=", ";}
4241 PF (HAS_RELOC
, "HAS_RELOC");
4242 PF (EXEC_P
, "EXEC_P");
4243 PF (HAS_LINENO
, "HAS_LINENO");
4244 PF (HAS_DEBUG
, "HAS_DEBUG");
4245 PF (HAS_SYMS
, "HAS_SYMS");
4246 PF (HAS_LOCALS
, "HAS_LOCALS");
4247 PF (DYNAMIC
, "DYNAMIC");
4248 PF (WP_TEXT
, "WP_TEXT");
4249 PF (D_PAGED
, "D_PAGED");
4250 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
4251 printf (_("\nstart address 0x"));
4252 bfd_printf_vma (abfd
, abfd
->start_address
);
4257 #ifdef ENABLE_LIBCTF
4258 /* Formatting callback function passed to ctf_dump. Returns either the pointer
4259 it is passed, or a pointer to newly-allocated storage, in which case
4260 dump_ctf() will free it when it no longer needs it. */
4263 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
4266 const char *blanks
= arg
;
4269 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
4274 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
4276 make_ctfsect (const char *name
, bfd_byte
*data
,
4281 ctfsect
.cts_name
= name
;
4282 ctfsect
.cts_entsize
= 1;
4283 ctfsect
.cts_size
= size
;
4284 ctfsect
.cts_data
= data
;
4289 /* Dump CTF errors/warnings. */
4291 dump_ctf_errs (ctf_dict_t
*fp
)
4293 ctf_next_t
*it
= NULL
;
4298 /* Dump accumulated errors and warnings. */
4299 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
4301 non_fatal (_("%s: %s"), is_warning
? _("warning"): _("error"),
4305 if (err
!= ECTF_NEXT_END
)
4307 non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
4312 /* Dump one CTF archive member. */
4315 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
4318 const char *things
[] = {"Header", "Labels", "Data objects",
4319 "Function objects", "Variables", "Types", "Strings",
4324 /* Don't print out the name of the default-named archive member if it appears
4325 first in the list. The name .ctf appears everywhere, even for things that
4326 aren't really archives, so printing it out is liable to be confusing; also,
4327 the common case by far is for only one archive member to exist, and hiding
4328 it in that case seems worthwhile. */
4330 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
4331 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
4333 if (ctf_parent_name (ctf
) != NULL
)
4334 ctf_import (ctf
, parent
);
4336 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
4338 ctf_dump_state_t
*s
= NULL
;
4341 printf ("\n %s:\n", *thing
);
4342 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
4343 (void *) " ")) != NULL
)
4345 printf ("%s\n", item
);
4349 if (ctf_errno (ctf
))
4351 non_fatal (_("Iteration failed: %s, %s"), *thing
,
4352 ctf_errmsg (ctf_errno (ctf
)));
4357 dump_ctf_errs (ctf
);
4360 /* Dump the CTF debugging information. */
4363 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
4365 ctf_archive_t
*ctfa
= NULL
;
4366 bfd_byte
*ctfdata
= NULL
;
4367 bfd_size_type ctfsize
;
4371 ctf_next_t
*i
= NULL
;
4376 if (sect_name
== NULL
)
4379 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
4380 bfd_fatal (bfd_get_filename (abfd
));
4382 /* Load the CTF file and dump it. Preload the parent dict, since it will
4383 need to be imported into every child in turn. */
4385 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
4386 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
4388 dump_ctf_errs (NULL
);
4389 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4390 bfd_fatal (bfd_get_filename (abfd
));
4393 if ((parent
= ctf_dict_open (ctfa
, parent_name
, &err
)) == NULL
)
4395 dump_ctf_errs (NULL
);
4396 non_fatal (_("CTF open failure: %s"), ctf_errmsg (err
));
4397 bfd_fatal (bfd_get_filename (abfd
));
4400 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
4402 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
4403 dump_ctf_archive_member (fp
, name
, parent
, member
++);
4404 if (err
!= ECTF_NEXT_END
)
4406 dump_ctf_errs (NULL
);
4407 non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err
));
4408 bfd_fatal (bfd_get_filename (abfd
));
4410 ctf_dict_close (parent
);
4416 dump_ctf (bfd
*abfd ATTRIBUTE_UNUSED
, const char *sect_name ATTRIBUTE_UNUSED
,
4417 const char *parent_name ATTRIBUTE_UNUSED
) {}
4422 dump_bfd_private_header (bfd
*abfd
)
4424 if (!bfd_print_private_bfd_data (abfd
, stdout
))
4425 non_fatal (_("warning: private headers incomplete: %s"),
4426 bfd_errmsg (bfd_get_error ()));
4430 dump_target_specific (bfd
*abfd
)
4432 const struct objdump_private_desc
* const *desc
;
4433 struct objdump_private_option
*opt
;
4436 /* Find the desc. */
4437 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
4438 if ((*desc
)->filter (abfd
))
4443 non_fatal (_("option -P/--private not supported by this file"));
4447 /* Clear all options. */
4448 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4449 opt
->selected
= false;
4451 /* Decode options. */
4452 b
= dump_private_options
;
4455 e
= strchr (b
, ',');
4460 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
4461 if (strcmp (opt
->name
, b
) == 0)
4463 opt
->selected
= true;
4466 if (opt
->name
== NULL
)
4467 non_fatal (_("target specific dump '%s' not supported"), b
);
4478 (*desc
)->dump (abfd
);
4481 /* Display a section in hexadecimal format with associated characters.
4482 Each line prefixed by the zero padded address. */
4485 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
4487 bfd_byte
*data
= NULL
;
4488 bfd_size_type datasize
;
4489 bfd_vma addr_offset
;
4490 bfd_vma start_offset
;
4491 bfd_vma stop_offset
;
4492 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
4493 /* Bytes per line. */
4494 const int onaline
= 16;
4499 if (! process_section_p (section
))
4502 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
4505 if ((datasize
= bfd_section_size (section
)) == 0)
4508 /* Compute the address range to display. */
4509 if (start_address
== (bfd_vma
) -1
4510 || start_address
< section
->vma
)
4513 start_offset
= start_address
- section
->vma
;
4515 if (stop_address
== (bfd_vma
) -1)
4516 stop_offset
= datasize
/ opb
;
4519 if (stop_address
< section
->vma
)
4522 stop_offset
= stop_address
- section
->vma
;
4524 if (stop_offset
> datasize
/ opb
)
4525 stop_offset
= datasize
/ opb
;
4528 if (start_offset
>= stop_offset
)
4531 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
4532 if (display_file_offsets
)
4533 printf (_(" (Starting at file offset: 0x%lx)"),
4534 (unsigned long) (section
->filepos
+ start_offset
));
4537 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
4539 non_fatal (_("Reading section %s failed because: %s"),
4540 section
->name
, bfd_errmsg (bfd_get_error ()));
4546 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
4547 if (strlen (buf
) >= sizeof (buf
))
4551 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4553 count
= strlen (buf
) - count
;
4557 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
4558 if (strlen (buf
) >= sizeof (buf
))
4562 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
4564 count
= strlen (buf
) - count
;
4568 for (addr_offset
= start_offset
;
4569 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
4573 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
4574 count
= strlen (buf
);
4575 if ((size_t) count
>= sizeof (buf
))
4579 while (count
< width
)
4584 fputs (buf
+ count
- width
, stdout
);
4587 for (j
= addr_offset
* opb
;
4588 j
< addr_offset
* opb
+ onaline
; j
++)
4590 if (j
< stop_offset
* opb
)
4591 printf ("%02x", (unsigned) (data
[j
]));
4599 for (j
= addr_offset
* opb
;
4600 j
< addr_offset
* opb
+ onaline
; j
++)
4602 if (j
>= stop_offset
* opb
)
4605 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
4612 /* Actually display the various requested regions. */
4615 dump_data (bfd
*abfd
)
4617 bfd_map_over_sections (abfd
, dump_section
, NULL
);
4620 /* Should perhaps share code and display with nm? */
4623 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bool dynamic
)
4632 max_count
= dynsymcount
;
4633 printf ("DYNAMIC SYMBOL TABLE:\n");
4638 max_count
= symcount
;
4639 printf ("SYMBOL TABLE:\n");
4643 printf (_("no symbols\n"));
4645 for (count
= 0; count
< max_count
; count
++)
4649 if (*current
== NULL
)
4650 printf (_("no information for symbol number %ld\n"), count
);
4652 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
4653 printf (_("could not determine the type of symbol number %ld\n"),
4656 else if (process_section_p ((* current
)->section
)
4657 && (dump_special_syms
4658 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
4660 const char *name
= (*current
)->name
;
4662 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
4666 /* If we want to demangle the name, we demangle it
4667 here, and temporarily clobber it while calling
4668 bfd_print_symbol. FIXME: This is a gross hack. */
4669 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
4671 (*current
)->name
= alloc
;
4672 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4673 bfd_print_symbol_all
);
4676 (*current
)->name
= name
;
4680 else if (unicode_display
!= unicode_default
4681 && name
!= NULL
&& *name
!= '\0')
4683 const char * sanitized_name
;
4685 /* If we want to sanitize the name, we do it here, and
4686 temporarily clobber it while calling bfd_print_symbol.
4687 FIXME: This is a gross hack. */
4688 sanitized_name
= sanitize_string (name
);
4689 if (sanitized_name
!= name
)
4690 (*current
)->name
= sanitized_name
;
4692 sanitized_name
= NULL
;
4693 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4694 bfd_print_symbol_all
);
4695 if (sanitized_name
!= NULL
)
4696 (*current
)->name
= name
;
4699 bfd_print_symbol (cur_bfd
, stdout
, *current
,
4700 bfd_print_symbol_all
);
4710 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
4713 char *last_filename
, *last_functionname
;
4714 unsigned int last_line
;
4715 unsigned int last_discriminator
;
4717 /* Get column headers lined up reasonably. */
4725 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
4726 width
= strlen (buf
) - 7;
4728 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
4731 last_filename
= NULL
;
4732 last_functionname
= NULL
;
4734 last_discriminator
= 0;
4736 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
4739 const char *filename
, *functionname
;
4740 unsigned int linenumber
;
4741 unsigned int discriminator
;
4742 const char *sym_name
;
4743 const char *section_name
;
4744 bfd_vma addend2
= 0;
4746 if (start_address
!= (bfd_vma
) -1
4747 && q
->address
< start_address
)
4749 if (stop_address
!= (bfd_vma
) -1
4750 && q
->address
> stop_address
)
4753 if (with_line_numbers
4755 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
4756 &filename
, &functionname
,
4757 &linenumber
, &discriminator
))
4759 if (functionname
!= NULL
4760 && (last_functionname
== NULL
4761 || strcmp (functionname
, last_functionname
) != 0))
4763 printf ("%s():\n", sanitize_string (functionname
));
4764 if (last_functionname
!= NULL
)
4765 free (last_functionname
);
4766 last_functionname
= xstrdup (functionname
);
4770 && (linenumber
!= last_line
4771 || (filename
!= NULL
4772 && last_filename
!= NULL
4773 && filename_cmp (filename
, last_filename
) != 0)
4774 || (discriminator
!= last_discriminator
)))
4776 if (discriminator
> 0)
4777 printf ("%s:%u\n", filename
== NULL
? "???" :
4778 sanitize_string (filename
), linenumber
);
4780 printf ("%s:%u (discriminator %u)\n",
4781 filename
== NULL
? "???" : sanitize_string (filename
),
4782 linenumber
, discriminator
);
4783 last_line
= linenumber
;
4784 last_discriminator
= discriminator
;
4785 if (last_filename
!= NULL
)
4786 free (last_filename
);
4787 if (filename
== NULL
)
4788 last_filename
= NULL
;
4790 last_filename
= xstrdup (filename
);
4794 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
4796 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
4797 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
4802 section_name
= NULL
;
4805 bfd_printf_vma (abfd
, q
->address
);
4806 if (q
->howto
== NULL
)
4807 printf (" *unknown* ");
4808 else if (q
->howto
->name
)
4810 const char *name
= q
->howto
->name
;
4812 /* R_SPARC_OLO10 relocations contain two addends.
4813 But because 'arelent' lacks enough storage to
4814 store them both, the 64-bit ELF Sparc backend
4815 records this as two relocations. One R_SPARC_LO10
4816 and one R_SPARC_13, both pointing to the same
4817 address. This is merely so that we have some
4818 place to store both addend fields.
4820 Undo this transformation, otherwise the output
4821 will be confusing. */
4822 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
4823 && elf_tdata (abfd
)->elf_header
->e_machine
== EM_SPARCV9
4825 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
4827 arelent
*q2
= *(p
+ 1);
4830 && q
->address
== q2
->address
4831 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
4833 name
= "R_SPARC_OLO10";
4834 addend2
= q2
->addend
;
4838 printf (" %-16s ", name
);
4841 printf (" %-16d ", q
->howto
->type
);
4845 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
4849 if (section_name
== NULL
)
4850 section_name
= "*unknown*";
4851 printf ("[%s]", sanitize_string (section_name
));
4856 bfd_signed_vma addend
= q
->addend
;
4864 bfd_printf_vma (abfd
, addend
);
4869 bfd_printf_vma (abfd
, addend2
);
4875 if (last_filename
!= NULL
)
4876 free (last_filename
);
4877 if (last_functionname
!= NULL
)
4878 free (last_functionname
);
4882 dump_relocs_in_section (bfd
*abfd
,
4884 void *dummy ATTRIBUTE_UNUSED
)
4886 arelent
**relpp
= NULL
;
4890 if ( bfd_is_abs_section (section
)
4891 || bfd_is_und_section (section
)
4892 || bfd_is_com_section (section
)
4893 || (! process_section_p (section
))
4894 || ((section
->flags
& SEC_RELOC
) == 0))
4897 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
4899 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
4902 printf (" (none)\n\n");
4910 relpp
= (arelent
**) xmalloc (relsize
);
4911 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
4917 non_fatal (_("failed to read relocs in: %s"),
4918 sanitize_string (bfd_get_filename (abfd
)));
4919 bfd_fatal (_("error message was"));
4921 else if (relcount
== 0)
4922 printf (" (none)\n\n");
4926 dump_reloc_set (abfd
, section
, relpp
, relcount
);
4933 dump_relocs (bfd
*abfd
)
4935 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
4939 dump_dynamic_relocs (bfd
*abfd
)
4945 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4947 bfd_fatal (bfd_get_filename (abfd
));
4949 printf ("DYNAMIC RELOCATION RECORDS");
4952 printf (" (none)\n\n");
4955 relpp
= (arelent
**) xmalloc (relsize
);
4956 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
4959 bfd_fatal (bfd_get_filename (abfd
));
4960 else if (relcount
== 0)
4961 printf (" (none)\n\n");
4965 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
4972 /* Creates a table of paths, to search for source files. */
4975 add_include_path (const char *path
)
4979 include_path_count
++;
4980 include_paths
= (const char **)
4981 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
4982 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4983 if (path
[1] == ':' && path
[2] == 0)
4984 path
= concat (path
, ".", (const char *) 0);
4986 include_paths
[include_path_count
- 1] = path
;
4990 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
4994 if ((section
->flags
& SEC_DEBUGGING
) == 0)
4996 bool *has_reloc_p
= (bool *) arg
;
4997 section
->vma
+= adjust_section_vma
;
4999 section
->lma
+= adjust_section_vma
;
5003 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
5006 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
5011 mask
= (bfd_vma
) 1 << (arch_size
- 1);
5012 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
5015 /* Dump selected contents of ABFD. */
5018 dump_bfd (bfd
*abfd
, bool is_mainfile
)
5020 const struct elf_backend_data
* bed
;
5022 if (bfd_big_endian (abfd
))
5023 byte_get
= byte_get_big_endian
;
5024 else if (bfd_little_endian (abfd
))
5025 byte_get
= byte_get_little_endian
;
5029 /* Load any separate debug information files.
5030 We do this now and without checking do_follow_links because separate
5031 debug info files may contain symbol tables that we will need when
5032 displaying information about the main file. Any memory allocated by
5033 load_separate_debug_files will be released when we call
5034 free_debug_memory below.
5036 The test on is_mainfile is there because the chain of separate debug
5037 info files is a global variable shared by all invocations of dump_bfd. */
5038 if (byte_get
!= NULL
&& is_mainfile
)
5040 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
5042 /* If asked to do so, recursively dump the separate files. */
5043 if (do_follow_links
)
5047 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5048 dump_bfd (i
->handle
, false);
5052 /* Adjust user-specified start and stop limits for targets that use
5053 signed addresses. */
5054 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
5055 && (bed
= get_elf_backend_data (abfd
)) != NULL
5056 && bed
->sign_extend_vma
)
5058 start_address
= sign_extend_address (abfd
, start_address
,
5060 stop_address
= sign_extend_address (abfd
, stop_address
,
5064 /* If we are adjusting section VMA's, change them all now. Changing
5065 the BFD information is a hack. However, we must do it, or
5066 bfd_find_nearest_line will not do the right thing. */
5067 if (adjust_section_vma
!= 0)
5069 bool has_reloc
= (abfd
->flags
& HAS_RELOC
);
5070 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
5073 if (is_mainfile
|| process_links
)
5075 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5076 printf (_("\n%s: file format %s\n"),
5077 sanitize_string (bfd_get_filename (abfd
)),
5080 print_arelt_descr (stdout
, abfd
, true, false);
5081 if (dump_file_header
)
5082 dump_bfd_header (abfd
);
5083 if (dump_private_headers
)
5084 dump_bfd_private_header (abfd
);
5085 if (dump_private_options
!= NULL
)
5086 dump_target_specific (abfd
);
5087 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
5095 || dump_dwarf_section_info
)
5097 syms
= slurp_symtab (abfd
);
5099 /* If following links, load any symbol tables from the linked files as well. */
5100 if (do_follow_links
&& is_mainfile
)
5104 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
5106 asymbol
** extra_syms
;
5107 long old_symcount
= symcount
;
5109 extra_syms
= slurp_symtab (i
->handle
);
5113 if (old_symcount
== 0)
5119 syms
= xrealloc (syms
, ((symcount
+ old_symcount
+ 1)
5120 * sizeof (asymbol
*)));
5121 memcpy (syms
+ old_symcount
,
5123 (symcount
+ 1) * sizeof (asymbol
*));
5127 symcount
+= old_symcount
;
5132 if (is_mainfile
|| process_links
)
5134 if (dump_section_headers
)
5135 dump_headers (abfd
);
5137 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
5138 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
5139 dynsyms
= slurp_dynamic_symtab (abfd
);
5143 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
5144 dynsymcount
, dynsyms
,
5151 dump_symbols (abfd
, false);
5152 if (dump_dynamic_symtab
)
5153 dump_symbols (abfd
, true);
5155 if (dump_dwarf_section_info
)
5156 dump_dwarf (abfd
, is_mainfile
);
5157 if (is_mainfile
|| process_links
)
5159 if (dump_ctf_section_info
)
5160 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
5161 if (dump_stab_section_info
)
5163 if (dump_reloc_info
&& ! disassemble
)
5165 if (dump_dynamic_reloc_info
&& ! disassemble
)
5166 dump_dynamic_relocs (abfd
);
5167 if (dump_section_contents
)
5170 disassemble_data (abfd
);
5177 dhandle
= read_debugging_info (abfd
, syms
, symcount
, true);
5178 if (dhandle
!= NULL
)
5180 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
5182 dump_debugging_tags
!= 0))
5184 non_fatal (_("%s: printing debugging information failed"),
5185 bfd_get_filename (abfd
));
5191 /* PR 6483: If there was no STABS debug info in the file, try
5193 else if (! dump_dwarf_section_info
)
5195 dwarf_select_sections_all ();
5196 dump_dwarf (abfd
, is_mainfile
);
5223 free_debug_memory ();
5227 display_object_bfd (bfd
*abfd
)
5231 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
5233 dump_bfd (abfd
, true);
5237 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5239 nonfatal (bfd_get_filename (abfd
));
5240 list_matching_formats (matching
);
5245 if (bfd_get_error () != bfd_error_file_not_recognized
)
5247 nonfatal (bfd_get_filename (abfd
));
5251 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
5253 dump_bfd (abfd
, true);
5257 nonfatal (bfd_get_filename (abfd
));
5259 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
5261 list_matching_formats (matching
);
5267 display_any_bfd (bfd
*file
, int level
)
5269 /* Decompress sections unless dumping the section contents. */
5270 if (!dump_section_contents
)
5271 file
->flags
|= BFD_DECOMPRESS
;
5273 /* If the file is an archive, process all of its elements. */
5274 if (bfd_check_format (file
, bfd_archive
))
5277 bfd
*last_arfile
= NULL
;
5280 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
5281 else if (level
> 100)
5283 /* Prevent corrupted files from spinning us into an
5284 infinite loop. 100 is an arbitrary heuristic. */
5285 fatal (_("Archive nesting is too deep"));
5289 printf (_("In nested archive %s:\n"),
5290 sanitize_string (bfd_get_filename (file
)));
5294 bfd_set_error (bfd_error_no_error
);
5296 arfile
= bfd_openr_next_archived_file (file
, arfile
);
5299 if (bfd_get_error () != bfd_error_no_more_archived_files
)
5300 nonfatal (bfd_get_filename (file
));
5304 display_any_bfd (arfile
, level
+ 1);
5306 if (last_arfile
!= NULL
)
5308 bfd_close (last_arfile
);
5309 /* PR 17512: file: ac585d01. */
5310 if (arfile
== last_arfile
)
5316 last_arfile
= arfile
;
5319 if (last_arfile
!= NULL
)
5320 bfd_close (last_arfile
);
5323 display_object_bfd (file
);
5327 display_file (char *filename
, char *target
, bool last_file
)
5331 if (get_file_size (filename
) < 1)
5337 file
= bfd_openr (filename
, target
);
5340 nonfatal (filename
);
5344 display_any_bfd (file
, 0);
5346 /* This is an optimization to improve the speed of objdump, especially when
5347 dumping a file with lots of associated debug informatiom. Calling
5348 bfd_close on such a file can take a non-trivial amount of time as there
5349 are lots of lists to walk and buffers to free. This is only really
5350 necessary however if we are about to load another file and we need the
5351 memory back. Otherwise, if we are about to exit, then we can save (a lot
5352 of) time by only doing a quick close, and allowing the OS to reclaim the
5357 bfd_close_all_done (file
);
5361 main (int argc
, char **argv
)
5364 char *target
= default_target
;
5365 bool seenflag
= false;
5367 #ifdef HAVE_LC_MESSAGES
5368 setlocale (LC_MESSAGES
, "");
5370 setlocale (LC_CTYPE
, "");
5372 bindtextdomain (PACKAGE
, LOCALEDIR
);
5373 textdomain (PACKAGE
);
5375 program_name
= *argv
;
5376 xmalloc_set_program_name (program_name
);
5377 bfd_set_error_program_name (program_name
);
5379 START_PROGRESS (program_name
, 0);
5381 expandargv (&argc
, &argv
);
5383 if (bfd_init () != BFD_INIT_MAGIC
)
5384 fatal (_("fatal error: libbfd ABI mismatch"));
5385 set_default_bfd_target ();
5387 while ((c
= getopt_long (argc
, argv
,
5388 "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
5389 long_options
, (int *) 0))
5395 break; /* We've been given a long option. */
5402 if (disassembler_options
)
5403 /* Ignore potential memory leak for now. */
5404 options
= concat (disassembler_options
, ",",
5405 optarg
, (const char *) NULL
);
5408 disassembler_options
= remove_whitespace_and_extra_commas (options
);
5415 display_file_offsets
= true;
5418 with_line_numbers
= true;
5427 enum demangling_styles style
;
5429 style
= cplus_demangle_name_to_style (optarg
);
5430 if (style
== unknown_demangling
)
5431 fatal (_("unknown demangling style `%s'"),
5434 cplus_demangle_set_style (style
);
5437 case OPTION_RECURSE_LIMIT
:
5438 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5440 case OPTION_NO_RECURSE_LIMIT
:
5441 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5444 do_wide
= wide_output
= true;
5446 case OPTION_ADJUST_VMA
:
5447 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
5449 case OPTION_START_ADDRESS
:
5450 start_address
= parse_vma (optarg
, "--start-address");
5451 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5452 fatal (_("error: the start address should be before the end address"));
5454 case OPTION_STOP_ADDRESS
:
5455 stop_address
= parse_vma (optarg
, "--stop-address");
5456 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
5457 fatal (_("error: the stop address should be after the start address"));
5461 prefix_length
= strlen (prefix
);
5462 /* Remove an unnecessary trailing '/' */
5463 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
5466 case OPTION_PREFIX_STRIP
:
5467 prefix_strip
= atoi (optarg
);
5468 if (prefix_strip
< 0)
5469 fatal (_("error: prefix strip must be non-negative"));
5471 case OPTION_INSN_WIDTH
:
5472 insn_width
= strtoul (optarg
, NULL
, 0);
5473 if (insn_width
<= 0)
5474 fatal (_("error: instruction width must be positive"));
5476 case OPTION_INLINES
:
5477 unwind_inlines
= true;
5479 case OPTION_VISUALIZE_JUMPS
:
5480 visualize_jumps
= true;
5481 color_output
= false;
5482 extended_color_output
= false;
5485 if (streq (optarg
, "color"))
5486 color_output
= true;
5487 else if (streq (optarg
, "extended-color"))
5489 color_output
= true;
5490 extended_color_output
= true;
5492 else if (streq (optarg
, "off"))
5493 visualize_jumps
= false;
5495 nonfatal (_("unrecognized argument to --visualize-option"));
5499 if (strcmp (optarg
, "B") == 0)
5500 endian
= BFD_ENDIAN_BIG
;
5501 else if (strcmp (optarg
, "L") == 0)
5502 endian
= BFD_ENDIAN_LITTLE
;
5505 nonfatal (_("unrecognized -E option"));
5510 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
5511 endian
= BFD_ENDIAN_BIG
;
5512 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
5513 endian
= BFD_ENDIAN_LITTLE
;
5516 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
5523 dump_file_header
= true;
5527 formats_info
= true;
5531 add_include_path (optarg
);
5534 dump_private_headers
= true;
5538 dump_private_options
= optarg
;
5542 dump_private_headers
= true;
5544 dump_reloc_info
= true;
5545 dump_file_header
= true;
5546 dump_ar_hdrs
= true;
5547 dump_section_headers
= true;
5555 dump_dynamic_symtab
= true;
5561 disasm_sym
= optarg
;
5564 disassemble_zeroes
= true;
5568 disassemble_all
= true;
5573 with_source_code
= true;
5576 case OPTION_SOURCE_COMMENT
:
5578 with_source_code
= true;
5581 source_comment
= xstrdup (sanitize_string (optarg
));
5583 source_comment
= xstrdup ("# ");
5591 dump_debugging_tags
= 1;
5596 process_links
= true;
5597 do_follow_links
= true;
5600 dump_dwarf_section_info
= true;
5603 dwarf_select_sections_by_letters (optarg
);
5605 dwarf_select_sections_all ();
5608 dump_dwarf_section_info
= true;
5611 dwarf_select_sections_by_names (optarg
);
5613 dwarf_select_sections_all ();
5615 case OPTION_DWARF_DEPTH
:
5618 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5621 case OPTION_DWARF_START
:
5624 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5625 suppress_bfd_header
= 1;
5628 case OPTION_DWARF_CHECK
:
5631 #ifdef ENABLE_LIBCTF
5633 dump_ctf_section_info
= true;
5635 dump_ctf_section_name
= xstrdup (optarg
);
5638 case OPTION_CTF_PARENT
:
5639 dump_ctf_parent_name
= xstrdup (optarg
);
5643 dump_stab_section_info
= true;
5647 dump_section_contents
= true;
5651 dump_reloc_info
= true;
5655 dump_dynamic_reloc_info
= true;
5659 dump_ar_hdrs
= true;
5663 dump_section_headers
= true;
5668 show_version
= true;
5673 if (streq (optarg
, "default") || streq (optarg
, "d"))
5674 unicode_display
= unicode_default
;
5675 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5676 unicode_display
= unicode_locale
;
5677 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5678 unicode_display
= unicode_escape
;
5679 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5680 unicode_display
= unicode_invalid
;
5681 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5682 unicode_display
= unicode_hex
;
5683 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5684 unicode_display
= unicode_highlight
;
5686 fatal (_("invalid argument to -U/--unicode: %s"), optarg
);
5691 /* No need to set seenflag or to break - usage() does not return. */
5698 print_version ("objdump");
5703 dump_any_debugging
= (dump_debugging
5704 || dump_dwarf_section_info
5708 exit_status
= display_info ();
5712 display_file ("a.out", target
, true);
5714 for (; optind
< argc
;)
5716 display_file (argv
[optind
], target
, optind
== argc
- 1);
5722 free (dump_ctf_section_name
);
5723 free (dump_ctf_parent_name
);
5724 free ((void *) source_comment
);
5726 END_PROGRESS (program_name
);