1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2018 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. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status
= 0;
80 static char *default_target
= NULL
; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version
= 0; /* Show the version number. */
85 static int dump_section_contents
; /* -s */
86 static int dump_section_headers
; /* -h */
87 static bfd_boolean dump_file_header
; /* -f */
88 static int dump_symtab
; /* -t */
89 static int dump_dynamic_symtab
; /* -T */
90 static int dump_reloc_info
; /* -r */
91 static int dump_dynamic_reloc_info
; /* -R */
92 static int dump_ar_hdrs
; /* -a */
93 static int dump_private_headers
; /* -p */
94 static char *dump_private_options
; /* -P */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int suppress_bfd_header
;
113 static int dump_special_syms
= 0; /* --special-syms */
114 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
115 static int file_start_context
= 0; /* --file-start-context */
116 static bfd_boolean display_file_offsets
;/* -F */
117 static const char *prefix
; /* --prefix */
118 static int prefix_strip
; /* --prefix-strip */
119 static size_t prefix_length
;
120 static bfd_boolean unwind_inlines
; /* --inlines. */
121 static const char * disasm_sym
; /* Disassembly start symbol. */
123 /* A structure to record the sections mentioned in -j switches. */
126 const char * name
; /* The name of the section. */
127 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
128 struct only
* next
; /* Pointer to the next structure in the list. */
130 /* Pointer to an array of 'only' structures.
131 This pointer is NULL if the -j switch has not been used. */
132 static struct only
* only_list
= NULL
;
134 /* Variables for handling include file path table. */
135 static const char **include_paths
;
136 static int include_path_count
;
138 /* Extra info to pass to the section disassembler and address printing
140 struct objdump_disasm_info
144 bfd_boolean require_sec
;
145 arelent
** dynrelbuf
;
147 disassembler_ftype disassemble_fn
;
152 /* Architecture to disassemble for, or default if NULL. */
153 static char *machine
= NULL
;
155 /* Target specific options to the disassembler. */
156 static char *disassembler_options
= NULL
;
158 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
159 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
161 /* The symbol table. */
162 static asymbol
**syms
;
164 /* Number of symbols in `syms'. */
165 static long symcount
= 0;
167 /* The sorted symbol table. */
168 static asymbol
**sorted_syms
;
170 /* Number of symbols in `sorted_syms'. */
171 static long sorted_symcount
= 0;
173 /* The dynamic symbol table. */
174 static asymbol
**dynsyms
;
176 /* The synthetic symbol table. */
177 static asymbol
*synthsyms
;
178 static long synthcount
= 0;
180 /* Number of symbols in `dynsyms'. */
181 static long dynsymcount
= 0;
183 static bfd_byte
*stabs
;
184 static bfd_size_type stab_size
;
186 static bfd_byte
*strtab
;
187 static bfd_size_type stabstr_size
;
189 static bfd_boolean is_relocatable
= FALSE
;
191 /* Handlers for -P/--private. */
192 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
194 OBJDUMP_PRIVATE_VECTORS
198 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
200 usage (FILE *stream
, int status
)
202 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
203 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
204 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
205 fprintf (stream
, _("\
206 -a, --archive-headers Display archive header information\n\
207 -f, --file-headers Display the contents of the overall file header\n\
208 -p, --private-headers Display object format specific file header contents\n\
209 -P, --private=OPT,OPT... Display object format specific contents\n\
210 -h, --[section-]headers Display the contents of the section headers\n\
211 -x, --all-headers Display the contents of all headers\n\
212 -d, --disassemble Display assembler contents of executable sections\n\
213 -D, --disassemble-all Display assembler contents of all sections\n\
214 --disassemble=<sym> Display assembler contents from <sym>\n\
215 -S, --source Intermix source code with disassembly\n\
216 -s, --full-contents Display the full contents of all sections requested\n\
217 -g, --debugging Display debug information in object file\n\
218 -e, --debugging-tags Display debug information using ctags style\n\
219 -G, --stabs Display (in raw form) any STABS info in the file\n\
220 -W[lLiaprmfFsoRtUuTgAckK] or\n\
221 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
222 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
223 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
224 =addr,=cu_index,=links,=follow-links]\n\
225 Display DWARF info in the file\n\
226 -t, --syms Display the contents of the symbol table(s)\n\
227 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
228 -r, --reloc Display the relocation entries in the file\n\
229 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
230 @<file> Read options from <file>\n\
231 -v, --version Display this program's version number\n\
232 -i, --info List object formats and architectures supported\n\
233 -H, --help Display this information\n\
237 const struct objdump_private_desc
* const *desc
;
239 fprintf (stream
, _("\n The following switches are optional:\n"));
240 fprintf (stream
, _("\
241 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
242 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
243 -j, --section=NAME Only display information for section NAME\n\
244 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
245 -EB --endian=big Assume big endian format when disassembling\n\
246 -EL --endian=little Assume little endian format when disassembling\n\
247 --file-start-context Include context from start of file (with -S)\n\
248 -I, --include=DIR Add DIR to search list for source files\n\
249 -l, --line-numbers Include line numbers and filenames in output\n\
250 -F, --file-offsets Include file offsets when displaying information\n\
251 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
252 The STYLE, if specified, can be `auto', `gnu',\n\
253 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
255 -w, --wide Format output for more than 80 columns\n\
256 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
257 --start-address=ADDR Only process data whose address is >= ADDR\n\
258 --stop-address=ADDR Only process data whose address is <= ADDR\n\
259 --prefix-addresses Print complete address alongside disassembly\n\
260 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
261 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
262 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
263 --special-syms Include special symbols in symbol dumps\n\
264 --inlines Print all inlines for source line (with -l)\n\
265 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
266 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
267 fprintf (stream
, _("\
268 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
269 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
271 --dwarf-check Make additional dwarf internal consistency checks.\
273 list_supported_targets (program_name
, stream
);
274 list_supported_architectures (program_name
, stream
);
276 disassembler_usage (stream
);
278 if (objdump_private_vectors
[0] != NULL
)
281 _("\nOptions supported for -P/--private switch:\n"));
282 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
283 (*desc
)->help (stream
);
286 if (REPORT_BUGS_TO
[0] && status
== 0)
287 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
291 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
295 OPTION_START_ADDRESS
,
308 static struct option long_options
[]=
310 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
311 {"all-headers", no_argument
, NULL
, 'x'},
312 {"private-headers", no_argument
, NULL
, 'p'},
313 {"private", required_argument
, NULL
, 'P'},
314 {"architecture", required_argument
, NULL
, 'm'},
315 {"archive-headers", no_argument
, NULL
, 'a'},
316 {"debugging", no_argument
, NULL
, 'g'},
317 {"debugging-tags", no_argument
, NULL
, 'e'},
318 {"demangle", optional_argument
, NULL
, 'C'},
319 {"disassemble", optional_argument
, NULL
, 'd'},
320 {"disassemble-all", no_argument
, NULL
, 'D'},
321 {"disassembler-options", required_argument
, NULL
, 'M'},
322 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
323 {"dynamic-reloc", no_argument
, NULL
, 'R'},
324 {"dynamic-syms", no_argument
, NULL
, 'T'},
325 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
326 {"file-headers", no_argument
, NULL
, 'f'},
327 {"file-offsets", no_argument
, NULL
, 'F'},
328 {"file-start-context", no_argument
, &file_start_context
, 1},
329 {"full-contents", no_argument
, NULL
, 's'},
330 {"headers", no_argument
, NULL
, 'h'},
331 {"help", no_argument
, NULL
, 'H'},
332 {"info", no_argument
, NULL
, 'i'},
333 {"line-numbers", no_argument
, NULL
, 'l'},
334 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
335 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
336 {"reloc", no_argument
, NULL
, 'r'},
337 {"section", required_argument
, NULL
, 'j'},
338 {"section-headers", no_argument
, NULL
, 'h'},
339 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
340 {"source", no_argument
, NULL
, 'S'},
341 {"special-syms", no_argument
, &dump_special_syms
, 1},
342 {"include", required_argument
, NULL
, 'I'},
343 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
344 {"stabs", no_argument
, NULL
, 'G'},
345 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
346 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
347 {"syms", no_argument
, NULL
, 't'},
348 {"target", required_argument
, NULL
, 'b'},
349 {"version", no_argument
, NULL
, 'V'},
350 {"wide", no_argument
, NULL
, 'w'},
351 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
352 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
353 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
354 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
355 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
356 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
357 {"inlines", no_argument
, 0, OPTION_INLINES
},
358 {0, no_argument
, 0, 0}
362 nonfatal (const char *msg
)
368 /* Returns TRUE if the specified section should be dumped. */
371 process_section_p (asection
* section
)
375 if (only_list
== NULL
)
378 for (only
= only_list
; only
; only
= only
->next
)
379 if (strcmp (only
->name
, section
->name
) == 0)
388 /* Add an entry to the 'only' list. */
391 add_only (char * name
)
395 /* First check to make sure that we do not
396 already have an entry for this name. */
397 for (only
= only_list
; only
; only
= only
->next
)
398 if (strcmp (only
->name
, name
) == 0)
401 only
= xmalloc (sizeof * only
);
404 only
->next
= only_list
;
408 /* Release the memory used by the 'only' list.
409 PR 11225: Issue a warning message for unseen sections.
410 Only do this if none of the sections were seen. This is mainly to support
411 tools like the GAS testsuite where an object file is dumped with a list of
412 generic section names known to be present in a range of different file
416 free_only_list (void)
418 bfd_boolean at_least_one_seen
= FALSE
;
422 if (only_list
== NULL
)
425 for (only
= only_list
; only
; only
= only
->next
)
428 at_least_one_seen
= TRUE
;
432 for (only
= only_list
; only
; only
= next
)
434 if (! at_least_one_seen
)
436 non_fatal (_("section '%s' mentioned in a -j option, "
437 "but not found in any input file"),
448 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
451 unsigned int opb
= bfd_octets_per_byte (abfd
);
452 int longest_section_name
= *((int *) data
);
454 /* Ignore linker created section. See elfNN_ia64_object_p in
456 if (section
->flags
& SEC_LINKER_CREATED
)
459 /* PR 10413: Skip sections that we are ignoring. */
460 if (! process_section_p (section
))
463 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
464 bfd_get_section_name (abfd
, section
),
465 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
466 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
468 bfd_printf_vma (abfd
, section
->lma
);
469 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
470 bfd_get_section_alignment (abfd
, section
));
476 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
478 PF (SEC_HAS_CONTENTS
, "CONTENTS");
479 PF (SEC_ALLOC
, "ALLOC");
480 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
481 PF (SEC_LOAD
, "LOAD");
482 PF (SEC_RELOC
, "RELOC");
483 PF (SEC_READONLY
, "READONLY");
484 PF (SEC_CODE
, "CODE");
485 PF (SEC_DATA
, "DATA");
487 PF (SEC_DEBUGGING
, "DEBUGGING");
488 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
489 PF (SEC_EXCLUDE
, "EXCLUDE");
490 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
491 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
493 PF (SEC_TIC54X_BLOCK
, "BLOCK");
494 PF (SEC_TIC54X_CLINK
, "CLINK");
496 PF (SEC_SMALL_DATA
, "SMALL_DATA");
497 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
499 PF (SEC_COFF_SHARED
, "SHARED");
500 PF (SEC_COFF_NOREAD
, "NOREAD");
502 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
503 PF (SEC_ELF_PURECODE
, "PURECODE");
504 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
505 PF (SEC_GROUP
, "GROUP");
506 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
508 PF (SEC_MEP_VLIW
, "VLIW");
511 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
514 struct coff_comdat_info
*comdat
;
516 switch (section
->flags
& SEC_LINK_DUPLICATES
)
520 case SEC_LINK_DUPLICATES_DISCARD
:
521 ls
= "LINK_ONCE_DISCARD";
523 case SEC_LINK_DUPLICATES_ONE_ONLY
:
524 ls
= "LINK_ONCE_ONE_ONLY";
526 case SEC_LINK_DUPLICATES_SAME_SIZE
:
527 ls
= "LINK_ONCE_SAME_SIZE";
529 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
530 ls
= "LINK_ONCE_SAME_CONTENTS";
533 printf ("%s%s", comma
, ls
);
535 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
537 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
546 /* Called on each SECTION in ABFD, update the int variable pointed to by
547 DATA which contains the string length of the longest section name. */
550 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
552 int *longest_so_far
= (int *) data
;
556 /* Ignore linker created section. */
557 if (section
->flags
& SEC_LINKER_CREATED
)
560 /* Skip sections that we are ignoring. */
561 if (! process_section_p (section
))
564 name
= bfd_get_section_name (abfd
, section
);
565 len
= (int) strlen (name
);
566 if (len
> *longest_so_far
)
567 *longest_so_far
= len
;
571 dump_headers (bfd
*abfd
)
573 /* The default width of 13 is just an arbitrary choice. */
574 int max_section_name_length
= 13;
580 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
581 if (bfd_get_arch_size (abfd
) == 32)
587 printf (_("Sections:\n"));
590 bfd_map_over_sections (abfd
, find_longest_section_name
,
591 &max_section_name_length
);
593 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
594 max_section_name_length
, "Name",
595 bfd_vma_width
, "VMA",
596 bfd_vma_width
, "LMA");
599 printf (_(" Flags"));
602 bfd_map_over_sections (abfd
, dump_section_header
,
603 &max_section_name_length
);
607 slurp_symtab (bfd
*abfd
)
612 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
618 storage
= bfd_get_symtab_upper_bound (abfd
);
621 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
622 bfd_fatal (_("error message was"));
625 sy
= (asymbol
**) xmalloc (storage
);
627 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
629 bfd_fatal (bfd_get_filename (abfd
));
633 /* Read in the dynamic symbols. */
636 slurp_dynamic_symtab (bfd
*abfd
)
641 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
644 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
646 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
652 bfd_fatal (bfd_get_filename (abfd
));
655 sy
= (asymbol
**) xmalloc (storage
);
657 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
659 bfd_fatal (bfd_get_filename (abfd
));
663 /* Some symbol names are significant and should be kept in the
664 table of sorted symbol names, even if they are marked as
665 debugging/section symbols. */
668 is_significant_symbol_name (const char * name
)
670 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
673 /* Filter out (in place) symbols that are useless for disassembly.
674 COUNT is the number of elements in SYMBOLS.
675 Return the number of useful symbols. */
678 remove_useless_symbols (asymbol
**symbols
, long count
)
680 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
684 asymbol
*sym
= *in_ptr
++;
686 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
688 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
689 && ! is_significant_symbol_name (sym
->name
))
691 if (bfd_is_und_section (sym
->section
)
692 || bfd_is_com_section (sym
->section
))
697 return out_ptr
- symbols
;
700 /* Sort symbols into value order. */
703 compare_symbols (const void *ap
, const void *bp
)
705 const asymbol
*a
= * (const asymbol
**) ap
;
706 const asymbol
*b
= * (const asymbol
**) bp
;
716 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
718 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
721 if (a
->section
> b
->section
)
723 else if (a
->section
< b
->section
)
726 an
= bfd_asymbol_name (a
);
727 bn
= bfd_asymbol_name (b
);
731 /* The symbols gnu_compiled and gcc2_compiled convey no real
732 information, so put them after other symbols with the same value. */
733 af
= (strstr (an
, "gnu_compiled") != NULL
734 || strstr (an
, "gcc2_compiled") != NULL
);
735 bf
= (strstr (bn
, "gnu_compiled") != NULL
736 || strstr (bn
, "gcc2_compiled") != NULL
);
743 /* We use a heuristic for the file name, to try to sort it after
744 more useful symbols. It may not work on non Unix systems, but it
745 doesn't really matter; the only difference is precisely which
746 symbol names get printed. */
748 #define file_symbol(s, sn, snl) \
749 (((s)->flags & BSF_FILE) != 0 \
750 || ((sn)[(snl) - 2] == '.' \
751 && ((sn)[(snl) - 1] == 'o' \
752 || (sn)[(snl) - 1] == 'a')))
754 af
= file_symbol (a
, an
, anl
);
755 bf
= file_symbol (b
, bn
, bnl
);
762 /* Try to sort global symbols before local symbols before function
763 symbols before debugging symbols. */
768 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
770 if ((aflags
& BSF_DEBUGGING
) != 0)
775 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
777 if ((aflags
& BSF_FUNCTION
) != 0)
782 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
784 if ((aflags
& BSF_LOCAL
) != 0)
789 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
791 if ((aflags
& BSF_GLOBAL
) != 0)
797 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
798 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
803 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
804 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
806 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
807 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
809 return asz
> bsz
? -1 : 1;
812 /* Symbols that start with '.' might be section names, so sort them
813 after symbols that don't start with '.'. */
814 if (an
[0] == '.' && bn
[0] != '.')
816 if (an
[0] != '.' && bn
[0] == '.')
819 /* Finally, if we can't distinguish them in any other way, try to
820 get consistent results by sorting the symbols by name. */
821 return strcmp (an
, bn
);
824 /* Sort relocs into address order. */
827 compare_relocs (const void *ap
, const void *bp
)
829 const arelent
*a
= * (const arelent
**) ap
;
830 const arelent
*b
= * (const arelent
**) bp
;
832 if (a
->address
> b
->address
)
834 else if (a
->address
< b
->address
)
837 /* So that associated relocations tied to the same address show up
838 in the correct order, we don't do any further sorting. */
847 /* Print an address (VMA) to the output stream in INFO.
848 If SKIP_ZEROES is TRUE, omit leading zeroes. */
851 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
852 bfd_boolean skip_zeroes
)
856 struct objdump_disasm_info
*aux
;
858 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
859 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
864 for (p
= buf
; *p
== '0'; ++p
)
869 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
872 /* Print the name of a symbol. */
875 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
879 const char *name
, *version_string
= NULL
;
880 bfd_boolean hidden
= FALSE
;
883 name
= bfd_asymbol_name (sym
);
884 if (do_demangle
&& name
[0] != '\0')
886 /* Demangle the name. */
887 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
892 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
893 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
895 if (bfd_is_und_section (bfd_get_section (sym
)))
900 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
901 if (version_string
&& *version_string
!= '\0')
902 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
908 if (version_string
&& *version_string
!= '\0')
909 printf (hidden
? "@%s" : "@@%s", version_string
);
916 /* Locate a symbol given a bfd and a section (from INFO->application_data),
917 and a VMA. If INFO->application_data->require_sec is TRUE, then always
918 require the symbol to be in the section. Returns NULL if there is no
919 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
920 of the symbol in sorted_syms. */
923 find_symbol_for_address (bfd_vma vma
,
924 struct disassemble_info
*inf
,
927 /* @@ Would it speed things up to cache the last two symbols returned,
928 and maybe their address ranges? For many processors, only one memory
929 operand can be present at a time, so the 2-entry cache wouldn't be
930 constantly churned by code doing heavy memory accesses. */
932 /* Indices in `sorted_syms'. */
934 long max_count
= sorted_symcount
;
936 struct objdump_disasm_info
*aux
;
940 bfd_boolean want_section
;
943 if (sorted_symcount
< 1)
946 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
949 opb
= inf
->octets_per_byte
;
951 /* Perform a binary search looking for the closest symbol to the
952 required value. We are searching the range (min, max_count]. */
953 while (min
+ 1 < max_count
)
957 thisplace
= (max_count
+ min
) / 2;
958 sym
= sorted_syms
[thisplace
];
960 if (bfd_asymbol_value (sym
) > vma
)
961 max_count
= thisplace
;
962 else if (bfd_asymbol_value (sym
) < vma
)
971 /* The symbol we want is now in min, the low end of the range we
972 were searching. If there are several symbols with the same
973 value, we want the first (non-section/non-debugging) one. */
976 && (bfd_asymbol_value (sorted_syms
[thisplace
])
977 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
978 && ((sorted_syms
[thisplace
- 1]->flags
979 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
983 /* Prefer a symbol in the current section if we have multple symbols
984 with the same value, as can occur with overlays or zero size
987 while (min
< max_count
988 && (bfd_asymbol_value (sorted_syms
[min
])
989 == bfd_asymbol_value (sorted_syms
[thisplace
])))
991 if (sorted_syms
[min
]->section
== sec
992 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
999 return sorted_syms
[thisplace
];
1004 /* If the file is relocatable, and the symbol could be from this
1005 section, prefer a symbol from this section over symbols from
1006 others, even if the other symbol's value might be closer.
1008 Note that this may be wrong for some symbol references if the
1009 sections have overlapping memory ranges, but in that case there's
1010 no way to tell what's desired without looking at the relocation
1013 Also give the target a chance to reject symbols. */
1014 want_section
= (aux
->require_sec
1015 || ((abfd
->flags
& HAS_RELOC
) != 0
1016 && vma
>= bfd_get_section_vma (abfd
, sec
)
1017 && vma
< (bfd_get_section_vma (abfd
, sec
)
1018 + bfd_section_size (abfd
, sec
) / opb
)));
1019 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1020 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1023 long newplace
= sorted_symcount
;
1025 for (i
= min
- 1; i
>= 0; i
--)
1027 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1028 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1030 if (newplace
== sorted_symcount
)
1033 if (bfd_asymbol_value (sorted_syms
[i
])
1034 != bfd_asymbol_value (sorted_syms
[newplace
]))
1037 /* Remember this symbol and keep searching until we reach
1038 an earlier address. */
1043 if (newplace
!= sorted_symcount
)
1044 thisplace
= newplace
;
1047 /* We didn't find a good symbol with a smaller value.
1048 Look for one with a larger value. */
1049 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1051 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
1052 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1060 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1061 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1062 /* There is no suitable symbol. */
1066 /* If we have not found an exact match for the specified address
1067 and we have dynamic relocations available, then we can produce
1068 a better result by matching a relocation to the address and
1069 using the symbol associated with that relocation. */
1070 rel_count
= aux
->dynrelcount
;
1072 && sorted_syms
[thisplace
]->value
!= vma
1074 && aux
->dynrelbuf
!= NULL
1075 && aux
->dynrelbuf
[0]->address
<= vma
1076 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1077 /* If we have matched a synthetic symbol, then stick with that. */
1078 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1081 arelent
** rel_high
;
1083 rel_low
= aux
->dynrelbuf
;
1084 rel_high
= rel_low
+ rel_count
- 1;
1085 while (rel_low
<= rel_high
)
1087 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1088 arelent
* rel
= *rel_mid
;
1090 if (rel
->address
== vma
)
1092 /* Absolute relocations do not provide a more helpful
1093 symbolic address. Find a non-absolute relocation
1094 with the same address. */
1095 arelent
**rel_vma
= rel_mid
;
1097 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1101 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1105 if (rel
->sym_ptr_ptr
!= NULL
1106 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1109 * place
= thisplace
;
1110 return * rel
->sym_ptr_ptr
;
1116 if (vma
< rel
->address
)
1118 else if (vma
>= rel_mid
[1]->address
)
1119 rel_low
= rel_mid
+ 1;
1128 return sorted_syms
[thisplace
];
1131 /* Print an address and the offset to the nearest symbol. */
1134 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1135 bfd_vma vma
, struct disassemble_info
*inf
,
1136 bfd_boolean skip_zeroes
)
1138 objdump_print_value (vma
, inf
, skip_zeroes
);
1144 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1145 bfd_get_section_name (abfd
, sec
));
1146 secaddr
= bfd_get_section_vma (abfd
, sec
);
1149 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1150 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1152 else if (vma
> secaddr
)
1154 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1155 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1157 (*inf
->fprintf_func
) (inf
->stream
, ">");
1161 (*inf
->fprintf_func
) (inf
->stream
, " <");
1163 objdump_print_symname (abfd
, inf
, sym
);
1165 if (bfd_asymbol_value (sym
) == vma
)
1167 /* Undefined symbols in an executables and dynamic objects do not have
1168 a value associated with them, so it does not make sense to display
1169 an offset relative to them. Normally we would not be provided with
1170 this kind of symbol, but the target backend might choose to do so,
1171 and the code in find_symbol_for_address might return an as yet
1172 unresolved symbol associated with a dynamic reloc. */
1173 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1174 && bfd_is_und_section (sym
->section
))
1176 else if (bfd_asymbol_value (sym
) > vma
)
1178 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1179 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1181 else if (vma
> bfd_asymbol_value (sym
))
1183 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1184 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1187 (*inf
->fprintf_func
) (inf
->stream
, ">");
1190 if (display_file_offsets
)
1191 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1192 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1195 /* Print an address (VMA), symbolically if possible.
1196 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1199 objdump_print_addr (bfd_vma vma
,
1200 struct disassemble_info
*inf
,
1201 bfd_boolean skip_zeroes
)
1203 struct objdump_disasm_info
*aux
;
1204 asymbol
*sym
= NULL
;
1205 bfd_boolean skip_find
= FALSE
;
1207 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1209 if (sorted_symcount
< 1)
1211 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1212 objdump_print_value (vma
, inf
, skip_zeroes
);
1214 if (display_file_offsets
)
1215 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1216 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1220 if (aux
->reloc
!= NULL
1221 && aux
->reloc
->sym_ptr_ptr
!= NULL
1222 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1224 sym
= * aux
->reloc
->sym_ptr_ptr
;
1226 /* Adjust the vma to the reloc. */
1227 vma
+= bfd_asymbol_value (sym
);
1229 if (bfd_is_und_section (bfd_get_section (sym
)))
1234 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1236 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1240 /* Print VMA to INFO. This function is passed to the disassembler
1244 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1246 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1249 /* Determine if the given address has a symbol associated with it. */
1252 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1256 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1258 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1261 /* Hold the last function name and the last line number we displayed
1262 in a disassembly. */
1264 static char *prev_functionname
;
1265 static unsigned int prev_line
;
1266 static unsigned int prev_discriminator
;
1268 /* We keep a list of all files that we have seen when doing a
1269 disassembly with source, so that we know how much of the file to
1270 display. This can be important for inlined functions. */
1272 struct print_file_list
1274 struct print_file_list
*next
;
1275 const char *filename
;
1276 const char *modname
;
1279 const char **linemap
;
1282 unsigned max_printed
;
1286 static struct print_file_list
*print_files
;
1288 /* The number of preceding context lines to show when we start
1289 displaying a file for the first time. */
1291 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1293 /* Read a complete file into memory. */
1296 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1299 int ps
= getpagesize ();
1303 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1307 if (fstat (fd
, fst
) < 0)
1312 *size
= fst
->st_size
;
1314 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1315 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1316 if (map
!= (char *) -1L)
1322 map
= (const char *) malloc (*size
);
1323 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1325 free ((void *) map
);
1332 #define line_map_decrease 5
1334 /* Precompute array of lines for a mapped file. */
1336 static const char **
1337 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1339 const char *p
, *lstart
, *end
;
1340 int chars_per_line
= 45; /* First iteration will use 40. */
1341 unsigned int lineno
;
1342 const char **linemap
= NULL
;
1343 unsigned long line_map_size
= 0;
1349 for (p
= map
; p
< end
; p
++)
1353 if (p
+ 1 < end
&& p
[1] == '\r')
1356 else if (*p
== '\r')
1358 if (p
+ 1 < end
&& p
[1] == '\n')
1364 /* End of line found. */
1366 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1368 unsigned long newsize
;
1370 chars_per_line
-= line_map_decrease
;
1371 if (chars_per_line
<= 1)
1373 line_map_size
= size
/ chars_per_line
+ 1;
1374 if (line_map_size
< lineno
+ 1)
1375 line_map_size
= lineno
+ 1;
1376 newsize
= line_map_size
* sizeof (char *);
1377 linemap
= (const char **) xrealloc (linemap
, newsize
);
1380 linemap
[lineno
++] = lstart
;
1388 /* Tries to open MODNAME, and if successful adds a node to print_files
1389 linked list and returns that node. Returns NULL on failure. */
1391 static struct print_file_list
*
1392 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1394 struct print_file_list
*p
;
1396 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1398 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1405 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1408 p
->filename
= origname
;
1409 p
->modname
= modname
;
1410 p
->next
= print_files
;
1416 /* If the source file, as described in the symtab, is not found
1417 try to locate it in one of the paths specified with -I
1418 If found, add location to print_files linked list. */
1420 static struct print_file_list
*
1421 update_source_path (const char *filename
, bfd
*abfd
)
1423 struct print_file_list
*p
;
1428 p
= try_print_file_open (filename
, filename
, &fst
);
1431 if (include_path_count
== 0)
1434 /* Get the name of the file. */
1435 fname
= lbasename (filename
);
1437 /* If file exists under a new path, we need to add it to the list
1438 so that show_line knows about it. */
1439 for (i
= 0; i
< include_path_count
; i
++)
1441 char *modname
= concat (include_paths
[i
], "/", fname
,
1444 p
= try_print_file_open (filename
, modname
, &fst
);
1454 long mtime
= bfd_get_mtime (abfd
);
1456 if (fst
.st_mtime
> mtime
)
1457 warn (_("source file %s is more recent than object file\n"),
1464 /* Print a source file line. */
1467 print_line (struct print_file_list
*p
, unsigned int linenum
)
1473 if (linenum
>= p
->maxline
)
1475 l
= p
->linemap
[linenum
];
1476 /* Test fwrite return value to quiet glibc warning. */
1477 len
= strcspn (l
, "\n\r");
1478 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1482 /* Print a range of source code lines. */
1485 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1489 while (start
<= end
)
1491 print_line (p
, start
);
1496 /* Show the line number, or the source line, in a disassembly
1500 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1502 const char *filename
;
1503 const char *functionname
;
1504 unsigned int linenumber
;
1505 unsigned int discriminator
;
1509 if (! with_line_numbers
&& ! with_source_code
)
1512 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1513 &filename
, &functionname
,
1514 &linenumber
, &discriminator
))
1517 if (filename
!= NULL
&& *filename
== '\0')
1519 if (functionname
!= NULL
&& *functionname
== '\0')
1520 functionname
= NULL
;
1523 && IS_ABSOLUTE_PATH (filename
)
1527 const char *fname
= filename
;
1529 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1532 memcpy (path
, prefix
, prefix_length
);
1533 path_up
= path
+ prefix_length
;
1535 /* Build relocated filename, stripping off leading directories
1536 from the initial filename if requested. */
1537 if (prefix_strip
> 0)
1542 /* Skip selected directory levels. */
1543 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1544 if (IS_DIR_SEPARATOR(*s
))
1551 /* Update complete filename. */
1552 strncpy (path_up
, fname
, PATH_MAX
);
1553 path_up
[PATH_MAX
] = '\0';
1561 if (with_line_numbers
)
1563 if (functionname
!= NULL
1564 && (prev_functionname
== NULL
1565 || strcmp (functionname
, prev_functionname
) != 0))
1567 printf ("%s():\n", functionname
);
1571 && (linenumber
!= prev_line
1572 || discriminator
!= prev_discriminator
))
1574 if (discriminator
> 0)
1575 printf ("%s:%u (discriminator %u)\n",
1576 filename
== NULL
? "???" : filename
,
1577 linenumber
, discriminator
);
1579 printf ("%s:%u\n", filename
== NULL
? "???" : filename
,
1584 const char *filename2
;
1585 const char *functionname2
;
1588 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1590 printf ("inlined by %s:%u (%s)\n", filename2
, line2
,
1595 if (with_source_code
1599 struct print_file_list
**pp
, *p
;
1602 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1603 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1610 filename
= xstrdup (filename
);
1611 p
= update_source_path (filename
, abfd
);
1614 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1616 if (file_start_context
&& p
->first
)
1620 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1621 if (l
>= linenumber
)
1623 if (p
->max_printed
>= l
)
1625 if (p
->max_printed
< linenumber
)
1626 l
= p
->max_printed
+ 1;
1631 dump_lines (p
, l
, linenumber
);
1632 if (p
->max_printed
< linenumber
)
1633 p
->max_printed
= linenumber
;
1634 p
->last_line
= linenumber
;
1639 if (functionname
!= NULL
1640 && (prev_functionname
== NULL
1641 || strcmp (functionname
, prev_functionname
) != 0))
1643 if (prev_functionname
!= NULL
)
1644 free (prev_functionname
);
1645 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1646 strcpy (prev_functionname
, functionname
);
1649 if (linenumber
> 0 && linenumber
!= prev_line
)
1650 prev_line
= linenumber
;
1652 if (discriminator
!= prev_discriminator
)
1653 prev_discriminator
= discriminator
;
1659 /* Pseudo FILE object for strings. */
1667 /* sprintf to a "stream". */
1669 static int ATTRIBUTE_PRINTF_2
1670 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1677 size_t space
= f
->alloc
- f
->pos
;
1679 va_start (args
, format
);
1680 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1686 f
->alloc
= (f
->alloc
+ n
) * 2;
1687 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1694 /* The number of zeroes we want to see before we start skipping them.
1695 The number is arbitrarily chosen. */
1697 #define DEFAULT_SKIP_ZEROES 8
1699 /* The number of zeroes to skip at the end of a section. If the
1700 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1701 SKIP_ZEROES, they will be disassembled. If there are fewer than
1702 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1703 attempt to avoid disassembling zeroes inserted by section
1706 #define DEFAULT_SKIP_ZEROES_AT_END 3
1708 /* Disassemble some data in memory between given values. */
1711 disassemble_bytes (struct disassemble_info
* inf
,
1712 disassembler_ftype disassemble_fn
,
1715 bfd_vma start_offset
,
1716 bfd_vma stop_offset
,
1719 arelent
** relppend
)
1721 struct objdump_disasm_info
*aux
;
1723 int octets_per_line
;
1724 int skip_addr_chars
;
1725 bfd_vma addr_offset
;
1726 unsigned int opb
= inf
->octets_per_byte
;
1727 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1728 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1732 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1736 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1740 octets_per_line
= insn_width
;
1742 octets_per_line
= 4;
1744 octets_per_line
= 16;
1746 /* Figure out how many characters to skip at the start of an
1747 address, to make the disassembly look nicer. We discard leading
1748 zeroes in chunks of 4, ensuring that there is always a leading
1750 skip_addr_chars
= 0;
1751 if (! prefix_addresses
)
1755 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1757 while (buf
[skip_addr_chars
] == '0')
1760 /* Don't discard zeros on overflow. */
1761 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1762 skip_addr_chars
= 0;
1764 if (skip_addr_chars
!= 0)
1765 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1768 inf
->insn_info_valid
= 0;
1770 addr_offset
= start_offset
;
1771 while (addr_offset
< stop_offset
)
1774 bfd_boolean need_nl
= FALSE
;
1775 int previous_octets
;
1777 /* Remember the length of the previous instruction. */
1778 previous_octets
= octets
;
1781 /* Make sure we don't use relocs from previous instructions. */
1784 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1786 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1789 if (! disassemble_zeroes
1790 && (inf
->insn_info_valid
== 0
1791 || inf
->branch_delay_insns
== 0)
1792 && (z
- addr_offset
* opb
>= skip_zeroes
1793 || (z
== stop_offset
* opb
&&
1794 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1796 /* If there are more nonzero octets to follow, we only skip
1797 zeroes in multiples of 4, to try to avoid running over
1798 the start of an instruction which happens to start with
1800 if (z
!= stop_offset
* opb
)
1801 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1803 octets
= z
- addr_offset
* opb
;
1805 /* If we are going to display more data, and we are displaying
1806 file offsets, then tell the user how many zeroes we skip
1807 and the file offset from where we resume dumping. */
1808 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1809 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1811 (unsigned long) (section
->filepos
1812 + (addr_offset
+ (octets
/ opb
))));
1822 if (with_line_numbers
|| with_source_code
)
1823 show_line (aux
->abfd
, section
, addr_offset
);
1825 if (! prefix_addresses
)
1829 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1830 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1834 printf ("%s:\t", buf
+ skip_addr_chars
);
1838 aux
->require_sec
= TRUE
;
1839 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1840 aux
->require_sec
= FALSE
;
1847 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1848 inf
->stream
= &sfile
;
1849 inf
->bytes_per_line
= 0;
1850 inf
->bytes_per_chunk
= 0;
1851 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1853 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1855 if (inf
->disassembler_needs_relocs
1856 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1857 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1858 && *relppp
< relppend
)
1860 bfd_signed_vma distance_to_rel
;
1862 distance_to_rel
= (**relppp
)->address
1863 - (rel_offset
+ addr_offset
);
1865 /* Check to see if the current reloc is associated with
1866 the instruction that we are about to disassemble. */
1867 if (distance_to_rel
== 0
1868 /* FIXME: This is wrong. We are trying to catch
1869 relocs that are addressed part way through the
1870 current instruction, as might happen with a packed
1871 VLIW instruction. Unfortunately we do not know the
1872 length of the current instruction since we have not
1873 disassembled it yet. Instead we take a guess based
1874 upon the length of the previous instruction. The
1875 proper solution is to have a new target-specific
1876 disassembler function which just returns the length
1877 of an instruction at a given address without trying
1878 to display its disassembly. */
1879 || (distance_to_rel
> 0
1880 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1882 inf
->flags
|= INSN_HAS_RELOC
;
1883 aux
->reloc
= **relppp
;
1887 if (! disassemble_all
1888 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1889 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1890 /* Set a stop_vma so that the disassembler will not read
1891 beyond the next symbol. We assume that symbols appear on
1892 the boundaries between instructions. We only do this when
1893 disassembling code of course, and when -D is in effect. */
1894 inf
->stop_vma
= section
->vma
+ stop_offset
;
1896 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1899 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1900 inf
->stream
= stdout
;
1901 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1902 octets_per_line
= inf
->bytes_per_line
;
1903 if (octets
< (int) opb
)
1906 printf ("%s\n", sfile
.buffer
);
1909 non_fatal (_("disassemble_fn returned length %d"),
1920 octets
= octets_per_line
;
1921 if (addr_offset
+ octets
/ opb
> stop_offset
)
1922 octets
= (stop_offset
- addr_offset
) * opb
;
1924 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1926 if (ISPRINT (data
[j
]))
1927 buf
[j
- addr_offset
* opb
] = data
[j
];
1929 buf
[j
- addr_offset
* opb
] = '.';
1931 buf
[j
- addr_offset
* opb
] = '\0';
1934 if (prefix_addresses
1936 : show_raw_insn
>= 0)
1940 /* If ! prefix_addresses and ! wide_output, we print
1941 octets_per_line octets per line. */
1943 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1944 pb
= octets_per_line
;
1946 if (inf
->bytes_per_chunk
)
1947 bpc
= inf
->bytes_per_chunk
;
1951 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1953 /* PR 21580: Check for a buffer ending early. */
1954 if (j
+ bpc
<= stop_offset
* opb
)
1958 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1960 for (k
= bpc
- 1; k
>= 0; k
--)
1961 printf ("%02x", (unsigned) data
[j
+ k
]);
1965 for (k
= 0; k
< bpc
; k
++)
1966 printf ("%02x", (unsigned) data
[j
+ k
]);
1972 for (; pb
< octets_per_line
; pb
+= bpc
)
1976 for (k
= 0; k
< bpc
; k
++)
1981 /* Separate raw data from instruction by extra space. */
1991 printf ("%s", sfile
.buffer
);
1993 if (prefix_addresses
1995 : show_raw_insn
>= 0)
2003 j
= addr_offset
* opb
+ pb
;
2005 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2006 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2010 printf ("%s:\t", buf
+ skip_addr_chars
);
2012 pb
+= octets_per_line
;
2015 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2017 /* PR 21619: Check for a buffer ending early. */
2018 if (j
+ bpc
<= stop_offset
* opb
)
2022 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2024 for (k
= bpc
- 1; k
>= 0; k
--)
2025 printf ("%02x", (unsigned) data
[j
+ k
]);
2029 for (k
= 0; k
< bpc
; k
++)
2030 printf ("%02x", (unsigned) data
[j
+ k
]);
2044 while ((*relppp
) < relppend
2045 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2047 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2058 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2061 if (q
->howto
== NULL
)
2062 printf (": *unknown*\t");
2063 else if (q
->howto
->name
)
2064 printf (": %s\t", q
->howto
->name
);
2066 printf (": %d\t", q
->howto
->type
);
2068 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2069 printf ("*unknown*");
2072 const char *sym_name
;
2074 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2075 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2076 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2081 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2082 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2083 if (sym_name
== NULL
|| *sym_name
== '\0')
2084 sym_name
= "*unknown*";
2085 printf ("%s", sym_name
);
2091 bfd_signed_vma addend
= q
->addend
;
2099 objdump_print_value (addend
, inf
, TRUE
);
2111 addr_offset
+= octets
/ opb
;
2114 free (sfile
.buffer
);
2118 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2120 const struct elf_backend_data
* bed
;
2121 bfd_vma sign_adjust
= 0;
2122 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2123 struct objdump_disasm_info
* paux
;
2124 unsigned int opb
= pinfo
->octets_per_byte
;
2125 bfd_byte
* data
= NULL
;
2126 bfd_size_type datasize
= 0;
2127 arelent
** rel_pp
= NULL
;
2128 arelent
** rel_ppstart
= NULL
;
2129 arelent
** rel_ppend
;
2130 bfd_vma stop_offset
;
2131 asymbol
* sym
= NULL
;
2135 unsigned long addr_offset
;
2137 /* Sections that do not contain machine
2138 code are not normally disassembled. */
2139 if (! disassemble_all
2140 && only_list
== NULL
2141 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2142 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2145 if (! process_section_p (section
))
2148 datasize
= bfd_get_section_size (section
);
2152 if (start_address
== (bfd_vma
) -1
2153 || start_address
< section
->vma
)
2156 addr_offset
= start_address
- section
->vma
;
2158 if (stop_address
== (bfd_vma
) -1)
2159 stop_offset
= datasize
/ opb
;
2162 if (stop_address
< section
->vma
)
2165 stop_offset
= stop_address
- section
->vma
;
2166 if (stop_offset
> datasize
/ opb
)
2167 stop_offset
= datasize
/ opb
;
2170 if (addr_offset
>= stop_offset
)
2173 /* Decide which set of relocs to use. Load them if necessary. */
2174 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2175 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2177 rel_pp
= paux
->dynrelbuf
;
2178 rel_count
= paux
->dynrelcount
;
2179 /* Dynamic reloc addresses are absolute, non-dynamic are section
2180 relative. REL_OFFSET specifies the reloc address corresponding
2181 to the start of this section. */
2182 rel_offset
= section
->vma
;
2190 if ((section
->flags
& SEC_RELOC
) != 0
2191 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2195 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2197 bfd_fatal (bfd_get_filename (abfd
));
2201 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2202 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2204 bfd_fatal (bfd_get_filename (abfd
));
2206 /* Sort the relocs by address. */
2207 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2211 rel_ppend
= rel_pp
+ rel_count
;
2213 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2215 non_fatal (_("Reading section %s failed because: %s"),
2216 section
->name
, bfd_errmsg (bfd_get_error ()));
2220 paux
->sec
= section
;
2221 pinfo
->buffer
= data
;
2222 pinfo
->buffer_vma
= section
->vma
;
2223 pinfo
->buffer_length
= datasize
;
2224 pinfo
->section
= section
;
2226 /* Skip over the relocs belonging to addresses below the
2228 while (rel_pp
< rel_ppend
2229 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2232 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2234 /* Find the nearest symbol forwards from our current position. */
2235 paux
->require_sec
= TRUE
;
2236 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2237 (struct disassemble_info
*) inf
,
2239 paux
->require_sec
= FALSE
;
2241 /* PR 9774: If the target used signed addresses then we must make
2242 sure that we sign extend the value that we calculate for 'addr'
2243 in the loop below. */
2244 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2245 && (bed
= get_elf_backend_data (abfd
)) != NULL
2246 && bed
->sign_extend_vma
)
2247 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2249 /* Disassemble a block of instructions up to the address associated with
2250 the symbol we have just found. Then print the symbol and find the
2251 next symbol on. Repeat until we have disassembled the entire section
2252 or we have reached the end of the address range we are interested in. */
2253 while (addr_offset
< stop_offset
)
2257 bfd_vma nextstop_offset
;
2259 bfd_boolean do_print
= TRUE
;
2261 addr
= section
->vma
+ addr_offset
;
2262 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2264 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2269 (x
< sorted_symcount
2270 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2274 pinfo
->symbols
= sorted_syms
+ place
;
2275 pinfo
->num_symbols
= x
- place
;
2276 pinfo
->symtab_pos
= place
;
2280 pinfo
->symbols
= NULL
;
2281 pinfo
->num_symbols
= 0;
2282 pinfo
->symtab_pos
= -1;
2285 if (sym
&& paux
->symbol
)
2287 const char *name
= bfd_asymbol_name (sym
);
2290 if (do_demangle
&& name
[0] != '\0')
2292 /* Demangle the name. */
2293 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2297 do_print
= streq (name
, paux
->symbol
);
2301 if (! prefix_addresses
&& do_print
)
2303 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2304 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2306 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2309 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2311 else if (sym
== NULL
)
2315 #define is_valid_next_sym(SYM) \
2316 ((SYM)->section == section \
2317 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2318 && pinfo->symbol_is_valid (SYM, pinfo))
2320 /* Search forward for the next appropriate symbol in
2321 SECTION. Note that all the symbols are sorted
2322 together into one big array, and that some sections
2323 may have overlapping addresses. */
2324 while (place
< sorted_symcount
2325 && ! is_valid_next_sym (sorted_syms
[place
]))
2328 if (place
>= sorted_symcount
)
2331 nextsym
= sorted_syms
[place
];
2334 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2335 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2336 else if (nextsym
== NULL
)
2337 nextstop_offset
= stop_offset
;
2339 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2341 if (nextstop_offset
> stop_offset
2342 || nextstop_offset
<= addr_offset
)
2343 nextstop_offset
= stop_offset
;
2345 /* If a symbol is explicitly marked as being an object
2346 rather than a function, just dump the bytes without
2347 disassembling them. */
2350 || sym
->section
!= section
2351 || bfd_asymbol_value (sym
) > addr
2352 || ((sym
->flags
& BSF_OBJECT
) == 0
2353 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2355 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2357 || (sym
->flags
& BSF_FUNCTION
) != 0)
2364 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2365 addr_offset
, nextstop_offset
,
2366 rel_offset
, &rel_pp
, rel_ppend
);
2371 addr_offset
= nextstop_offset
;
2377 if (rel_ppstart
!= NULL
)
2381 /* Disassemble the contents of an object file. */
2384 disassemble_data (bfd
*abfd
)
2386 struct disassemble_info disasm_info
;
2387 struct objdump_disasm_info aux
;
2391 prev_functionname
= NULL
;
2393 prev_discriminator
= 0;
2395 /* We make a copy of syms to sort. We don't want to sort syms
2396 because that will screw up the relocs. */
2397 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2398 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2399 * sizeof (asymbol
*));
2400 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2401 sorted_symcount
* sizeof (asymbol
*));
2403 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2405 for (i
= 0; i
< synthcount
; ++i
)
2407 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2411 /* Sort the symbols into section and symbol order. */
2412 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2414 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2416 disasm_info
.application_data
= (void *) &aux
;
2418 aux
.require_sec
= FALSE
;
2419 aux
.dynrelbuf
= NULL
;
2420 aux
.dynrelcount
= 0;
2422 aux
.symbol
= disasm_sym
;
2424 disasm_info
.print_address_func
= objdump_print_address
;
2425 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2427 if (machine
!= NULL
)
2429 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2432 fatal (_("can't use supplied machine %s"), machine
);
2434 abfd
->arch_info
= inf
;
2437 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2439 struct bfd_target
*xvec
;
2441 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2442 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2443 xvec
->byteorder
= endian
;
2447 /* Use libopcodes to locate a suitable disassembler. */
2448 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2449 bfd_big_endian (abfd
),
2450 bfd_get_mach (abfd
), abfd
);
2451 if (!aux
.disassemble_fn
)
2453 non_fatal (_("can't disassemble for architecture %s\n"),
2454 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2459 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2460 disasm_info
.arch
= bfd_get_arch (abfd
);
2461 disasm_info
.mach
= bfd_get_mach (abfd
);
2462 disasm_info
.disassembler_options
= disassembler_options
;
2463 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2464 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2465 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2466 disasm_info
.disassembler_needs_relocs
= FALSE
;
2468 if (bfd_big_endian (abfd
))
2469 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2470 else if (bfd_little_endian (abfd
))
2471 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2473 /* ??? Aborting here seems too drastic. We could default to big or little
2475 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2477 /* Allow the target to customize the info structure. */
2478 disassemble_init_for_target (& disasm_info
);
2480 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2482 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2484 if (relsize
< 0 && dump_dynamic_reloc_info
)
2485 bfd_fatal (bfd_get_filename (abfd
));
2489 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2490 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2493 if (aux
.dynrelcount
< 0)
2494 bfd_fatal (bfd_get_filename (abfd
));
2496 /* Sort the relocs by address. */
2497 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2501 disasm_info
.symtab
= sorted_syms
;
2502 disasm_info
.symtab_size
= sorted_symcount
;
2504 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2506 if (aux
.dynrelbuf
!= NULL
)
2507 free (aux
.dynrelbuf
);
2512 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2513 asection
*sec
, void *file
)
2515 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2516 bfd
*abfd
= (bfd
*) file
;
2520 if (section
->start
!= NULL
)
2522 /* If it is already loaded, do nothing. */
2523 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2525 free (section
->start
);
2528 section
->filename
= bfd_get_filename (abfd
);
2529 section
->reloc_info
= NULL
;
2530 section
->num_relocs
= 0;
2531 section
->address
= bfd_get_section_vma (abfd
, sec
);
2532 section
->size
= bfd_get_section_size (sec
);
2533 amt
= section
->size
+ 1;
2534 section
->start
= contents
= malloc (amt
);
2535 section
->user_data
= sec
;
2537 || section
->start
== NULL
2538 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2540 free_debug_section (debug
);
2541 printf (_("\nCan't get contents for section '%s'.\n"),
2545 /* Ensure any string section has a terminating NUL. */
2546 section
->start
[section
->size
] = 0;
2548 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2553 bfd_cache_section_contents (sec
, section
->start
);
2555 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2562 free_debug_section (debug
);
2563 printf (_("\nCan't get contents for section '%s'.\n"),
2568 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2571 unsigned long reloc_count
;
2574 relocs
= (arelent
**) xmalloc (reloc_size
);
2576 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2577 if (reloc_count
== 0)
2581 section
->reloc_info
= relocs
;
2582 section
->num_relocs
= reloc_count
;
2591 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2596 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2599 relocs
= (arelent
**) dsec
->reloc_info
;
2601 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2602 if (rp
->address
== offset
)
2609 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2611 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2612 bfd
*abfd
= (bfd
*) file
;
2615 /* If it is already loaded, do nothing. */
2616 if (section
->start
!= NULL
)
2618 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2622 /* Locate the debug section. */
2623 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2625 section
->name
= section
->uncompressed_name
;
2628 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2630 section
->name
= section
->compressed_name
;
2635 return load_specific_debug_section (debug
, sec
, file
);
2639 free_debug_section (enum dwarf_section_display_enum debug
)
2641 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2643 if (section
->start
== NULL
)
2646 /* PR 17512: file: 0f67f69d. */
2647 if (section
->user_data
!= NULL
)
2649 asection
* sec
= (asection
*) section
->user_data
;
2651 /* If we are freeing contents that are also pointed to by the BFD
2652 library's section structure then make sure to update those pointers
2653 too. Otherwise, the next time we try to load data for this section
2654 we can end up using a stale pointer. */
2655 if (section
->start
== sec
->contents
)
2657 sec
->contents
= NULL
;
2658 sec
->flags
&= ~ SEC_IN_MEMORY
;
2659 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2663 free ((char *) section
->start
);
2664 section
->start
= NULL
;
2665 section
->address
= 0;
2670 close_debug_file (void * file
)
2672 bfd
* abfd
= (bfd
*) file
;
2678 open_debug_file (const char * pathname
)
2682 data
= bfd_openr (pathname
, NULL
);
2686 if (! bfd_check_format (data
, bfd_object
))
2693 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2694 void *arg ATTRIBUTE_UNUSED
)
2696 const char *name
= bfd_get_section_name (abfd
, section
);
2700 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2701 match
= ".debug_info";
2705 for (i
= 0; i
< max
; i
++)
2706 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2707 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2708 && debug_displays
[i
].enabled
!= NULL
2709 && *debug_displays
[i
].enabled
)
2711 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2713 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2714 sec
->name
= sec
->uncompressed_name
;
2716 sec
->name
= sec
->compressed_name
;
2717 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2720 debug_displays
[i
].display (sec
, abfd
);
2722 if (i
!= info
&& i
!= abbrev
)
2723 free_debug_section ((enum dwarf_section_display_enum
) i
);
2729 /* Dump the dwarf debugging information. */
2732 dump_dwarf (bfd
*abfd
)
2736 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2738 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2740 if (bfd_big_endian (abfd
))
2741 byte_get
= byte_get_big_endian
;
2742 else if (bfd_little_endian (abfd
))
2743 byte_get
= byte_get_little_endian
;
2745 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2747 warn (_("File %s does not contain any dwarf debug information\n"),
2748 bfd_get_filename (abfd
));
2752 switch (bfd_get_arch (abfd
))
2755 switch (bfd_get_mach (abfd
))
2757 case bfd_mach_x86_64
:
2758 case bfd_mach_x86_64_intel_syntax
:
2759 case bfd_mach_x86_64_nacl
:
2760 case bfd_mach_x64_32
:
2761 case bfd_mach_x64_32_intel_syntax
:
2762 case bfd_mach_x64_32_nacl
:
2763 init_dwarf_regnames_x86_64 ();
2767 init_dwarf_regnames_i386 ();
2772 case bfd_arch_iamcu
:
2773 init_dwarf_regnames_iamcu ();
2776 case bfd_arch_aarch64
:
2777 init_dwarf_regnames_aarch64();
2781 init_dwarf_regnames_s390 ();
2784 case bfd_arch_riscv
:
2785 init_dwarf_regnames_riscv ();
2789 /* S12Z has a 24 bit address space. But the only known
2790 producer of dwarf_info encodes addresses into 32 bits. */
2798 separates
= load_separate_debug_file (abfd
, bfd_get_filename (abfd
));
2800 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2803 bfd_map_over_sections (separates
, dump_dwarf_section
, NULL
);
2805 free_debug_memory ();
2808 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2809 it. Return NULL on failure. */
2812 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2817 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2818 if (stabsect
== NULL
)
2820 printf (_("No %s section present\n\n"), sect_name
);
2824 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
2826 non_fatal (_("reading %s section of %s failed: %s"),
2827 sect_name
, bfd_get_filename (abfd
),
2828 bfd_errmsg (bfd_get_error ()));
2834 *size_ptr
= bfd_section_size (abfd
, stabsect
);
2839 /* Stabs entries use a 12 byte format:
2840 4 byte string table index
2842 1 byte stab other field
2843 2 byte stab desc field
2845 FIXME: This will have to change for a 64 bit object format. */
2847 #define STRDXOFF (0)
2849 #define OTHEROFF (5)
2852 #define STABSIZE (12)
2854 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2855 using string table section STRSECT_NAME (in `strtab'). */
2858 print_section_stabs (bfd
*abfd
,
2859 const char *stabsect_name
,
2860 unsigned *string_offset_ptr
)
2863 unsigned file_string_table_offset
= 0;
2864 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2865 bfd_byte
*stabp
, *stabs_end
;
2868 stabs_end
= stabp
+ stab_size
;
2870 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2871 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2873 /* Loop through all symbols and print them.
2875 We start the index at -1 because there is a dummy symbol on
2876 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2877 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2881 unsigned char type
, other
;
2882 unsigned short desc
;
2885 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2886 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2887 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2888 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2889 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2891 printf ("\n%-6d ", i
);
2892 /* Either print the stab name, or, if unnamed, print its number
2893 again (makes consistent formatting for tools like awk). */
2894 name
= bfd_get_stab_name (type
);
2896 printf ("%-6s", name
);
2897 else if (type
== N_UNDF
)
2900 printf ("%-6d", type
);
2901 printf (" %-6d %-6d ", other
, desc
);
2902 bfd_printf_vma (abfd
, value
);
2903 printf (" %-6lu", strx
);
2905 /* Symbols with type == 0 (N_UNDF) specify the length of the
2906 string table associated with this file. We use that info
2907 to know how to relocate the *next* file's string table indices. */
2910 file_string_table_offset
= next_file_string_table_offset
;
2911 next_file_string_table_offset
+= value
;
2915 bfd_size_type amt
= strx
+ file_string_table_offset
;
2917 /* Using the (possibly updated) string table offset, print the
2918 string (if any) associated with this symbol. */
2919 if (amt
< stabstr_size
)
2920 /* PR 17512: file: 079-79389-0.001:0.1. */
2921 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2927 *string_offset_ptr
= next_file_string_table_offset
;
2932 const char * section_name
;
2933 const char * string_section_name
;
2934 unsigned string_offset
;
2939 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2942 stab_section_names
* sought
= (stab_section_names
*) names
;
2944 /* Check for section names for which stabsect_name is a prefix, to
2945 handle .stab.N, etc. */
2946 len
= strlen (sought
->section_name
);
2948 /* If the prefix matches, and the files section name ends with a
2949 nul or a digit, then we match. I.e., we want either an exact
2950 match or a section followed by a number. */
2951 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2952 && (section
->name
[len
] == 0
2953 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2956 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2961 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
2963 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2969 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2971 stab_section_names s
;
2973 s
.section_name
= stabsect_name
;
2974 s
.string_section_name
= strsect_name
;
2975 s
.string_offset
= 0;
2977 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2983 /* Dump the any sections containing stabs debugging information. */
2986 dump_stabs (bfd
*abfd
)
2988 dump_stabs_section (abfd
, ".stab", ".stabstr");
2989 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2990 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2993 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2995 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2999 dump_bfd_header (bfd
*abfd
)
3003 printf (_("architecture: %s, "),
3004 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3005 bfd_get_mach (abfd
)));
3006 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3008 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3009 PF (HAS_RELOC
, "HAS_RELOC");
3010 PF (EXEC_P
, "EXEC_P");
3011 PF (HAS_LINENO
, "HAS_LINENO");
3012 PF (HAS_DEBUG
, "HAS_DEBUG");
3013 PF (HAS_SYMS
, "HAS_SYMS");
3014 PF (HAS_LOCALS
, "HAS_LOCALS");
3015 PF (DYNAMIC
, "DYNAMIC");
3016 PF (WP_TEXT
, "WP_TEXT");
3017 PF (D_PAGED
, "D_PAGED");
3018 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3019 printf (_("\nstart address 0x"));
3020 bfd_printf_vma (abfd
, abfd
->start_address
);
3026 dump_bfd_private_header (bfd
*abfd
)
3028 bfd_print_private_bfd_data (abfd
, stdout
);
3032 dump_target_specific (bfd
*abfd
)
3034 const struct objdump_private_desc
* const *desc
;
3035 struct objdump_private_option
*opt
;
3038 /* Find the desc. */
3039 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3040 if ((*desc
)->filter (abfd
))
3045 non_fatal (_("option -P/--private not supported by this file"));
3049 /* Clear all options. */
3050 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3051 opt
->selected
= FALSE
;
3053 /* Decode options. */
3054 b
= dump_private_options
;
3057 e
= strchr (b
, ',');
3062 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3063 if (strcmp (opt
->name
, b
) == 0)
3065 opt
->selected
= TRUE
;
3068 if (opt
->name
== NULL
)
3069 non_fatal (_("target specific dump '%s' not supported"), b
);
3080 (*desc
)->dump (abfd
);
3083 /* Display a section in hexadecimal format with associated characters.
3084 Each line prefixed by the zero padded address. */
3087 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3089 bfd_byte
*data
= NULL
;
3090 bfd_size_type datasize
;
3091 bfd_vma addr_offset
;
3092 bfd_vma start_offset
;
3093 bfd_vma stop_offset
;
3094 unsigned int opb
= bfd_octets_per_byte (abfd
);
3095 /* Bytes per line. */
3096 const int onaline
= 16;
3101 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3104 if (! process_section_p (section
))
3107 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3110 /* Compute the address range to display. */
3111 if (start_address
== (bfd_vma
) -1
3112 || start_address
< section
->vma
)
3115 start_offset
= start_address
- section
->vma
;
3117 if (stop_address
== (bfd_vma
) -1)
3118 stop_offset
= datasize
/ opb
;
3121 if (stop_address
< section
->vma
)
3124 stop_offset
= stop_address
- section
->vma
;
3126 if (stop_offset
> datasize
/ opb
)
3127 stop_offset
= datasize
/ opb
;
3130 if (start_offset
>= stop_offset
)
3133 printf (_("Contents of section %s:"), section
->name
);
3134 if (display_file_offsets
)
3135 printf (_(" (Starting at file offset: 0x%lx)"),
3136 (unsigned long) (section
->filepos
+ start_offset
));
3139 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3141 non_fatal (_("Reading section %s failed because: %s"),
3142 section
->name
, bfd_errmsg (bfd_get_error ()));
3148 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3149 if (strlen (buf
) >= sizeof (buf
))
3153 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3155 count
= strlen (buf
) - count
;
3159 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3160 if (strlen (buf
) >= sizeof (buf
))
3164 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3166 count
= strlen (buf
) - count
;
3170 for (addr_offset
= start_offset
;
3171 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3175 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3176 count
= strlen (buf
);
3177 if ((size_t) count
>= sizeof (buf
))
3181 while (count
< width
)
3186 fputs (buf
+ count
- width
, stdout
);
3189 for (j
= addr_offset
* opb
;
3190 j
< addr_offset
* opb
+ onaline
; j
++)
3192 if (j
< stop_offset
* opb
)
3193 printf ("%02x", (unsigned) (data
[j
]));
3201 for (j
= addr_offset
* opb
;
3202 j
< addr_offset
* opb
+ onaline
; j
++)
3204 if (j
>= stop_offset
* opb
)
3207 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3214 /* Actually display the various requested regions. */
3217 dump_data (bfd
*abfd
)
3219 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3222 /* Should perhaps share code and display with nm? */
3225 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3234 max_count
= dynsymcount
;
3235 printf ("DYNAMIC SYMBOL TABLE:\n");
3240 max_count
= symcount
;
3241 printf ("SYMBOL TABLE:\n");
3245 printf (_("no symbols\n"));
3247 for (count
= 0; count
< max_count
; count
++)
3251 if (*current
== NULL
)
3252 printf (_("no information for symbol number %ld\n"), count
);
3254 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3255 printf (_("could not determine the type of symbol number %ld\n"),
3258 else if (process_section_p ((* current
)->section
)
3259 && (dump_special_syms
3260 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3262 const char *name
= (*current
)->name
;
3264 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3268 /* If we want to demangle the name, we demangle it
3269 here, and temporarily clobber it while calling
3270 bfd_print_symbol. FIXME: This is a gross hack. */
3271 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3273 (*current
)->name
= alloc
;
3274 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3275 bfd_print_symbol_all
);
3278 (*current
)->name
= name
;
3283 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3284 bfd_print_symbol_all
);
3294 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3297 char *last_filename
, *last_functionname
;
3298 unsigned int last_line
;
3299 unsigned int last_discriminator
;
3301 /* Get column headers lined up reasonably. */
3309 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3310 width
= strlen (buf
) - 7;
3312 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3315 last_filename
= NULL
;
3316 last_functionname
= NULL
;
3318 last_discriminator
= 0;
3320 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3323 const char *filename
, *functionname
;
3324 unsigned int linenumber
;
3325 unsigned int discriminator
;
3326 const char *sym_name
;
3327 const char *section_name
;
3328 bfd_vma addend2
= 0;
3330 if (start_address
!= (bfd_vma
) -1
3331 && q
->address
< start_address
)
3333 if (stop_address
!= (bfd_vma
) -1
3334 && q
->address
> stop_address
)
3337 if (with_line_numbers
3339 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3340 &filename
, &functionname
,
3341 &linenumber
, &discriminator
))
3343 if (functionname
!= NULL
3344 && (last_functionname
== NULL
3345 || strcmp (functionname
, last_functionname
) != 0))
3347 printf ("%s():\n", functionname
);
3348 if (last_functionname
!= NULL
)
3349 free (last_functionname
);
3350 last_functionname
= xstrdup (functionname
);
3354 && (linenumber
!= last_line
3355 || (filename
!= NULL
3356 && last_filename
!= NULL
3357 && filename_cmp (filename
, last_filename
) != 0)
3358 || (discriminator
!= last_discriminator
)))
3360 if (discriminator
> 0)
3361 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3363 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3364 linenumber
, discriminator
);
3365 last_line
= linenumber
;
3366 last_discriminator
= discriminator
;
3367 if (last_filename
!= NULL
)
3368 free (last_filename
);
3369 if (filename
== NULL
)
3370 last_filename
= NULL
;
3372 last_filename
= xstrdup (filename
);
3376 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3378 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3379 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3384 section_name
= NULL
;
3387 bfd_printf_vma (abfd
, q
->address
);
3388 if (q
->howto
== NULL
)
3389 printf (" *unknown* ");
3390 else if (q
->howto
->name
)
3392 const char *name
= q
->howto
->name
;
3394 /* R_SPARC_OLO10 relocations contain two addends.
3395 But because 'arelent' lacks enough storage to
3396 store them both, the 64-bit ELF Sparc backend
3397 records this as two relocations. One R_SPARC_LO10
3398 and one R_SPARC_13, both pointing to the same
3399 address. This is merely so that we have some
3400 place to store both addend fields.
3402 Undo this transformation, otherwise the output
3403 will be confusing. */
3404 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3405 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3407 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3409 arelent
*q2
= *(p
+ 1);
3412 && q
->address
== q2
->address
3413 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3415 name
= "R_SPARC_OLO10";
3416 addend2
= q2
->addend
;
3420 printf (" %-16s ", name
);
3423 printf (" %-16d ", q
->howto
->type
);
3427 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3431 if (section_name
== NULL
)
3432 section_name
= "*unknown*";
3433 printf ("[%s]", section_name
);
3438 bfd_signed_vma addend
= q
->addend
;
3446 bfd_printf_vma (abfd
, addend
);
3451 bfd_printf_vma (abfd
, addend2
);
3457 if (last_filename
!= NULL
)
3458 free (last_filename
);
3459 if (last_functionname
!= NULL
)
3460 free (last_functionname
);
3464 dump_relocs_in_section (bfd
*abfd
,
3466 void *dummy ATTRIBUTE_UNUSED
)
3472 if ( bfd_is_abs_section (section
)
3473 || bfd_is_und_section (section
)
3474 || bfd_is_com_section (section
)
3475 || (! process_section_p (section
))
3476 || ((section
->flags
& SEC_RELOC
) == 0))
3479 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3481 bfd_fatal (bfd_get_filename (abfd
));
3483 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3487 printf (" (none)\n\n");
3491 if ((bfd_get_file_flags (abfd
) & (BFD_IN_MEMORY
| BFD_LINKER_CREATED
)) == 0
3492 && (((ufile_ptr
) relsize
> bfd_get_file_size (abfd
))
3493 /* Also check the section's reloc count since if this is negative
3494 (or very large) the computation in bfd_get_reloc_upper_bound
3495 may have resulted in returning a small, positive integer.
3496 See PR 22508 for a reproducer.
3498 Note - we check against file size rather than section size as
3499 it is possible for there to be more relocs that apply to a
3500 section than there are bytes in that section. */
3501 || (section
->reloc_count
> bfd_get_file_size (abfd
))))
3503 printf (" (too many: 0x%x)\n", section
->reloc_count
);
3504 bfd_set_error (bfd_error_file_truncated
);
3505 bfd_fatal (bfd_get_filename (abfd
));
3508 relpp
= (arelent
**) xmalloc (relsize
);
3509 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3514 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3515 bfd_fatal (_("error message was"));
3517 else if (relcount
== 0)
3518 printf (" (none)\n\n");
3522 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3529 dump_relocs (bfd
*abfd
)
3531 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3535 dump_dynamic_relocs (bfd
*abfd
)
3541 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3543 bfd_fatal (bfd_get_filename (abfd
));
3545 printf ("DYNAMIC RELOCATION RECORDS");
3548 printf (" (none)\n\n");
3551 relpp
= (arelent
**) xmalloc (relsize
);
3552 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3555 bfd_fatal (bfd_get_filename (abfd
));
3556 else if (relcount
== 0)
3557 printf (" (none)\n\n");
3561 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3568 /* Creates a table of paths, to search for source files. */
3571 add_include_path (const char *path
)
3575 include_path_count
++;
3576 include_paths
= (const char **)
3577 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3578 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3579 if (path
[1] == ':' && path
[2] == 0)
3580 path
= concat (path
, ".", (const char *) 0);
3582 include_paths
[include_path_count
- 1] = path
;
3586 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3590 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3592 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3593 section
->vma
+= adjust_section_vma
;
3595 section
->lma
+= adjust_section_vma
;
3599 /* Dump selected contents of ABFD. */
3602 dump_bfd (bfd
*abfd
)
3604 /* If we are adjusting section VMA's, change them all now. Changing
3605 the BFD information is a hack. However, we must do it, or
3606 bfd_find_nearest_line will not do the right thing. */
3607 if (adjust_section_vma
!= 0)
3609 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3610 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3613 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3614 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3617 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
3618 if (dump_file_header
)
3619 dump_bfd_header (abfd
);
3620 if (dump_private_headers
)
3621 dump_bfd_private_header (abfd
);
3622 if (dump_private_options
!= NULL
)
3623 dump_target_specific (abfd
);
3624 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3631 || dump_dwarf_section_info
)
3632 syms
= slurp_symtab (abfd
);
3634 if (dump_section_headers
)
3635 dump_headers (abfd
);
3637 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3638 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3639 dynsyms
= slurp_dynamic_symtab (abfd
);
3642 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3643 dynsymcount
, dynsyms
, &synthsyms
);
3649 dump_symbols (abfd
, FALSE
);
3650 if (dump_dynamic_symtab
)
3651 dump_symbols (abfd
, TRUE
);
3652 if (dump_dwarf_section_info
)
3654 if (dump_stab_section_info
)
3656 if (dump_reloc_info
&& ! disassemble
)
3658 if (dump_dynamic_reloc_info
&& ! disassemble
)
3659 dump_dynamic_relocs (abfd
);
3660 if (dump_section_contents
)
3663 disassemble_data (abfd
);
3669 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3670 if (dhandle
!= NULL
)
3672 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3674 dump_debugging_tags
? TRUE
: FALSE
))
3676 non_fatal (_("%s: printing debugging information failed"),
3677 bfd_get_filename (abfd
));
3681 /* PR 6483: If there was no STABS debug info in the file, try
3683 else if (! dump_dwarf_section_info
)
3685 dwarf_select_sections_all ();
3714 display_object_bfd (bfd
*abfd
)
3718 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3724 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3726 nonfatal (bfd_get_filename (abfd
));
3727 list_matching_formats (matching
);
3732 if (bfd_get_error () != bfd_error_file_not_recognized
)
3734 nonfatal (bfd_get_filename (abfd
));
3738 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3744 nonfatal (bfd_get_filename (abfd
));
3746 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3748 list_matching_formats (matching
);
3754 display_any_bfd (bfd
*file
, int level
)
3756 /* Decompress sections unless dumping the section contents. */
3757 if (!dump_section_contents
)
3758 file
->flags
|= BFD_DECOMPRESS
;
3760 /* If the file is an archive, process all of its elements. */
3761 if (bfd_check_format (file
, bfd_archive
))
3764 bfd
*last_arfile
= NULL
;
3767 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3768 else if (level
> 100)
3770 /* Prevent corrupted files from spinning us into an
3771 infinite loop. 100 is an arbitrary heuristic. */
3772 fatal (_("Archive nesting is too deep"));
3776 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3780 bfd_set_error (bfd_error_no_error
);
3782 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3785 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3786 nonfatal (bfd_get_filename (file
));
3790 display_any_bfd (arfile
, level
+ 1);
3792 if (last_arfile
!= NULL
)
3794 bfd_close (last_arfile
);
3795 /* PR 17512: file: ac585d01. */
3796 if (arfile
== last_arfile
)
3802 last_arfile
= arfile
;
3805 if (last_arfile
!= NULL
)
3806 bfd_close (last_arfile
);
3809 display_object_bfd (file
);
3813 display_file (char *filename
, char *target
, bfd_boolean last_file
)
3817 if (get_file_size (filename
) < 1)
3823 file
= bfd_openr (filename
, target
);
3826 nonfatal (filename
);
3830 display_any_bfd (file
, 0);
3832 /* This is an optimization to improve the speed of objdump, especially when
3833 dumping a file with lots of associated debug informatiom. Calling
3834 bfd_close on such a file can take a non-trivial amount of time as there
3835 are lots of lists to walk and buffers to free. This is only really
3836 necessary however if we are about to load another file and we need the
3837 memory back. Otherwise, if we are about to exit, then we can save (a lot
3838 of) time by only doing a quick close, and allowing the OS to reclaim the
3843 bfd_close_all_done (file
);
3847 main (int argc
, char **argv
)
3850 char *target
= default_target
;
3851 bfd_boolean seenflag
= FALSE
;
3853 #if defined (HAVE_SETLOCALE)
3854 #if defined (HAVE_LC_MESSAGES)
3855 setlocale (LC_MESSAGES
, "");
3857 setlocale (LC_CTYPE
, "");
3860 bindtextdomain (PACKAGE
, LOCALEDIR
);
3861 textdomain (PACKAGE
);
3863 program_name
= *argv
;
3864 xmalloc_set_program_name (program_name
);
3865 bfd_set_error_program_name (program_name
);
3867 START_PROGRESS (program_name
, 0);
3869 expandargv (&argc
, &argv
);
3871 if (bfd_init () != BFD_INIT_MAGIC
)
3872 fatal (_("fatal error: libbfd ABI mismatch"));
3873 set_default_bfd_target ();
3875 while ((c
= getopt_long (argc
, argv
,
3876 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3877 long_options
, (int *) 0))
3883 break; /* We've been given a long option. */
3890 if (disassembler_options
)
3891 /* Ignore potential memory leak for now. */
3892 options
= concat (disassembler_options
, ",",
3893 optarg
, (const char *) NULL
);
3896 disassembler_options
= remove_whitespace_and_extra_commas (options
);
3903 display_file_offsets
= TRUE
;
3906 with_line_numbers
= TRUE
;
3915 enum demangling_styles style
;
3917 style
= cplus_demangle_name_to_style (optarg
);
3918 if (style
== unknown_demangling
)
3919 fatal (_("unknown demangling style `%s'"),
3922 cplus_demangle_set_style (style
);
3926 do_wide
= wide_output
= TRUE
;
3928 case OPTION_ADJUST_VMA
:
3929 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3931 case OPTION_START_ADDRESS
:
3932 start_address
= parse_vma (optarg
, "--start-address");
3933 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3934 fatal (_("error: the start address should be before the end address"));
3936 case OPTION_STOP_ADDRESS
:
3937 stop_address
= parse_vma (optarg
, "--stop-address");
3938 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3939 fatal (_("error: the stop address should be after the start address"));
3943 prefix_length
= strlen (prefix
);
3944 /* Remove an unnecessary trailing '/' */
3945 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3948 case OPTION_PREFIX_STRIP
:
3949 prefix_strip
= atoi (optarg
);
3950 if (prefix_strip
< 0)
3951 fatal (_("error: prefix strip must be non-negative"));
3953 case OPTION_INSN_WIDTH
:
3954 insn_width
= strtoul (optarg
, NULL
, 0);
3955 if (insn_width
<= 0)
3956 fatal (_("error: instruction width must be positive"));
3958 case OPTION_INLINES
:
3959 unwind_inlines
= TRUE
;
3962 if (strcmp (optarg
, "B") == 0)
3963 endian
= BFD_ENDIAN_BIG
;
3964 else if (strcmp (optarg
, "L") == 0)
3965 endian
= BFD_ENDIAN_LITTLE
;
3968 nonfatal (_("unrecognized -E option"));
3973 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3974 endian
= BFD_ENDIAN_BIG
;
3975 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3976 endian
= BFD_ENDIAN_LITTLE
;
3979 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3986 dump_file_header
= TRUE
;
3990 formats_info
= TRUE
;
3994 add_include_path (optarg
);
3997 dump_private_headers
= TRUE
;
4001 dump_private_options
= optarg
;
4005 dump_private_headers
= TRUE
;
4007 dump_reloc_info
= TRUE
;
4008 dump_file_header
= TRUE
;
4009 dump_ar_hdrs
= TRUE
;
4010 dump_section_headers
= TRUE
;
4018 dump_dynamic_symtab
= TRUE
;
4024 disasm_sym
= optarg
;
4027 disassemble_zeroes
= TRUE
;
4031 disassemble_all
= TRUE
;
4036 with_source_code
= TRUE
;
4045 dump_debugging_tags
= 1;
4050 dump_dwarf_section_info
= TRUE
;
4053 dwarf_select_sections_by_letters (optarg
);
4055 dwarf_select_sections_all ();
4058 dump_dwarf_section_info
= TRUE
;
4061 dwarf_select_sections_by_names (optarg
);
4063 dwarf_select_sections_all ();
4065 case OPTION_DWARF_DEPTH
:
4068 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4071 case OPTION_DWARF_START
:
4074 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4075 suppress_bfd_header
= 1;
4078 case OPTION_DWARF_CHECK
:
4082 dump_stab_section_info
= TRUE
;
4086 dump_section_contents
= TRUE
;
4090 dump_reloc_info
= TRUE
;
4094 dump_dynamic_reloc_info
= TRUE
;
4098 dump_ar_hdrs
= TRUE
;
4102 dump_section_headers
= TRUE
;
4107 show_version
= TRUE
;
4113 /* No need to set seenflag or to break - usage() does not return. */
4120 print_version ("objdump");
4126 exit_status
= display_info ();
4130 display_file ("a.out", target
, TRUE
);
4132 for (; optind
< argc
;)
4134 display_file (argv
[optind
], target
, optind
== argc
- 1);
4141 END_PROGRESS (program_name
);