1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2016 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
;
121 /* A structure to record the sections mentioned in -j switches. */
124 const char * name
; /* The name of the section. */
125 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
126 struct only
* next
; /* Pointer to the next structure in the list. */
128 /* Pointer to an array of 'only' structures.
129 This pointer is NULL if the -j switch has not been used. */
130 static struct only
* only_list
= NULL
;
132 /* Variables for handling include file path table. */
133 static const char **include_paths
;
134 static int include_path_count
;
136 /* Extra info to pass to the section disassembler and address printing
138 struct objdump_disasm_info
142 bfd_boolean require_sec
;
143 arelent
** dynrelbuf
;
145 disassembler_ftype disassemble_fn
;
149 /* Architecture to disassemble for, or default if NULL. */
150 static char *machine
= NULL
;
152 /* Target specific options to the disassembler. */
153 static char *disassembler_options
= NULL
;
155 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
156 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
158 /* The symbol table. */
159 static asymbol
**syms
;
161 /* Number of symbols in `syms'. */
162 static long symcount
= 0;
164 /* The sorted symbol table. */
165 static asymbol
**sorted_syms
;
167 /* Number of symbols in `sorted_syms'. */
168 static long sorted_symcount
= 0;
170 /* The dynamic symbol table. */
171 static asymbol
**dynsyms
;
173 /* The synthetic symbol table. */
174 static asymbol
*synthsyms
;
175 static long synthcount
= 0;
177 /* Number of symbols in `dynsyms'. */
178 static long dynsymcount
= 0;
180 static bfd_byte
*stabs
;
181 static bfd_size_type stab_size
;
184 static bfd_size_type stabstr_size
;
186 static bfd_boolean is_relocatable
= FALSE
;
188 /* Handlers for -P/--private. */
189 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
191 OBJDUMP_PRIVATE_VECTORS
195 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
197 usage (FILE *stream
, int status
)
199 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
200 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
201 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
202 fprintf (stream
, _("\
203 -a, --archive-headers Display archive header information\n\
204 -f, --file-headers Display the contents of the overall file header\n\
205 -p, --private-headers Display object format specific file header contents\n\
206 -P, --private=OPT,OPT... Display object format specific contents\n\
207 -h, --[section-]headers Display the contents of the section headers\n\
208 -x, --all-headers Display the contents of all headers\n\
209 -d, --disassemble Display assembler contents of executable sections\n\
210 -D, --disassemble-all Display assembler contents of all sections\n\
211 -S, --source Intermix source code with disassembly\n\
212 -s, --full-contents Display the full contents of all sections requested\n\
213 -g, --debugging Display debug information in object file\n\
214 -e, --debugging-tags Display debug information using ctags style\n\
215 -G, --stabs Display (in raw form) any STABS info in the file\n\
216 -W[lLiaprmfFsoRt] or\n\
217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 Display DWARF info in the file\n\
222 -t, --syms Display the contents of the symbol table(s)\n\
223 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
224 -r, --reloc Display the relocation entries in the file\n\
225 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
226 @<file> Read options from <file>\n\
227 -v, --version Display this program's version number\n\
228 -i, --info List object formats and architectures supported\n\
229 -H, --help Display this information\n\
233 const struct objdump_private_desc
* const *desc
;
235 fprintf (stream
, _("\n The following switches are optional:\n"));
236 fprintf (stream
, _("\
237 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
238 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
239 -j, --section=NAME Only display information for section NAME\n\
240 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
241 -EB --endian=big Assume big endian format when disassembling\n\
242 -EL --endian=little Assume little endian format when disassembling\n\
243 --file-start-context Include context from start of file (with -S)\n\
244 -I, --include=DIR Add DIR to search list for source files\n\
245 -l, --line-numbers Include line numbers and filenames in output\n\
246 -F, --file-offsets Include file offsets when displaying information\n\
247 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
248 The STYLE, if specified, can be `auto', `gnu',\n\
249 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251 -w, --wide Format output for more than 80 columns\n\
252 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
253 --start-address=ADDR Only process data whose address is >= ADDR\n\
254 --stop-address=ADDR Only process data whose address is <= ADDR\n\
255 --prefix-addresses Print complete address alongside disassembly\n\
256 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
257 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
258 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
259 --special-syms Include special symbols in symbol dumps\n\
260 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
261 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
262 fprintf (stream
, _("\
263 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
264 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
266 --dwarf-check Make additional dwarf internal consistency checks.\
268 list_supported_targets (program_name
, stream
);
269 list_supported_architectures (program_name
, stream
);
271 disassembler_usage (stream
);
273 if (objdump_private_vectors
[0] != NULL
)
276 _("\nOptions supported for -P/--private switch:\n"));
277 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
278 (*desc
)->help (stream
);
281 if (REPORT_BUGS_TO
[0] && status
== 0)
282 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
286 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
290 OPTION_START_ADDRESS
,
302 static struct option long_options
[]=
304 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
305 {"all-headers", no_argument
, NULL
, 'x'},
306 {"private-headers", no_argument
, NULL
, 'p'},
307 {"private", required_argument
, NULL
, 'P'},
308 {"architecture", required_argument
, NULL
, 'm'},
309 {"archive-headers", no_argument
, NULL
, 'a'},
310 {"debugging", no_argument
, NULL
, 'g'},
311 {"debugging-tags", no_argument
, NULL
, 'e'},
312 {"demangle", optional_argument
, NULL
, 'C'},
313 {"disassemble", no_argument
, NULL
, 'd'},
314 {"disassemble-all", no_argument
, NULL
, 'D'},
315 {"disassembler-options", required_argument
, NULL
, 'M'},
316 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
317 {"dynamic-reloc", no_argument
, NULL
, 'R'},
318 {"dynamic-syms", no_argument
, NULL
, 'T'},
319 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
320 {"file-headers", no_argument
, NULL
, 'f'},
321 {"file-offsets", no_argument
, NULL
, 'F'},
322 {"file-start-context", no_argument
, &file_start_context
, 1},
323 {"full-contents", no_argument
, NULL
, 's'},
324 {"headers", no_argument
, NULL
, 'h'},
325 {"help", no_argument
, NULL
, 'H'},
326 {"info", no_argument
, NULL
, 'i'},
327 {"line-numbers", no_argument
, NULL
, 'l'},
328 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
329 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
330 {"reloc", no_argument
, NULL
, 'r'},
331 {"section", required_argument
, NULL
, 'j'},
332 {"section-headers", no_argument
, NULL
, 'h'},
333 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
334 {"source", no_argument
, NULL
, 'S'},
335 {"special-syms", no_argument
, &dump_special_syms
, 1},
336 {"include", required_argument
, NULL
, 'I'},
337 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
338 {"stabs", no_argument
, NULL
, 'G'},
339 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
340 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
341 {"syms", no_argument
, NULL
, 't'},
342 {"target", required_argument
, NULL
, 'b'},
343 {"version", no_argument
, NULL
, 'V'},
344 {"wide", no_argument
, NULL
, 'w'},
345 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
346 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
347 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
348 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
349 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
350 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
351 {0, no_argument
, 0, 0}
355 nonfatal (const char *msg
)
361 /* Returns TRUE if the specified section should be dumped. */
364 process_section_p (asection
* section
)
368 if (only_list
== NULL
)
371 for (only
= only_list
; only
; only
= only
->next
)
372 if (strcmp (only
->name
, section
->name
) == 0)
381 /* Add an entry to the 'only' list. */
384 add_only (char * name
)
388 /* First check to make sure that we do not
389 already have an entry for this name. */
390 for (only
= only_list
; only
; only
= only
->next
)
391 if (strcmp (only
->name
, name
) == 0)
394 only
= xmalloc (sizeof * only
);
397 only
->next
= only_list
;
401 /* Release the memory used by the 'only' list.
402 PR 11225: Issue a warning message for unseen sections.
403 Only do this if none of the sections were seen. This is mainly to support
404 tools like the GAS testsuite where an object file is dumped with a list of
405 generic section names known to be present in a range of different file
409 free_only_list (void)
411 bfd_boolean at_least_one_seen
= FALSE
;
415 if (only_list
== NULL
)
418 for (only
= only_list
; only
; only
= only
->next
)
421 at_least_one_seen
= TRUE
;
425 for (only
= only_list
; only
; only
= next
)
427 if (! at_least_one_seen
)
429 non_fatal (_("section '%s' mentioned in a -j option, "
430 "but not found in any input file"),
441 dump_section_header (bfd
*abfd
, asection
*section
,
442 void *ignored ATTRIBUTE_UNUSED
)
445 unsigned int opb
= bfd_octets_per_byte (abfd
);
447 /* Ignore linker created section. See elfNN_ia64_object_p in
449 if (section
->flags
& SEC_LINKER_CREATED
)
452 /* PR 10413: Skip sections that we are ignoring. */
453 if (! process_section_p (section
))
456 printf ("%3d %-13s %08lx ", section
->index
,
457 bfd_get_section_name (abfd
, section
),
458 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
459 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
461 bfd_printf_vma (abfd
, section
->lma
);
462 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
463 bfd_get_section_alignment (abfd
, section
));
469 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
471 PF (SEC_HAS_CONTENTS
, "CONTENTS");
472 PF (SEC_ALLOC
, "ALLOC");
473 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
474 PF (SEC_LOAD
, "LOAD");
475 PF (SEC_RELOC
, "RELOC");
476 PF (SEC_READONLY
, "READONLY");
477 PF (SEC_CODE
, "CODE");
478 PF (SEC_DATA
, "DATA");
480 PF (SEC_DEBUGGING
, "DEBUGGING");
481 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
482 PF (SEC_EXCLUDE
, "EXCLUDE");
483 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
484 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
486 PF (SEC_TIC54X_BLOCK
, "BLOCK");
487 PF (SEC_TIC54X_CLINK
, "CLINK");
489 PF (SEC_SMALL_DATA
, "SMALL_DATA");
490 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
492 PF (SEC_COFF_SHARED
, "SHARED");
493 PF (SEC_COFF_NOREAD
, "NOREAD");
495 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
496 PF (SEC_ELF_PURECODE
, "PURECODE");
497 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
498 PF (SEC_GROUP
, "GROUP");
499 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
501 PF (SEC_MEP_VLIW
, "VLIW");
504 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
507 struct coff_comdat_info
*comdat
;
509 switch (section
->flags
& SEC_LINK_DUPLICATES
)
513 case SEC_LINK_DUPLICATES_DISCARD
:
514 ls
= "LINK_ONCE_DISCARD";
516 case SEC_LINK_DUPLICATES_ONE_ONLY
:
517 ls
= "LINK_ONCE_ONE_ONLY";
519 case SEC_LINK_DUPLICATES_SAME_SIZE
:
520 ls
= "LINK_ONCE_SAME_SIZE";
522 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
523 ls
= "LINK_ONCE_SAME_CONTENTS";
526 printf ("%s%s", comma
, ls
);
528 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
530 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
540 dump_headers (bfd
*abfd
)
542 printf (_("Sections:\n"));
545 printf (_("Idx Name Size VMA LMA File off Algn"));
547 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
548 if (bfd_get_arch_size (abfd
) == 32)
549 printf (_("Idx Name Size VMA LMA File off Algn"));
551 printf (_("Idx Name Size VMA LMA File off Algn"));
555 printf (_(" Flags"));
558 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
562 slurp_symtab (bfd
*abfd
)
567 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
573 storage
= bfd_get_symtab_upper_bound (abfd
);
576 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
577 bfd_fatal (_("error message was"));
580 sy
= (asymbol
**) xmalloc (storage
);
582 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
584 bfd_fatal (bfd_get_filename (abfd
));
588 /* Read in the dynamic symbols. */
591 slurp_dynamic_symtab (bfd
*abfd
)
596 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
599 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
601 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
607 bfd_fatal (bfd_get_filename (abfd
));
610 sy
= (asymbol
**) xmalloc (storage
);
612 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
614 bfd_fatal (bfd_get_filename (abfd
));
618 /* Filter out (in place) symbols that are useless for disassembly.
619 COUNT is the number of elements in SYMBOLS.
620 Return the number of useful symbols. */
623 remove_useless_symbols (asymbol
**symbols
, long count
)
625 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
629 asymbol
*sym
= *in_ptr
++;
631 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
633 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
635 if (bfd_is_und_section (sym
->section
)
636 || bfd_is_com_section (sym
->section
))
641 return out_ptr
- symbols
;
644 /* Sort symbols into value order. */
647 compare_symbols (const void *ap
, const void *bp
)
649 const asymbol
*a
= * (const asymbol
**) ap
;
650 const asymbol
*b
= * (const asymbol
**) bp
;
660 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
662 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
665 if (a
->section
> b
->section
)
667 else if (a
->section
< b
->section
)
670 an
= bfd_asymbol_name (a
);
671 bn
= bfd_asymbol_name (b
);
675 /* The symbols gnu_compiled and gcc2_compiled convey no real
676 information, so put them after other symbols with the same value. */
677 af
= (strstr (an
, "gnu_compiled") != NULL
678 || strstr (an
, "gcc2_compiled") != NULL
);
679 bf
= (strstr (bn
, "gnu_compiled") != NULL
680 || strstr (bn
, "gcc2_compiled") != NULL
);
687 /* We use a heuristic for the file name, to try to sort it after
688 more useful symbols. It may not work on non Unix systems, but it
689 doesn't really matter; the only difference is precisely which
690 symbol names get printed. */
692 #define file_symbol(s, sn, snl) \
693 (((s)->flags & BSF_FILE) != 0 \
694 || ((sn)[(snl) - 2] == '.' \
695 && ((sn)[(snl) - 1] == 'o' \
696 || (sn)[(snl) - 1] == 'a')))
698 af
= file_symbol (a
, an
, anl
);
699 bf
= file_symbol (b
, bn
, bnl
);
706 /* Try to sort global symbols before local symbols before function
707 symbols before debugging symbols. */
712 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
714 if ((aflags
& BSF_DEBUGGING
) != 0)
719 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
721 if ((aflags
& BSF_FUNCTION
) != 0)
726 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
728 if ((aflags
& BSF_LOCAL
) != 0)
733 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
735 if ((aflags
& BSF_GLOBAL
) != 0)
741 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
742 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
747 if ((a
->flags
& BSF_SYNTHETIC
) == 0)
748 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
750 if ((b
->flags
& BSF_SYNTHETIC
) == 0)
751 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
753 return asz
> bsz
? -1 : 1;
756 /* Symbols that start with '.' might be section names, so sort them
757 after symbols that don't start with '.'. */
758 if (an
[0] == '.' && bn
[0] != '.')
760 if (an
[0] != '.' && bn
[0] == '.')
763 /* Finally, if we can't distinguish them in any other way, try to
764 get consistent results by sorting the symbols by name. */
765 return strcmp (an
, bn
);
768 /* Sort relocs into address order. */
771 compare_relocs (const void *ap
, const void *bp
)
773 const arelent
*a
= * (const arelent
**) ap
;
774 const arelent
*b
= * (const arelent
**) bp
;
776 if (a
->address
> b
->address
)
778 else if (a
->address
< b
->address
)
781 /* So that associated relocations tied to the same address show up
782 in the correct order, we don't do any further sorting. */
791 /* Print an address (VMA) to the output stream in INFO.
792 If SKIP_ZEROES is TRUE, omit leading zeroes. */
795 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
796 bfd_boolean skip_zeroes
)
800 struct objdump_disasm_info
*aux
;
802 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
803 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
808 for (p
= buf
; *p
== '0'; ++p
)
813 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
816 /* Print the name of a symbol. */
819 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
823 const char *name
, *version_string
= NULL
;
824 bfd_boolean hidden
= FALSE
;
827 name
= bfd_asymbol_name (sym
);
828 if (do_demangle
&& name
[0] != '\0')
830 /* Demangle the name. */
831 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
836 if ((sym
->flags
& BSF_SYNTHETIC
) == 0)
837 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
839 if (bfd_is_und_section (bfd_get_section (sym
)))
844 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
845 if (version_string
&& *version_string
!= '\0')
846 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
852 if (version_string
&& *version_string
!= '\0')
853 printf (hidden
? "@%s" : "@@%s", version_string
);
860 /* Locate a symbol given a bfd and a section (from INFO->application_data),
861 and a VMA. If INFO->application_data->require_sec is TRUE, then always
862 require the symbol to be in the section. Returns NULL if there is no
863 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
864 of the symbol in sorted_syms. */
867 find_symbol_for_address (bfd_vma vma
,
868 struct disassemble_info
*inf
,
871 /* @@ Would it speed things up to cache the last two symbols returned,
872 and maybe their address ranges? For many processors, only one memory
873 operand can be present at a time, so the 2-entry cache wouldn't be
874 constantly churned by code doing heavy memory accesses. */
876 /* Indices in `sorted_syms'. */
878 long max_count
= sorted_symcount
;
880 struct objdump_disasm_info
*aux
;
884 bfd_boolean want_section
;
886 if (sorted_symcount
< 1)
889 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
892 opb
= inf
->octets_per_byte
;
894 /* Perform a binary search looking for the closest symbol to the
895 required value. We are searching the range (min, max_count]. */
896 while (min
+ 1 < max_count
)
900 thisplace
= (max_count
+ min
) / 2;
901 sym
= sorted_syms
[thisplace
];
903 if (bfd_asymbol_value (sym
) > vma
)
904 max_count
= thisplace
;
905 else if (bfd_asymbol_value (sym
) < vma
)
914 /* The symbol we want is now in min, the low end of the range we
915 were searching. If there are several symbols with the same
916 value, we want the first one. */
919 && (bfd_asymbol_value (sorted_syms
[thisplace
])
920 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
923 /* Prefer a symbol in the current section if we have multple symbols
924 with the same value, as can occur with overlays or zero size
927 while (min
< max_count
928 && (bfd_asymbol_value (sorted_syms
[min
])
929 == bfd_asymbol_value (sorted_syms
[thisplace
])))
931 if (sorted_syms
[min
]->section
== sec
932 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
939 return sorted_syms
[thisplace
];
944 /* If the file is relocatable, and the symbol could be from this
945 section, prefer a symbol from this section over symbols from
946 others, even if the other symbol's value might be closer.
948 Note that this may be wrong for some symbol references if the
949 sections have overlapping memory ranges, but in that case there's
950 no way to tell what's desired without looking at the relocation
953 Also give the target a chance to reject symbols. */
954 want_section
= (aux
->require_sec
955 || ((abfd
->flags
& HAS_RELOC
) != 0
956 && vma
>= bfd_get_section_vma (abfd
, sec
)
957 && vma
< (bfd_get_section_vma (abfd
, sec
)
958 + bfd_section_size (abfd
, sec
) / opb
)));
959 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
960 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
963 long newplace
= sorted_symcount
;
965 for (i
= min
- 1; i
>= 0; i
--)
967 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
968 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
970 if (newplace
== sorted_symcount
)
973 if (bfd_asymbol_value (sorted_syms
[i
])
974 != bfd_asymbol_value (sorted_syms
[newplace
]))
977 /* Remember this symbol and keep searching until we reach
978 an earlier address. */
983 if (newplace
!= sorted_symcount
)
984 thisplace
= newplace
;
987 /* We didn't find a good symbol with a smaller value.
988 Look for one with a larger value. */
989 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
991 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
992 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
1000 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
1001 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
1002 /* There is no suitable symbol. */
1009 return sorted_syms
[thisplace
];
1012 /* Print an address and the offset to the nearest symbol. */
1015 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1016 bfd_vma vma
, struct disassemble_info
*inf
,
1017 bfd_boolean skip_zeroes
)
1019 objdump_print_value (vma
, inf
, skip_zeroes
);
1025 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1026 bfd_get_section_name (abfd
, sec
));
1027 secaddr
= bfd_get_section_vma (abfd
, sec
);
1030 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1031 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1033 else if (vma
> secaddr
)
1035 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1036 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1038 (*inf
->fprintf_func
) (inf
->stream
, ">");
1042 (*inf
->fprintf_func
) (inf
->stream
, " <");
1043 objdump_print_symname (abfd
, inf
, sym
);
1044 if (bfd_asymbol_value (sym
) > vma
)
1046 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1047 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1049 else if (vma
> bfd_asymbol_value (sym
))
1051 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1052 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1054 (*inf
->fprintf_func
) (inf
->stream
, ">");
1057 if (display_file_offsets
)
1058 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1059 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1062 /* Print an address (VMA), symbolically if possible.
1063 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1066 objdump_print_addr (bfd_vma vma
,
1067 struct disassemble_info
*inf
,
1068 bfd_boolean skip_zeroes
)
1070 struct objdump_disasm_info
*aux
;
1071 asymbol
*sym
= NULL
;
1072 bfd_boolean skip_find
= FALSE
;
1074 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1076 if (sorted_symcount
< 1)
1078 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1079 objdump_print_value (vma
, inf
, skip_zeroes
);
1081 if (display_file_offsets
)
1082 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1083 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1087 if (aux
->reloc
!= NULL
1088 && aux
->reloc
->sym_ptr_ptr
!= NULL
1089 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1091 sym
= * aux
->reloc
->sym_ptr_ptr
;
1093 /* Adjust the vma to the reloc. */
1094 vma
+= bfd_asymbol_value (sym
);
1096 if (bfd_is_und_section (bfd_get_section (sym
)))
1101 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1103 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1107 /* Print VMA to INFO. This function is passed to the disassembler
1111 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1113 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1116 /* Determine if the given address has a symbol associated with it. */
1119 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1123 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1125 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1128 /* Hold the last function name and the last line number we displayed
1129 in a disassembly. */
1131 static char *prev_functionname
;
1132 static unsigned int prev_line
;
1133 static unsigned int prev_discriminator
;
1135 /* We keep a list of all files that we have seen when doing a
1136 disassembly with source, so that we know how much of the file to
1137 display. This can be important for inlined functions. */
1139 struct print_file_list
1141 struct print_file_list
*next
;
1142 const char *filename
;
1143 const char *modname
;
1146 const char **linemap
;
1149 unsigned max_printed
;
1153 static struct print_file_list
*print_files
;
1155 /* The number of preceding context lines to show when we start
1156 displaying a file for the first time. */
1158 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1160 /* Read a complete file into memory. */
1163 slurp_file (const char *fn
, size_t *size
)
1166 int ps
= getpagesize ();
1171 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1175 if (fstat (fd
, &st
) < 0)
1182 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1183 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1184 if (map
!= (char *) -1L)
1190 map
= (const char *) malloc (*size
);
1191 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1193 free ((void *) map
);
1200 #define line_map_decrease 5
1202 /* Precompute array of lines for a mapped file. */
1204 static const char **
1205 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1207 const char *p
, *lstart
, *end
;
1208 int chars_per_line
= 45; /* First iteration will use 40. */
1209 unsigned int lineno
;
1210 const char **linemap
= NULL
;
1211 unsigned long line_map_size
= 0;
1217 for (p
= map
; p
< end
; p
++)
1221 if (p
+ 1 < end
&& p
[1] == '\r')
1224 else if (*p
== '\r')
1226 if (p
+ 1 < end
&& p
[1] == '\n')
1232 /* End of line found. */
1234 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1236 unsigned long newsize
;
1238 chars_per_line
-= line_map_decrease
;
1239 if (chars_per_line
<= 1)
1241 line_map_size
= size
/ chars_per_line
+ 1;
1242 if (line_map_size
< lineno
+ 1)
1243 line_map_size
= lineno
+ 1;
1244 newsize
= line_map_size
* sizeof (char *);
1245 linemap
= (const char **) xrealloc (linemap
, newsize
);
1248 linemap
[lineno
++] = lstart
;
1256 /* Tries to open MODNAME, and if successful adds a node to print_files
1257 linked list and returns that node. Returns NULL on failure. */
1259 static struct print_file_list
*
1260 try_print_file_open (const char *origname
, const char *modname
)
1262 struct print_file_list
*p
;
1264 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1266 p
->map
= slurp_file (modname
, &p
->mapsize
);
1273 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1276 p
->filename
= origname
;
1277 p
->modname
= modname
;
1278 p
->next
= print_files
;
1284 /* If the source file, as described in the symtab, is not found
1285 try to locate it in one of the paths specified with -I
1286 If found, add location to print_files linked list. */
1288 static struct print_file_list
*
1289 update_source_path (const char *filename
)
1291 struct print_file_list
*p
;
1295 p
= try_print_file_open (filename
, filename
);
1299 if (include_path_count
== 0)
1302 /* Get the name of the file. */
1303 fname
= lbasename (filename
);
1305 /* If file exists under a new path, we need to add it to the list
1306 so that show_line knows about it. */
1307 for (i
= 0; i
< include_path_count
; i
++)
1309 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1311 p
= try_print_file_open (filename
, modname
);
1321 /* Print a source file line. */
1324 print_line (struct print_file_list
*p
, unsigned int linenum
)
1330 if (linenum
>= p
->maxline
)
1332 l
= p
->linemap
[linenum
];
1333 /* Test fwrite return value to quiet glibc warning. */
1334 len
= strcspn (l
, "\n\r");
1335 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1339 /* Print a range of source code lines. */
1342 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1346 while (start
<= end
)
1348 print_line (p
, start
);
1353 /* Show the line number, or the source line, in a disassembly
1357 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1359 const char *filename
;
1360 const char *functionname
;
1361 unsigned int linenumber
;
1362 unsigned int discriminator
;
1366 if (! with_line_numbers
&& ! with_source_code
)
1369 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1370 &filename
, &functionname
,
1371 &linenumber
, &discriminator
))
1374 if (filename
!= NULL
&& *filename
== '\0')
1376 if (functionname
!= NULL
&& *functionname
== '\0')
1377 functionname
= NULL
;
1380 && IS_ABSOLUTE_PATH (filename
)
1384 const char *fname
= filename
;
1386 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1389 memcpy (path
, prefix
, prefix_length
);
1390 path_up
= path
+ prefix_length
;
1392 /* Build relocated filename, stripping off leading directories
1393 from the initial filename if requested. */
1394 if (prefix_strip
> 0)
1399 /* Skip selected directory levels. */
1400 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1401 if (IS_DIR_SEPARATOR(*s
))
1408 /* Update complete filename. */
1409 strncpy (path_up
, fname
, PATH_MAX
);
1410 path_up
[PATH_MAX
] = '\0';
1418 if (with_line_numbers
)
1420 if (functionname
!= NULL
1421 && (prev_functionname
== NULL
1422 || strcmp (functionname
, prev_functionname
) != 0))
1423 printf ("%s():\n", functionname
);
1424 if (linenumber
> 0 && (linenumber
!= prev_line
||
1425 (discriminator
!= prev_discriminator
)))
1427 if (discriminator
> 0)
1428 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1429 linenumber
, discriminator
);
1431 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1435 if (with_source_code
1439 struct print_file_list
**pp
, *p
;
1442 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1443 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1450 filename
= xstrdup (filename
);
1451 p
= update_source_path (filename
);
1454 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1456 if (file_start_context
&& p
->first
)
1460 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1461 if (l
>= linenumber
)
1463 if (p
->max_printed
>= l
)
1465 if (p
->max_printed
< linenumber
)
1466 l
= p
->max_printed
+ 1;
1471 dump_lines (p
, l
, linenumber
);
1472 if (p
->max_printed
< linenumber
)
1473 p
->max_printed
= linenumber
;
1474 p
->last_line
= linenumber
;
1479 if (functionname
!= NULL
1480 && (prev_functionname
== NULL
1481 || strcmp (functionname
, prev_functionname
) != 0))
1483 if (prev_functionname
!= NULL
)
1484 free (prev_functionname
);
1485 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1486 strcpy (prev_functionname
, functionname
);
1489 if (linenumber
> 0 && linenumber
!= prev_line
)
1490 prev_line
= linenumber
;
1492 if (discriminator
!= prev_discriminator
)
1493 prev_discriminator
= discriminator
;
1499 /* Pseudo FILE object for strings. */
1507 /* sprintf to a "stream". */
1509 static int ATTRIBUTE_PRINTF_2
1510 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1517 size_t space
= f
->alloc
- f
->pos
;
1519 va_start (args
, format
);
1520 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1526 f
->alloc
= (f
->alloc
+ n
) * 2;
1527 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1534 /* The number of zeroes we want to see before we start skipping them.
1535 The number is arbitrarily chosen. */
1537 #define DEFAULT_SKIP_ZEROES 8
1539 /* The number of zeroes to skip at the end of a section. If the
1540 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1541 SKIP_ZEROES, they will be disassembled. If there are fewer than
1542 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1543 attempt to avoid disassembling zeroes inserted by section
1546 #define DEFAULT_SKIP_ZEROES_AT_END 3
1548 /* Disassemble some data in memory between given values. */
1551 disassemble_bytes (struct disassemble_info
* inf
,
1552 disassembler_ftype disassemble_fn
,
1555 bfd_vma start_offset
,
1556 bfd_vma stop_offset
,
1559 arelent
** relppend
)
1561 struct objdump_disasm_info
*aux
;
1563 int octets_per_line
;
1564 int skip_addr_chars
;
1565 bfd_vma addr_offset
;
1566 unsigned int opb
= inf
->octets_per_byte
;
1567 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1568 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1572 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1576 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1580 octets_per_line
= insn_width
;
1582 octets_per_line
= 4;
1584 octets_per_line
= 16;
1586 /* Figure out how many characters to skip at the start of an
1587 address, to make the disassembly look nicer. We discard leading
1588 zeroes in chunks of 4, ensuring that there is always a leading
1590 skip_addr_chars
= 0;
1591 if (! prefix_addresses
)
1595 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1597 while (buf
[skip_addr_chars
] == '0')
1600 /* Don't discard zeros on overflow. */
1601 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1602 skip_addr_chars
= 0;
1604 if (skip_addr_chars
!= 0)
1605 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1608 inf
->insn_info_valid
= 0;
1610 addr_offset
= start_offset
;
1611 while (addr_offset
< stop_offset
)
1614 bfd_boolean need_nl
= FALSE
;
1615 int previous_octets
;
1617 /* Remember the length of the previous instruction. */
1618 previous_octets
= octets
;
1621 /* Make sure we don't use relocs from previous instructions. */
1624 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1626 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1629 if (! disassemble_zeroes
1630 && (inf
->insn_info_valid
== 0
1631 || inf
->branch_delay_insns
== 0)
1632 && (z
- addr_offset
* opb
>= skip_zeroes
1633 || (z
== stop_offset
* opb
&&
1634 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1636 /* If there are more nonzero octets to follow, we only skip
1637 zeroes in multiples of 4, to try to avoid running over
1638 the start of an instruction which happens to start with
1640 if (z
!= stop_offset
* opb
)
1641 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1643 octets
= z
- addr_offset
* opb
;
1645 /* If we are going to display more data, and we are displaying
1646 file offsets, then tell the user how many zeroes we skip
1647 and the file offset from where we resume dumping. */
1648 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1649 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1651 (unsigned long) (section
->filepos
1652 + (addr_offset
+ (octets
/ opb
))));
1662 if (with_line_numbers
|| with_source_code
)
1663 show_line (aux
->abfd
, section
, addr_offset
);
1665 if (! prefix_addresses
)
1669 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1670 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1674 printf ("%s:\t", buf
+ skip_addr_chars
);
1678 aux
->require_sec
= TRUE
;
1679 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1680 aux
->require_sec
= FALSE
;
1687 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1688 inf
->stream
= &sfile
;
1689 inf
->bytes_per_line
= 0;
1690 inf
->bytes_per_chunk
= 0;
1691 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1693 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1695 if (inf
->disassembler_needs_relocs
1696 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1697 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1698 && *relppp
< relppend
)
1700 bfd_signed_vma distance_to_rel
;
1702 distance_to_rel
= (**relppp
)->address
1703 - (rel_offset
+ addr_offset
);
1705 /* Check to see if the current reloc is associated with
1706 the instruction that we are about to disassemble. */
1707 if (distance_to_rel
== 0
1708 /* FIXME: This is wrong. We are trying to catch
1709 relocs that are addressed part way through the
1710 current instruction, as might happen with a packed
1711 VLIW instruction. Unfortunately we do not know the
1712 length of the current instruction since we have not
1713 disassembled it yet. Instead we take a guess based
1714 upon the length of the previous instruction. The
1715 proper solution is to have a new target-specific
1716 disassembler function which just returns the length
1717 of an instruction at a given address without trying
1718 to display its disassembly. */
1719 || (distance_to_rel
> 0
1720 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1722 inf
->flags
|= INSN_HAS_RELOC
;
1723 aux
->reloc
= **relppp
;
1727 if (! disassemble_all
1728 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1729 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1730 /* Set a stop_vma so that the disassembler will not read
1731 beyond the next symbol. We assume that symbols appear on
1732 the boundaries between instructions. We only do this when
1733 disassembling code of course, and when -D is in effect. */
1734 inf
->stop_vma
= section
->vma
+ stop_offset
;
1736 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1739 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1740 inf
->stream
= stdout
;
1741 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1742 octets_per_line
= inf
->bytes_per_line
;
1743 if (octets
< (int) opb
)
1746 printf ("%s\n", sfile
.buffer
);
1749 non_fatal (_("disassemble_fn returned length %d"),
1760 octets
= octets_per_line
;
1761 if (addr_offset
+ octets
/ opb
> stop_offset
)
1762 octets
= (stop_offset
- addr_offset
) * opb
;
1764 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1766 if (ISPRINT (data
[j
]))
1767 buf
[j
- addr_offset
* opb
] = data
[j
];
1769 buf
[j
- addr_offset
* opb
] = '.';
1771 buf
[j
- addr_offset
* opb
] = '\0';
1774 if (prefix_addresses
1776 : show_raw_insn
>= 0)
1780 /* If ! prefix_addresses and ! wide_output, we print
1781 octets_per_line octets per line. */
1783 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1784 pb
= octets_per_line
;
1786 if (inf
->bytes_per_chunk
)
1787 bpc
= inf
->bytes_per_chunk
;
1791 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1795 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1797 for (k
= bpc
- 1; k
>= 0; k
--)
1798 printf ("%02x", (unsigned) data
[j
+ k
]);
1803 for (k
= 0; k
< bpc
; k
++)
1804 printf ("%02x", (unsigned) data
[j
+ k
]);
1809 for (; pb
< octets_per_line
; pb
+= bpc
)
1813 for (k
= 0; k
< bpc
; k
++)
1818 /* Separate raw data from instruction by extra space. */
1828 printf ("%s", sfile
.buffer
);
1830 if (prefix_addresses
1832 : show_raw_insn
>= 0)
1840 j
= addr_offset
* opb
+ pb
;
1842 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1843 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1847 printf ("%s:\t", buf
+ skip_addr_chars
);
1849 pb
+= octets_per_line
;
1852 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1856 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1858 for (k
= bpc
- 1; k
>= 0; k
--)
1859 printf ("%02x", (unsigned) data
[j
+ k
]);
1864 for (k
= 0; k
< bpc
; k
++)
1865 printf ("%02x", (unsigned) data
[j
+ k
]);
1878 while ((*relppp
) < relppend
1879 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1881 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1892 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1895 if (q
->howto
== NULL
)
1896 printf (": *unknown*\t");
1897 else if (q
->howto
->name
)
1898 printf (": %s\t", q
->howto
->name
);
1900 printf (": %d\t", q
->howto
->type
);
1902 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1903 printf ("*unknown*");
1906 const char *sym_name
;
1908 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1909 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1910 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1915 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1916 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1917 if (sym_name
== NULL
|| *sym_name
== '\0')
1918 sym_name
= "*unknown*";
1919 printf ("%s", sym_name
);
1925 bfd_signed_vma addend
= q
->addend
;
1933 objdump_print_value (addend
, inf
, TRUE
);
1945 addr_offset
+= octets
/ opb
;
1948 free (sfile
.buffer
);
1952 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1954 const struct elf_backend_data
* bed
;
1955 bfd_vma sign_adjust
= 0;
1956 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1957 struct objdump_disasm_info
* paux
;
1958 unsigned int opb
= pinfo
->octets_per_byte
;
1959 bfd_byte
* data
= NULL
;
1960 bfd_size_type datasize
= 0;
1961 arelent
** rel_pp
= NULL
;
1962 arelent
** rel_ppstart
= NULL
;
1963 arelent
** rel_ppend
;
1964 bfd_vma stop_offset
;
1965 asymbol
* sym
= NULL
;
1969 unsigned long addr_offset
;
1971 /* Sections that do not contain machine
1972 code are not normally disassembled. */
1973 if (! disassemble_all
1974 && only_list
== NULL
1975 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1976 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1979 if (! process_section_p (section
))
1982 datasize
= bfd_get_section_size (section
);
1986 if (start_address
== (bfd_vma
) -1
1987 || start_address
< section
->vma
)
1990 addr_offset
= start_address
- section
->vma
;
1992 if (stop_address
== (bfd_vma
) -1)
1993 stop_offset
= datasize
/ opb
;
1996 if (stop_address
< section
->vma
)
1999 stop_offset
= stop_address
- section
->vma
;
2000 if (stop_offset
> datasize
/ opb
)
2001 stop_offset
= datasize
/ opb
;
2004 if (addr_offset
>= stop_offset
)
2007 /* Decide which set of relocs to use. Load them if necessary. */
2008 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2009 if (paux
->dynrelbuf
)
2011 rel_pp
= paux
->dynrelbuf
;
2012 rel_count
= paux
->dynrelcount
;
2013 /* Dynamic reloc addresses are absolute, non-dynamic are section
2014 relative. REL_OFFSET specifies the reloc address corresponding
2015 to the start of this section. */
2016 rel_offset
= section
->vma
;
2024 if ((section
->flags
& SEC_RELOC
) != 0
2025 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2029 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2031 bfd_fatal (bfd_get_filename (abfd
));
2035 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2036 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2038 bfd_fatal (bfd_get_filename (abfd
));
2040 /* Sort the relocs by address. */
2041 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2045 rel_ppend
= rel_pp
+ rel_count
;
2047 data
= (bfd_byte
*) xmalloc (datasize
);
2049 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2051 paux
->sec
= section
;
2052 pinfo
->buffer
= data
;
2053 pinfo
->buffer_vma
= section
->vma
;
2054 pinfo
->buffer_length
= datasize
;
2055 pinfo
->section
= section
;
2057 /* Skip over the relocs belonging to addresses below the
2059 while (rel_pp
< rel_ppend
2060 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2063 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2065 /* Find the nearest symbol forwards from our current position. */
2066 paux
->require_sec
= TRUE
;
2067 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2068 (struct disassemble_info
*) inf
,
2070 paux
->require_sec
= FALSE
;
2072 /* PR 9774: If the target used signed addresses then we must make
2073 sure that we sign extend the value that we calculate for 'addr'
2074 in the loop below. */
2075 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2076 && (bed
= get_elf_backend_data (abfd
)) != NULL
2077 && bed
->sign_extend_vma
)
2078 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2080 /* Disassemble a block of instructions up to the address associated with
2081 the symbol we have just found. Then print the symbol and find the
2082 next symbol on. Repeat until we have disassembled the entire section
2083 or we have reached the end of the address range we are interested in. */
2084 while (addr_offset
< stop_offset
)
2088 bfd_vma nextstop_offset
;
2091 addr
= section
->vma
+ addr_offset
;
2092 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2094 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2099 (x
< sorted_symcount
2100 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2104 pinfo
->symbols
= sorted_syms
+ place
;
2105 pinfo
->num_symbols
= x
- place
;
2106 pinfo
->symtab_pos
= place
;
2110 pinfo
->symbols
= NULL
;
2111 pinfo
->num_symbols
= 0;
2112 pinfo
->symtab_pos
= -1;
2115 if (! prefix_addresses
)
2117 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2118 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2120 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2123 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2125 else if (sym
== NULL
)
2129 #define is_valid_next_sym(SYM) \
2130 ((SYM)->section == section \
2131 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2132 && pinfo->symbol_is_valid (SYM, pinfo))
2134 /* Search forward for the next appropriate symbol in
2135 SECTION. Note that all the symbols are sorted
2136 together into one big array, and that some sections
2137 may have overlapping addresses. */
2138 while (place
< sorted_symcount
2139 && ! is_valid_next_sym (sorted_syms
[place
]))
2142 if (place
>= sorted_symcount
)
2145 nextsym
= sorted_syms
[place
];
2148 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2149 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2150 else if (nextsym
== NULL
)
2151 nextstop_offset
= stop_offset
;
2153 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2155 if (nextstop_offset
> stop_offset
2156 || nextstop_offset
<= addr_offset
)
2157 nextstop_offset
= stop_offset
;
2159 /* If a symbol is explicitly marked as being an object
2160 rather than a function, just dump the bytes without
2161 disassembling them. */
2164 || sym
->section
!= section
2165 || bfd_asymbol_value (sym
) > addr
2166 || ((sym
->flags
& BSF_OBJECT
) == 0
2167 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2169 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2171 || (sym
->flags
& BSF_FUNCTION
) != 0)
2176 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2177 addr_offset
, nextstop_offset
,
2178 rel_offset
, &rel_pp
, rel_ppend
);
2180 addr_offset
= nextstop_offset
;
2186 if (rel_ppstart
!= NULL
)
2190 /* Disassemble the contents of an object file. */
2193 disassemble_data (bfd
*abfd
)
2195 struct disassemble_info disasm_info
;
2196 struct objdump_disasm_info aux
;
2200 prev_functionname
= NULL
;
2202 prev_discriminator
= 0;
2204 /* We make a copy of syms to sort. We don't want to sort syms
2205 because that will screw up the relocs. */
2206 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2207 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2208 * sizeof (asymbol
*));
2209 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2210 sorted_symcount
* sizeof (asymbol
*));
2212 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2214 for (i
= 0; i
< synthcount
; ++i
)
2216 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2220 /* Sort the symbols into section and symbol order. */
2221 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2223 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2225 disasm_info
.application_data
= (void *) &aux
;
2227 aux
.require_sec
= FALSE
;
2228 aux
.dynrelbuf
= NULL
;
2229 aux
.dynrelcount
= 0;
2232 disasm_info
.print_address_func
= objdump_print_address
;
2233 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2235 if (machine
!= NULL
)
2237 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2240 fatal (_("can't use supplied machine %s"), machine
);
2242 abfd
->arch_info
= inf
;
2245 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2247 struct bfd_target
*xvec
;
2249 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2250 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2251 xvec
->byteorder
= endian
;
2255 /* Use libopcodes to locate a suitable disassembler. */
2256 aux
.disassemble_fn
= disassembler (abfd
);
2257 if (!aux
.disassemble_fn
)
2259 non_fatal (_("can't disassemble for architecture %s\n"),
2260 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2265 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2266 disasm_info
.arch
= bfd_get_arch (abfd
);
2267 disasm_info
.mach
= bfd_get_mach (abfd
);
2268 disasm_info
.disassembler_options
= disassembler_options
;
2269 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2270 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2271 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2272 disasm_info
.disassembler_needs_relocs
= FALSE
;
2274 if (bfd_big_endian (abfd
))
2275 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2276 else if (bfd_little_endian (abfd
))
2277 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2279 /* ??? Aborting here seems too drastic. We could default to big or little
2281 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2283 /* Allow the target to customize the info structure. */
2284 disassemble_init_for_target (& disasm_info
);
2286 /* Pre-load the dynamic relocs if we are going
2287 to be dumping them along with the disassembly. */
2288 if (dump_dynamic_reloc_info
)
2290 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2293 bfd_fatal (bfd_get_filename (abfd
));
2297 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2298 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2301 if (aux
.dynrelcount
< 0)
2302 bfd_fatal (bfd_get_filename (abfd
));
2304 /* Sort the relocs by address. */
2305 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2309 disasm_info
.symtab
= sorted_syms
;
2310 disasm_info
.symtab_size
= sorted_symcount
;
2312 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2314 if (aux
.dynrelbuf
!= NULL
)
2315 free (aux
.dynrelbuf
);
2320 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2321 asection
*sec
, void *file
)
2323 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2324 bfd
*abfd
= (bfd
*) file
;
2327 /* If it is already loaded, do nothing. */
2328 if (section
->start
!= NULL
)
2331 section
->reloc_info
= NULL
;
2332 section
->num_relocs
= 0;
2333 section
->address
= bfd_get_section_vma (abfd
, sec
);
2334 section
->size
= bfd_get_section_size (sec
);
2335 section
->start
= NULL
;
2336 section
->user_data
= sec
;
2337 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2341 free_debug_section (debug
);
2342 printf (_("\nCan't get contents for section '%s'.\n"),
2347 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2349 bfd_cache_section_contents (sec
, section
->start
);
2351 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2358 free_debug_section (debug
);
2359 printf (_("\nCan't get contents for section '%s'.\n"),
2366 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2369 unsigned long reloc_count
;
2372 relocs
= (arelent
**) xmalloc (reloc_size
);
2374 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2375 if (reloc_count
== 0)
2379 section
->reloc_info
= relocs
;
2380 section
->num_relocs
= reloc_count
;
2389 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2394 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2397 relocs
= (arelent
**) dsec
->reloc_info
;
2399 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2400 if (rp
->address
== offset
)
2407 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2409 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2410 bfd
*abfd
= (bfd
*) file
;
2413 /* If it is already loaded, do nothing. */
2414 if (section
->start
!= NULL
)
2417 /* Locate the debug section. */
2418 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2420 section
->name
= section
->uncompressed_name
;
2423 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2425 section
->name
= section
->compressed_name
;
2430 return load_specific_debug_section (debug
, sec
, file
);
2434 free_debug_section (enum dwarf_section_display_enum debug
)
2436 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2438 if (section
->start
== NULL
)
2441 /* PR 17512: file: 0f67f69d. */
2442 if (section
->user_data
!= NULL
)
2444 asection
* sec
= (asection
*) section
->user_data
;
2446 /* If we are freeing contents that are also pointed to by the BFD
2447 library's section structure then make sure to update those pointers
2448 too. Otherwise, the next time we try to load data for this section
2449 we can end up using a stale pointer. */
2450 if (section
->start
== sec
->contents
)
2452 sec
->contents
= NULL
;
2453 sec
->flags
&= ~ SEC_IN_MEMORY
;
2454 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2458 free ((char *) section
->start
);
2459 section
->start
= NULL
;
2460 section
->address
= 0;
2465 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2466 void *arg ATTRIBUTE_UNUSED
)
2468 const char *name
= bfd_get_section_name (abfd
, section
);
2472 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2473 match
= ".debug_info";
2477 for (i
= 0; i
< max
; i
++)
2478 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2479 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2480 && debug_displays
[i
].enabled
!= NULL
2481 && *debug_displays
[i
].enabled
)
2483 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2485 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2486 sec
->name
= sec
->uncompressed_name
;
2488 sec
->name
= sec
->compressed_name
;
2489 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2492 debug_displays
[i
].display (sec
, abfd
);
2494 if (i
!= info
&& i
!= abbrev
)
2495 free_debug_section ((enum dwarf_section_display_enum
) i
);
2501 /* Dump the dwarf debugging information. */
2504 dump_dwarf (bfd
*abfd
)
2506 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2508 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2510 if (bfd_big_endian (abfd
))
2511 byte_get
= byte_get_big_endian
;
2512 else if (bfd_little_endian (abfd
))
2513 byte_get
= byte_get_little_endian
;
2515 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2517 warn (_("File %s does not contain any dwarf debug information\n"),
2518 bfd_get_filename (abfd
));
2522 switch (bfd_get_arch (abfd
))
2525 switch (bfd_get_mach (abfd
))
2527 case bfd_mach_x86_64
:
2528 case bfd_mach_x86_64_intel_syntax
:
2529 case bfd_mach_x86_64_nacl
:
2530 case bfd_mach_x64_32
:
2531 case bfd_mach_x64_32_intel_syntax
:
2532 case bfd_mach_x64_32_nacl
:
2533 init_dwarf_regnames_x86_64 ();
2537 init_dwarf_regnames_i386 ();
2542 case bfd_arch_iamcu
:
2543 init_dwarf_regnames_iamcu ();
2546 case bfd_arch_aarch64
:
2547 init_dwarf_regnames_aarch64();
2551 init_dwarf_regnames_s390 ();
2558 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2560 free_debug_memory ();
2563 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2564 it. Return NULL on failure. */
2567 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2573 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2574 if (stabsect
== NULL
)
2576 printf (_("No %s section present\n\n"), sect_name
);
2580 size
= bfd_section_size (abfd
, stabsect
);
2581 contents
= (char *) xmalloc (size
);
2583 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2585 non_fatal (_("reading %s section of %s failed: %s"),
2586 sect_name
, bfd_get_filename (abfd
),
2587 bfd_errmsg (bfd_get_error ()));
2598 /* Stabs entries use a 12 byte format:
2599 4 byte string table index
2601 1 byte stab other field
2602 2 byte stab desc field
2604 FIXME: This will have to change for a 64 bit object format. */
2606 #define STRDXOFF (0)
2608 #define OTHEROFF (5)
2611 #define STABSIZE (12)
2613 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2614 using string table section STRSECT_NAME (in `strtab'). */
2617 print_section_stabs (bfd
*abfd
,
2618 const char *stabsect_name
,
2619 unsigned *string_offset_ptr
)
2622 unsigned file_string_table_offset
= 0;
2623 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2624 bfd_byte
*stabp
, *stabs_end
;
2627 stabs_end
= stabp
+ stab_size
;
2629 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2630 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2632 /* Loop through all symbols and print them.
2634 We start the index at -1 because there is a dummy symbol on
2635 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2636 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2640 unsigned char type
, other
;
2641 unsigned short desc
;
2644 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2645 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2646 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2647 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2648 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2650 printf ("\n%-6d ", i
);
2651 /* Either print the stab name, or, if unnamed, print its number
2652 again (makes consistent formatting for tools like awk). */
2653 name
= bfd_get_stab_name (type
);
2655 printf ("%-6s", name
);
2656 else if (type
== N_UNDF
)
2659 printf ("%-6d", type
);
2660 printf (" %-6d %-6d ", other
, desc
);
2661 bfd_printf_vma (abfd
, value
);
2662 printf (" %-6lu", strx
);
2664 /* Symbols with type == 0 (N_UNDF) specify the length of the
2665 string table associated with this file. We use that info
2666 to know how to relocate the *next* file's string table indices. */
2669 file_string_table_offset
= next_file_string_table_offset
;
2670 next_file_string_table_offset
+= value
;
2674 bfd_size_type amt
= strx
+ file_string_table_offset
;
2676 /* Using the (possibly updated) string table offset, print the
2677 string (if any) associated with this symbol. */
2678 if (amt
< stabstr_size
)
2679 /* PR 17512: file: 079-79389-0.001:0.1. */
2680 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2686 *string_offset_ptr
= next_file_string_table_offset
;
2691 const char * section_name
;
2692 const char * string_section_name
;
2693 unsigned string_offset
;
2698 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2701 stab_section_names
* sought
= (stab_section_names
*) names
;
2703 /* Check for section names for which stabsect_name is a prefix, to
2704 handle .stab.N, etc. */
2705 len
= strlen (sought
->section_name
);
2707 /* If the prefix matches, and the files section name ends with a
2708 nul or a digit, then we match. I.e., we want either an exact
2709 match or a section followed by a number. */
2710 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2711 && (section
->name
[len
] == 0
2712 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2715 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2720 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2723 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2729 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2731 stab_section_names s
;
2733 s
.section_name
= stabsect_name
;
2734 s
.string_section_name
= strsect_name
;
2735 s
.string_offset
= 0;
2737 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2743 /* Dump the any sections containing stabs debugging information. */
2746 dump_stabs (bfd
*abfd
)
2748 dump_stabs_section (abfd
, ".stab", ".stabstr");
2749 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2750 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2753 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2755 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2759 dump_bfd_header (bfd
*abfd
)
2763 printf (_("architecture: %s, "),
2764 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2765 bfd_get_mach (abfd
)));
2766 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2768 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2769 PF (HAS_RELOC
, "HAS_RELOC");
2770 PF (EXEC_P
, "EXEC_P");
2771 PF (HAS_LINENO
, "HAS_LINENO");
2772 PF (HAS_DEBUG
, "HAS_DEBUG");
2773 PF (HAS_SYMS
, "HAS_SYMS");
2774 PF (HAS_LOCALS
, "HAS_LOCALS");
2775 PF (DYNAMIC
, "DYNAMIC");
2776 PF (WP_TEXT
, "WP_TEXT");
2777 PF (D_PAGED
, "D_PAGED");
2778 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2779 printf (_("\nstart address 0x"));
2780 bfd_printf_vma (abfd
, abfd
->start_address
);
2786 dump_bfd_private_header (bfd
*abfd
)
2788 bfd_print_private_bfd_data (abfd
, stdout
);
2792 dump_target_specific (bfd
*abfd
)
2794 const struct objdump_private_desc
* const *desc
;
2795 struct objdump_private_option
*opt
;
2798 /* Find the desc. */
2799 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2800 if ((*desc
)->filter (abfd
))
2805 non_fatal (_("option -P/--private not supported by this file"));
2809 /* Clear all options. */
2810 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2811 opt
->selected
= FALSE
;
2813 /* Decode options. */
2814 b
= dump_private_options
;
2817 e
= strchr (b
, ',');
2822 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2823 if (strcmp (opt
->name
, b
) == 0)
2825 opt
->selected
= TRUE
;
2828 if (opt
->name
== NULL
)
2829 non_fatal (_("target specific dump '%s' not supported"), b
);
2840 (*desc
)->dump (abfd
);
2843 /* Display a section in hexadecimal format with associated characters.
2844 Each line prefixed by the zero padded address. */
2847 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2850 bfd_size_type datasize
;
2851 bfd_vma addr_offset
;
2852 bfd_vma start_offset
;
2853 bfd_vma stop_offset
;
2854 unsigned int opb
= bfd_octets_per_byte (abfd
);
2855 /* Bytes per line. */
2856 const int onaline
= 16;
2861 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2864 if (! process_section_p (section
))
2867 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2870 /* Compute the address range to display. */
2871 if (start_address
== (bfd_vma
) -1
2872 || start_address
< section
->vma
)
2875 start_offset
= start_address
- section
->vma
;
2877 if (stop_address
== (bfd_vma
) -1)
2878 stop_offset
= datasize
/ opb
;
2881 if (stop_address
< section
->vma
)
2884 stop_offset
= stop_address
- section
->vma
;
2886 if (stop_offset
> datasize
/ opb
)
2887 stop_offset
= datasize
/ opb
;
2890 if (start_offset
>= stop_offset
)
2893 printf (_("Contents of section %s:"), section
->name
);
2894 if (display_file_offsets
)
2895 printf (_(" (Starting at file offset: 0x%lx)"),
2896 (unsigned long) (section
->filepos
+ start_offset
));
2899 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2901 non_fatal (_("Reading section %s failed because: %s"),
2902 section
->name
, bfd_errmsg (bfd_get_error ()));
2908 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2909 if (strlen (buf
) >= sizeof (buf
))
2913 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2915 count
= strlen (buf
) - count
;
2919 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2920 if (strlen (buf
) >= sizeof (buf
))
2924 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2926 count
= strlen (buf
) - count
;
2930 for (addr_offset
= start_offset
;
2931 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2935 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2936 count
= strlen (buf
);
2937 if ((size_t) count
>= sizeof (buf
))
2941 while (count
< width
)
2946 fputs (buf
+ count
- width
, stdout
);
2949 for (j
= addr_offset
* opb
;
2950 j
< addr_offset
* opb
+ onaline
; j
++)
2952 if (j
< stop_offset
* opb
)
2953 printf ("%02x", (unsigned) (data
[j
]));
2961 for (j
= addr_offset
* opb
;
2962 j
< addr_offset
* opb
+ onaline
; j
++)
2964 if (j
>= stop_offset
* opb
)
2967 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2974 /* Actually display the various requested regions. */
2977 dump_data (bfd
*abfd
)
2979 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2982 /* Should perhaps share code and display with nm? */
2985 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2994 max_count
= dynsymcount
;
2995 printf ("DYNAMIC SYMBOL TABLE:\n");
3000 max_count
= symcount
;
3001 printf ("SYMBOL TABLE:\n");
3005 printf (_("no symbols\n"));
3007 for (count
= 0; count
< max_count
; count
++)
3011 if (*current
== NULL
)
3012 printf (_("no information for symbol number %ld\n"), count
);
3014 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3015 printf (_("could not determine the type of symbol number %ld\n"),
3018 else if (process_section_p ((* current
)->section
)
3019 && (dump_special_syms
3020 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3022 const char *name
= (*current
)->name
;
3024 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3028 /* If we want to demangle the name, we demangle it
3029 here, and temporarily clobber it while calling
3030 bfd_print_symbol. FIXME: This is a gross hack. */
3031 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3033 (*current
)->name
= alloc
;
3034 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3035 bfd_print_symbol_all
);
3038 (*current
)->name
= name
;
3043 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3044 bfd_print_symbol_all
);
3054 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3057 char *last_filename
, *last_functionname
;
3058 unsigned int last_line
;
3059 unsigned int last_discriminator
;
3061 /* Get column headers lined up reasonably. */
3069 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3070 width
= strlen (buf
) - 7;
3072 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3075 last_filename
= NULL
;
3076 last_functionname
= NULL
;
3078 last_discriminator
= 0;
3080 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3083 const char *filename
, *functionname
;
3084 unsigned int linenumber
;
3085 unsigned int discriminator
;
3086 const char *sym_name
;
3087 const char *section_name
;
3088 bfd_vma addend2
= 0;
3090 if (start_address
!= (bfd_vma
) -1
3091 && q
->address
< start_address
)
3093 if (stop_address
!= (bfd_vma
) -1
3094 && q
->address
> stop_address
)
3097 if (with_line_numbers
3099 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3100 &filename
, &functionname
,
3101 &linenumber
, &discriminator
))
3103 if (functionname
!= NULL
3104 && (last_functionname
== NULL
3105 || strcmp (functionname
, last_functionname
) != 0))
3107 printf ("%s():\n", functionname
);
3108 if (last_functionname
!= NULL
)
3109 free (last_functionname
);
3110 last_functionname
= xstrdup (functionname
);
3114 && (linenumber
!= last_line
3115 || (filename
!= NULL
3116 && last_filename
!= NULL
3117 && filename_cmp (filename
, last_filename
) != 0)
3118 || (discriminator
!= last_discriminator
)))
3120 if (discriminator
> 0)
3121 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3123 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3124 linenumber
, discriminator
);
3125 last_line
= linenumber
;
3126 last_discriminator
= discriminator
;
3127 if (last_filename
!= NULL
)
3128 free (last_filename
);
3129 if (filename
== NULL
)
3130 last_filename
= NULL
;
3132 last_filename
= xstrdup (filename
);
3136 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3138 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3139 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3144 section_name
= NULL
;
3147 bfd_printf_vma (abfd
, q
->address
);
3148 if (q
->howto
== NULL
)
3149 printf (" *unknown* ");
3150 else if (q
->howto
->name
)
3152 const char *name
= q
->howto
->name
;
3154 /* R_SPARC_OLO10 relocations contain two addends.
3155 But because 'arelent' lacks enough storage to
3156 store them both, the 64-bit ELF Sparc backend
3157 records this as two relocations. One R_SPARC_LO10
3158 and one R_SPARC_13, both pointing to the same
3159 address. This is merely so that we have some
3160 place to store both addend fields.
3162 Undo this transformation, otherwise the output
3163 will be confusing. */
3164 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3165 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3167 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3169 arelent
*q2
= *(p
+ 1);
3172 && q
->address
== q2
->address
3173 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3175 name
= "R_SPARC_OLO10";
3176 addend2
= q2
->addend
;
3180 printf (" %-16s ", name
);
3183 printf (" %-16d ", q
->howto
->type
);
3187 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3191 if (section_name
== NULL
)
3192 section_name
= "*unknown*";
3193 printf ("[%s]", section_name
);
3198 bfd_signed_vma addend
= q
->addend
;
3206 bfd_printf_vma (abfd
, addend
);
3211 bfd_printf_vma (abfd
, addend2
);
3217 if (last_filename
!= NULL
)
3218 free (last_filename
);
3219 if (last_functionname
!= NULL
)
3220 free (last_functionname
);
3224 dump_relocs_in_section (bfd
*abfd
,
3226 void *dummy ATTRIBUTE_UNUSED
)
3232 if ( bfd_is_abs_section (section
)
3233 || bfd_is_und_section (section
)
3234 || bfd_is_com_section (section
)
3235 || (! process_section_p (section
))
3236 || ((section
->flags
& SEC_RELOC
) == 0))
3239 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3241 bfd_fatal (bfd_get_filename (abfd
));
3243 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3247 printf (" (none)\n\n");
3251 relpp
= (arelent
**) xmalloc (relsize
);
3252 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3257 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3258 bfd_fatal (_("error message was"));
3260 else if (relcount
== 0)
3261 printf (" (none)\n\n");
3265 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3272 dump_relocs (bfd
*abfd
)
3274 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3278 dump_dynamic_relocs (bfd
*abfd
)
3284 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3286 bfd_fatal (bfd_get_filename (abfd
));
3288 printf ("DYNAMIC RELOCATION RECORDS");
3291 printf (" (none)\n\n");
3294 relpp
= (arelent
**) xmalloc (relsize
);
3295 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3298 bfd_fatal (bfd_get_filename (abfd
));
3299 else if (relcount
== 0)
3300 printf (" (none)\n\n");
3304 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3311 /* Creates a table of paths, to search for source files. */
3314 add_include_path (const char *path
)
3318 include_path_count
++;
3319 include_paths
= (const char **)
3320 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3321 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3322 if (path
[1] == ':' && path
[2] == 0)
3323 path
= concat (path
, ".", (const char *) 0);
3325 include_paths
[include_path_count
- 1] = path
;
3329 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3333 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3335 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3336 section
->vma
+= adjust_section_vma
;
3338 section
->lma
+= adjust_section_vma
;
3342 /* Dump selected contents of ABFD. */
3345 dump_bfd (bfd
*abfd
)
3347 /* If we are adjusting section VMA's, change them all now. Changing
3348 the BFD information is a hack. However, we must do it, or
3349 bfd_find_nearest_line will not do the right thing. */
3350 if (adjust_section_vma
!= 0)
3352 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3353 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3356 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3357 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3360 print_arelt_descr (stdout
, abfd
, TRUE
);
3361 if (dump_file_header
)
3362 dump_bfd_header (abfd
);
3363 if (dump_private_headers
)
3364 dump_bfd_private_header (abfd
);
3365 if (dump_private_options
!= NULL
)
3366 dump_target_specific (abfd
);
3367 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3374 || dump_dwarf_section_info
)
3375 syms
= slurp_symtab (abfd
);
3377 if (dump_section_headers
)
3378 dump_headers (abfd
);
3380 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3381 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3382 dynsyms
= slurp_dynamic_symtab (abfd
);
3385 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3386 dynsymcount
, dynsyms
, &synthsyms
);
3392 dump_symbols (abfd
, FALSE
);
3393 if (dump_dynamic_symtab
)
3394 dump_symbols (abfd
, TRUE
);
3395 if (dump_dwarf_section_info
)
3397 if (dump_stab_section_info
)
3399 if (dump_reloc_info
&& ! disassemble
)
3401 if (dump_dynamic_reloc_info
&& ! disassemble
)
3402 dump_dynamic_relocs (abfd
);
3403 if (dump_section_contents
)
3406 disassemble_data (abfd
);
3412 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3413 if (dhandle
!= NULL
)
3415 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3417 dump_debugging_tags
? TRUE
: FALSE
))
3419 non_fatal (_("%s: printing debugging information failed"),
3420 bfd_get_filename (abfd
));
3424 /* PR 6483: If there was no STABS or IEEE debug
3425 info in the file, try DWARF instead. */
3426 else if (! dump_dwarf_section_info
)
3428 dwarf_select_sections_all ();
3457 display_object_bfd (bfd
*abfd
)
3461 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3467 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3469 nonfatal (bfd_get_filename (abfd
));
3470 list_matching_formats (matching
);
3475 if (bfd_get_error () != bfd_error_file_not_recognized
)
3477 nonfatal (bfd_get_filename (abfd
));
3481 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3487 nonfatal (bfd_get_filename (abfd
));
3489 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3491 list_matching_formats (matching
);
3497 display_any_bfd (bfd
*file
, int level
)
3499 /* Decompress sections unless dumping the section contents. */
3500 if (!dump_section_contents
)
3501 file
->flags
|= BFD_DECOMPRESS
;
3503 /* If the file is an archive, process all of its elements. */
3504 if (bfd_check_format (file
, bfd_archive
))
3507 bfd
*last_arfile
= NULL
;
3510 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3511 else if (level
> 100)
3513 /* Prevent corrupted files from spinning us into an
3514 infinite loop. 100 is an arbitrary heuristic. */
3515 fatal (_("Archive nesting is too deep"));
3519 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3523 bfd_set_error (bfd_error_no_error
);
3525 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3528 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3529 nonfatal (bfd_get_filename (file
));
3533 display_any_bfd (arfile
, level
+ 1);
3535 if (last_arfile
!= NULL
)
3537 bfd_close (last_arfile
);
3538 /* PR 17512: file: ac585d01. */
3539 if (arfile
== last_arfile
)
3545 last_arfile
= arfile
;
3548 if (last_arfile
!= NULL
)
3549 bfd_close (last_arfile
);
3552 display_object_bfd (file
);
3556 display_file (char *filename
, char *target
)
3560 if (get_file_size (filename
) < 1)
3566 file
= bfd_openr (filename
, target
);
3569 nonfatal (filename
);
3573 display_any_bfd (file
, 0);
3579 main (int argc
, char **argv
)
3582 char *target
= default_target
;
3583 bfd_boolean seenflag
= FALSE
;
3585 #if defined (HAVE_SETLOCALE)
3586 #if defined (HAVE_LC_MESSAGES)
3587 setlocale (LC_MESSAGES
, "");
3589 setlocale (LC_CTYPE
, "");
3592 bindtextdomain (PACKAGE
, LOCALEDIR
);
3593 textdomain (PACKAGE
);
3595 program_name
= *argv
;
3596 xmalloc_set_program_name (program_name
);
3597 bfd_set_error_program_name (program_name
);
3599 START_PROGRESS (program_name
, 0);
3601 expandargv (&argc
, &argv
);
3604 set_default_bfd_target ();
3606 while ((c
= getopt_long (argc
, argv
,
3607 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3608 long_options
, (int *) 0))
3614 break; /* We've been given a long option. */
3619 if (disassembler_options
)
3620 /* Ignore potential memory leak for now. */
3621 disassembler_options
= concat (disassembler_options
, ",",
3622 optarg
, (const char *) NULL
);
3624 disassembler_options
= optarg
;
3630 display_file_offsets
= TRUE
;
3633 with_line_numbers
= TRUE
;
3642 enum demangling_styles style
;
3644 style
= cplus_demangle_name_to_style (optarg
);
3645 if (style
== unknown_demangling
)
3646 fatal (_("unknown demangling style `%s'"),
3649 cplus_demangle_set_style (style
);
3655 case OPTION_ADJUST_VMA
:
3656 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3658 case OPTION_START_ADDRESS
:
3659 start_address
= parse_vma (optarg
, "--start-address");
3660 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3661 fatal (_("error: the start address should be before the end address"));
3663 case OPTION_STOP_ADDRESS
:
3664 stop_address
= parse_vma (optarg
, "--stop-address");
3665 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3666 fatal (_("error: the stop address should be after the start address"));
3670 prefix_length
= strlen (prefix
);
3671 /* Remove an unnecessary trailing '/' */
3672 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3675 case OPTION_PREFIX_STRIP
:
3676 prefix_strip
= atoi (optarg
);
3677 if (prefix_strip
< 0)
3678 fatal (_("error: prefix strip must be non-negative"));
3680 case OPTION_INSN_WIDTH
:
3681 insn_width
= strtoul (optarg
, NULL
, 0);
3682 if (insn_width
<= 0)
3683 fatal (_("error: instruction width must be positive"));
3686 if (strcmp (optarg
, "B") == 0)
3687 endian
= BFD_ENDIAN_BIG
;
3688 else if (strcmp (optarg
, "L") == 0)
3689 endian
= BFD_ENDIAN_LITTLE
;
3692 nonfatal (_("unrecognized -E option"));
3697 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3698 endian
= BFD_ENDIAN_BIG
;
3699 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3700 endian
= BFD_ENDIAN_LITTLE
;
3703 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3710 dump_file_header
= TRUE
;
3714 formats_info
= TRUE
;
3718 add_include_path (optarg
);
3721 dump_private_headers
= TRUE
;
3725 dump_private_options
= optarg
;
3729 dump_private_headers
= TRUE
;
3731 dump_reloc_info
= TRUE
;
3732 dump_file_header
= TRUE
;
3733 dump_ar_hdrs
= TRUE
;
3734 dump_section_headers
= TRUE
;
3742 dump_dynamic_symtab
= TRUE
;
3750 disassemble_zeroes
= TRUE
;
3754 disassemble_all
= TRUE
;
3759 with_source_code
= TRUE
;
3768 dump_debugging_tags
= 1;
3773 dump_dwarf_section_info
= TRUE
;
3776 dwarf_select_sections_by_letters (optarg
);
3778 dwarf_select_sections_all ();
3781 dump_dwarf_section_info
= TRUE
;
3784 dwarf_select_sections_by_names (optarg
);
3786 dwarf_select_sections_all ();
3788 case OPTION_DWARF_DEPTH
:
3791 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3794 case OPTION_DWARF_START
:
3797 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3798 suppress_bfd_header
= 1;
3801 case OPTION_DWARF_CHECK
:
3805 dump_stab_section_info
= TRUE
;
3809 dump_section_contents
= TRUE
;
3813 dump_reloc_info
= TRUE
;
3817 dump_dynamic_reloc_info
= TRUE
;
3821 dump_ar_hdrs
= TRUE
;
3825 dump_section_headers
= TRUE
;
3830 show_version
= TRUE
;
3836 /* No need to set seenflag or to break - usage() does not return. */
3843 print_version ("objdump");
3849 exit_status
= display_info ();
3853 display_file ("a.out", target
);
3855 for (; optind
< argc
;)
3856 display_file (argv
[optind
++], target
);
3861 END_PROGRESS (program_name
);