1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2015 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
)
491 PF (SEC_COFF_SHARED
, "SHARED");
492 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
493 PF (SEC_GROUP
, "GROUP");
495 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
498 struct coff_comdat_info
*comdat
;
500 switch (section
->flags
& SEC_LINK_DUPLICATES
)
504 case SEC_LINK_DUPLICATES_DISCARD
:
505 ls
= "LINK_ONCE_DISCARD";
507 case SEC_LINK_DUPLICATES_ONE_ONLY
:
508 ls
= "LINK_ONCE_ONE_ONLY";
510 case SEC_LINK_DUPLICATES_SAME_SIZE
:
511 ls
= "LINK_ONCE_SAME_SIZE";
513 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
514 ls
= "LINK_ONCE_SAME_CONTENTS";
517 printf ("%s%s", comma
, ls
);
519 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
521 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
531 dump_headers (bfd
*abfd
)
533 printf (_("Sections:\n"));
536 printf (_("Idx Name Size VMA LMA File off Algn"));
538 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
539 if (bfd_get_arch_size (abfd
) == 32)
540 printf (_("Idx Name Size VMA LMA File off Algn"));
542 printf (_("Idx Name Size VMA LMA File off Algn"));
546 printf (_(" Flags"));
549 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
553 slurp_symtab (bfd
*abfd
)
558 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
564 storage
= bfd_get_symtab_upper_bound (abfd
);
567 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
568 bfd_fatal (_("error message was"));
571 sy
= (asymbol
**) xmalloc (storage
);
573 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
575 bfd_fatal (bfd_get_filename (abfd
));
579 /* Read in the dynamic symbols. */
582 slurp_dynamic_symtab (bfd
*abfd
)
587 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
590 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
592 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
598 bfd_fatal (bfd_get_filename (abfd
));
601 sy
= (asymbol
**) xmalloc (storage
);
603 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
605 bfd_fatal (bfd_get_filename (abfd
));
609 /* Filter out (in place) symbols that are useless for disassembly.
610 COUNT is the number of elements in SYMBOLS.
611 Return the number of useful symbols. */
614 remove_useless_symbols (asymbol
**symbols
, long count
)
616 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
620 asymbol
*sym
= *in_ptr
++;
622 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
624 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
626 if (bfd_is_und_section (sym
->section
)
627 || bfd_is_com_section (sym
->section
))
632 return out_ptr
- symbols
;
635 /* Sort symbols into value order. */
638 compare_symbols (const void *ap
, const void *bp
)
640 const asymbol
*a
= * (const asymbol
**) ap
;
641 const asymbol
*b
= * (const asymbol
**) bp
;
651 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
653 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
656 if (a
->section
> b
->section
)
658 else if (a
->section
< b
->section
)
661 an
= bfd_asymbol_name (a
);
662 bn
= bfd_asymbol_name (b
);
666 /* The symbols gnu_compiled and gcc2_compiled convey no real
667 information, so put them after other symbols with the same value. */
668 af
= (strstr (an
, "gnu_compiled") != NULL
669 || strstr (an
, "gcc2_compiled") != NULL
);
670 bf
= (strstr (bn
, "gnu_compiled") != NULL
671 || strstr (bn
, "gcc2_compiled") != NULL
);
678 /* We use a heuristic for the file name, to try to sort it after
679 more useful symbols. It may not work on non Unix systems, but it
680 doesn't really matter; the only difference is precisely which
681 symbol names get printed. */
683 #define file_symbol(s, sn, snl) \
684 (((s)->flags & BSF_FILE) != 0 \
685 || ((sn)[(snl) - 2] == '.' \
686 && ((sn)[(snl) - 1] == 'o' \
687 || (sn)[(snl) - 1] == 'a')))
689 af
= file_symbol (a
, an
, anl
);
690 bf
= file_symbol (b
, bn
, bnl
);
697 /* Try to sort global symbols before local symbols before function
698 symbols before debugging symbols. */
703 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
705 if ((aflags
& BSF_DEBUGGING
) != 0)
710 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
712 if ((aflags
& BSF_FUNCTION
) != 0)
717 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
719 if ((aflags
& BSF_LOCAL
) != 0)
724 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
726 if ((aflags
& BSF_GLOBAL
) != 0)
732 /* Symbols that start with '.' might be section names, so sort them
733 after symbols that don't start with '.'. */
734 if (an
[0] == '.' && bn
[0] != '.')
736 if (an
[0] != '.' && bn
[0] == '.')
739 /* Finally, if we can't distinguish them in any other way, try to
740 get consistent results by sorting the symbols by name. */
741 return strcmp (an
, bn
);
744 /* Sort relocs into address order. */
747 compare_relocs (const void *ap
, const void *bp
)
749 const arelent
*a
= * (const arelent
**) ap
;
750 const arelent
*b
= * (const arelent
**) bp
;
752 if (a
->address
> b
->address
)
754 else if (a
->address
< b
->address
)
757 /* So that associated relocations tied to the same address show up
758 in the correct order, we don't do any further sorting. */
767 /* Print an address (VMA) to the output stream in INFO.
768 If SKIP_ZEROES is TRUE, omit leading zeroes. */
771 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
772 bfd_boolean skip_zeroes
)
776 struct objdump_disasm_info
*aux
;
778 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
779 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
784 for (p
= buf
; *p
== '0'; ++p
)
789 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
792 /* Print the name of a symbol. */
795 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
799 const char *name
, *version_string
= NULL
;
800 bfd_boolean hidden
= FALSE
;
803 name
= bfd_asymbol_name (sym
);
804 if (do_demangle
&& name
[0] != '\0')
806 /* Demangle the name. */
807 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
812 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
814 if (bfd_is_und_section (bfd_get_section (sym
)))
819 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
820 if (version_string
&& *version_string
!= '\0')
821 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
827 if (version_string
&& *version_string
!= '\0')
828 printf (hidden
? "@%s" : "@@%s", version_string
);
835 /* Locate a symbol given a bfd and a section (from INFO->application_data),
836 and a VMA. If INFO->application_data->require_sec is TRUE, then always
837 require the symbol to be in the section. Returns NULL if there is no
838 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
839 of the symbol in sorted_syms. */
842 find_symbol_for_address (bfd_vma vma
,
843 struct disassemble_info
*inf
,
846 /* @@ Would it speed things up to cache the last two symbols returned,
847 and maybe their address ranges? For many processors, only one memory
848 operand can be present at a time, so the 2-entry cache wouldn't be
849 constantly churned by code doing heavy memory accesses. */
851 /* Indices in `sorted_syms'. */
853 long max_count
= sorted_symcount
;
855 struct objdump_disasm_info
*aux
;
859 bfd_boolean want_section
;
861 if (sorted_symcount
< 1)
864 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
867 opb
= inf
->octets_per_byte
;
869 /* Perform a binary search looking for the closest symbol to the
870 required value. We are searching the range (min, max_count]. */
871 while (min
+ 1 < max_count
)
875 thisplace
= (max_count
+ min
) / 2;
876 sym
= sorted_syms
[thisplace
];
878 if (bfd_asymbol_value (sym
) > vma
)
879 max_count
= thisplace
;
880 else if (bfd_asymbol_value (sym
) < vma
)
889 /* The symbol we want is now in min, the low end of the range we
890 were searching. If there are several symbols with the same
891 value, we want the first one. */
894 && (bfd_asymbol_value (sorted_syms
[thisplace
])
895 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
898 /* Prefer a symbol in the current section if we have multple symbols
899 with the same value, as can occur with overlays or zero size
902 while (min
< max_count
903 && (bfd_asymbol_value (sorted_syms
[min
])
904 == bfd_asymbol_value (sorted_syms
[thisplace
])))
906 if (sorted_syms
[min
]->section
== sec
907 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
914 return sorted_syms
[thisplace
];
919 /* If the file is relocatable, and the symbol could be from this
920 section, prefer a symbol from this section over symbols from
921 others, even if the other symbol's value might be closer.
923 Note that this may be wrong for some symbol references if the
924 sections have overlapping memory ranges, but in that case there's
925 no way to tell what's desired without looking at the relocation
928 Also give the target a chance to reject symbols. */
929 want_section
= (aux
->require_sec
930 || ((abfd
->flags
& HAS_RELOC
) != 0
931 && vma
>= bfd_get_section_vma (abfd
, sec
)
932 && vma
< (bfd_get_section_vma (abfd
, sec
)
933 + bfd_section_size (abfd
, sec
) / opb
)));
934 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
935 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
938 long newplace
= sorted_symcount
;
940 for (i
= min
- 1; i
>= 0; i
--)
942 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
943 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
945 if (newplace
== sorted_symcount
)
948 if (bfd_asymbol_value (sorted_syms
[i
])
949 != bfd_asymbol_value (sorted_syms
[newplace
]))
952 /* Remember this symbol and keep searching until we reach
953 an earlier address. */
958 if (newplace
!= sorted_symcount
)
959 thisplace
= newplace
;
962 /* We didn't find a good symbol with a smaller value.
963 Look for one with a larger value. */
964 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
966 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
967 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
975 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
976 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
977 /* There is no suitable symbol. */
984 return sorted_syms
[thisplace
];
987 /* Print an address and the offset to the nearest symbol. */
990 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
991 bfd_vma vma
, struct disassemble_info
*inf
,
992 bfd_boolean skip_zeroes
)
994 objdump_print_value (vma
, inf
, skip_zeroes
);
1000 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1001 bfd_get_section_name (abfd
, sec
));
1002 secaddr
= bfd_get_section_vma (abfd
, sec
);
1005 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1006 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1008 else if (vma
> secaddr
)
1010 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1011 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1013 (*inf
->fprintf_func
) (inf
->stream
, ">");
1017 (*inf
->fprintf_func
) (inf
->stream
, " <");
1018 objdump_print_symname (abfd
, inf
, sym
);
1019 if (bfd_asymbol_value (sym
) > vma
)
1021 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1022 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1024 else if (vma
> bfd_asymbol_value (sym
))
1026 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1027 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1029 (*inf
->fprintf_func
) (inf
->stream
, ">");
1032 if (display_file_offsets
)
1033 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1034 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1037 /* Print an address (VMA), symbolically if possible.
1038 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1041 objdump_print_addr (bfd_vma vma
,
1042 struct disassemble_info
*inf
,
1043 bfd_boolean skip_zeroes
)
1045 struct objdump_disasm_info
*aux
;
1046 asymbol
*sym
= NULL
;
1047 bfd_boolean skip_find
= FALSE
;
1049 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1051 if (sorted_symcount
< 1)
1053 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1054 objdump_print_value (vma
, inf
, skip_zeroes
);
1056 if (display_file_offsets
)
1057 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1058 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1062 if (aux
->reloc
!= NULL
1063 && aux
->reloc
->sym_ptr_ptr
!= NULL
1064 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1066 sym
= * aux
->reloc
->sym_ptr_ptr
;
1068 /* Adjust the vma to the reloc. */
1069 vma
+= bfd_asymbol_value (sym
);
1071 if (bfd_is_und_section (bfd_get_section (sym
)))
1076 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1078 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1082 /* Print VMA to INFO. This function is passed to the disassembler
1086 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1088 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1091 /* Determine if the given address has a symbol associated with it. */
1094 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1098 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1100 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1103 /* Hold the last function name and the last line number we displayed
1104 in a disassembly. */
1106 static char *prev_functionname
;
1107 static unsigned int prev_line
;
1108 static unsigned int prev_discriminator
;
1110 /* We keep a list of all files that we have seen when doing a
1111 disassembly with source, so that we know how much of the file to
1112 display. This can be important for inlined functions. */
1114 struct print_file_list
1116 struct print_file_list
*next
;
1117 const char *filename
;
1118 const char *modname
;
1121 const char **linemap
;
1127 static struct print_file_list
*print_files
;
1129 /* The number of preceding context lines to show when we start
1130 displaying a file for the first time. */
1132 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1134 /* Read a complete file into memory. */
1137 slurp_file (const char *fn
, size_t *size
)
1140 int ps
= getpagesize ();
1145 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1149 if (fstat (fd
, &st
) < 0)
1156 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1157 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1158 if (map
!= (char *) -1L)
1164 map
= (const char *) malloc (*size
);
1165 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1167 free ((void *) map
);
1174 #define line_map_decrease 5
1176 /* Precompute array of lines for a mapped file. */
1178 static const char **
1179 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1181 const char *p
, *lstart
, *end
;
1182 int chars_per_line
= 45; /* First iteration will use 40. */
1183 unsigned int lineno
;
1184 const char **linemap
= NULL
;
1185 unsigned long line_map_size
= 0;
1191 for (p
= map
; p
< end
; p
++)
1195 if (p
+ 1 < end
&& p
[1] == '\r')
1198 else if (*p
== '\r')
1200 if (p
+ 1 < end
&& p
[1] == '\n')
1206 /* End of line found. */
1208 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1210 unsigned long newsize
;
1212 chars_per_line
-= line_map_decrease
;
1213 if (chars_per_line
<= 1)
1215 line_map_size
= size
/ chars_per_line
+ 1;
1216 if (line_map_size
< lineno
+ 1)
1217 line_map_size
= lineno
+ 1;
1218 newsize
= line_map_size
* sizeof (char *);
1219 linemap
= (const char **) xrealloc (linemap
, newsize
);
1222 linemap
[lineno
++] = lstart
;
1230 /* Tries to open MODNAME, and if successful adds a node to print_files
1231 linked list and returns that node. Returns NULL on failure. */
1233 static struct print_file_list
*
1234 try_print_file_open (const char *origname
, const char *modname
)
1236 struct print_file_list
*p
;
1238 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1240 p
->map
= slurp_file (modname
, &p
->mapsize
);
1247 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1249 p
->filename
= origname
;
1250 p
->modname
= modname
;
1251 p
->next
= print_files
;
1257 /* If the source file, as described in the symtab, is not found
1258 try to locate it in one of the paths specified with -I
1259 If found, add location to print_files linked list. */
1261 static struct print_file_list
*
1262 update_source_path (const char *filename
)
1264 struct print_file_list
*p
;
1268 p
= try_print_file_open (filename
, filename
);
1272 if (include_path_count
== 0)
1275 /* Get the name of the file. */
1276 fname
= lbasename (filename
);
1278 /* If file exists under a new path, we need to add it to the list
1279 so that show_line knows about it. */
1280 for (i
= 0; i
< include_path_count
; i
++)
1282 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1284 p
= try_print_file_open (filename
, modname
);
1294 /* Print a source file line. */
1297 print_line (struct print_file_list
*p
, unsigned int linenum
)
1303 if (linenum
>= p
->maxline
)
1305 l
= p
->linemap
[linenum
];
1306 /* Test fwrite return value to quiet glibc warning. */
1307 len
= strcspn (l
, "\n\r");
1308 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1312 /* Print a range of source code lines. */
1315 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1319 while (start
<= end
)
1321 print_line (p
, start
);
1326 /* Show the line number, or the source line, in a disassembly
1330 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1332 const char *filename
;
1333 const char *functionname
;
1334 unsigned int linenumber
;
1335 unsigned int discriminator
;
1338 if (! with_line_numbers
&& ! with_source_code
)
1341 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1342 &filename
, &functionname
,
1343 &linenumber
, &discriminator
))
1346 if (filename
!= NULL
&& *filename
== '\0')
1348 if (functionname
!= NULL
&& *functionname
== '\0')
1349 functionname
= NULL
;
1352 && IS_ABSOLUTE_PATH (filename
)
1356 const char *fname
= filename
;
1357 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1360 memcpy (path
, prefix
, prefix_length
);
1361 path_up
= path
+ prefix_length
;
1363 /* Build relocated filename, stripping off leading directories
1364 from the initial filename if requested. */
1365 if (prefix_strip
> 0)
1370 /* Skip selected directory levels. */
1371 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1372 if (IS_DIR_SEPARATOR(*s
))
1379 /* Update complete filename. */
1380 strncpy (path_up
, fname
, PATH_MAX
);
1381 path_up
[PATH_MAX
] = '\0';
1389 if (with_line_numbers
)
1391 if (functionname
!= NULL
1392 && (prev_functionname
== NULL
1393 || strcmp (functionname
, prev_functionname
) != 0))
1394 printf ("%s():\n", functionname
);
1395 if (linenumber
> 0 && (linenumber
!= prev_line
||
1396 (discriminator
!= prev_discriminator
)))
1398 if (discriminator
> 0)
1399 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1400 linenumber
, discriminator
);
1402 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1406 if (with_source_code
1410 struct print_file_list
**pp
, *p
;
1413 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1414 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1421 filename
= xstrdup (filename
);
1422 p
= update_source_path (filename
);
1425 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1427 if (file_start_context
&& p
->first
)
1431 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1432 if (l
>= linenumber
)
1434 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1435 l
= p
->last_line
+ 1;
1437 dump_lines (p
, l
, linenumber
);
1438 p
->last_line
= linenumber
;
1443 if (functionname
!= NULL
1444 && (prev_functionname
== NULL
1445 || strcmp (functionname
, prev_functionname
) != 0))
1447 if (prev_functionname
!= NULL
)
1448 free (prev_functionname
);
1449 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1450 strcpy (prev_functionname
, functionname
);
1453 if (linenumber
> 0 && linenumber
!= prev_line
)
1454 prev_line
= linenumber
;
1456 if (discriminator
!= prev_discriminator
)
1457 prev_discriminator
= discriminator
;
1460 /* Pseudo FILE object for strings. */
1468 /* sprintf to a "stream". */
1470 static int ATTRIBUTE_PRINTF_2
1471 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1478 size_t space
= f
->alloc
- f
->pos
;
1480 va_start (args
, format
);
1481 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1487 f
->alloc
= (f
->alloc
+ n
) * 2;
1488 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1495 /* The number of zeroes we want to see before we start skipping them.
1496 The number is arbitrarily chosen. */
1498 #define DEFAULT_SKIP_ZEROES 8
1500 /* The number of zeroes to skip at the end of a section. If the
1501 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1502 SKIP_ZEROES, they will be disassembled. If there are fewer than
1503 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1504 attempt to avoid disassembling zeroes inserted by section
1507 #define DEFAULT_SKIP_ZEROES_AT_END 3
1509 /* Disassemble some data in memory between given values. */
1512 disassemble_bytes (struct disassemble_info
* inf
,
1513 disassembler_ftype disassemble_fn
,
1516 bfd_vma start_offset
,
1517 bfd_vma stop_offset
,
1520 arelent
** relppend
)
1522 struct objdump_disasm_info
*aux
;
1524 int octets_per_line
;
1525 int skip_addr_chars
;
1526 bfd_vma addr_offset
;
1527 unsigned int opb
= inf
->octets_per_byte
;
1528 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1529 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1533 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1537 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1541 octets_per_line
= insn_width
;
1543 octets_per_line
= 4;
1545 octets_per_line
= 16;
1547 /* Figure out how many characters to skip at the start of an
1548 address, to make the disassembly look nicer. We discard leading
1549 zeroes in chunks of 4, ensuring that there is always a leading
1551 skip_addr_chars
= 0;
1552 if (! prefix_addresses
)
1556 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1558 while (buf
[skip_addr_chars
] == '0')
1561 /* Don't discard zeros on overflow. */
1562 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1563 skip_addr_chars
= 0;
1565 if (skip_addr_chars
!= 0)
1566 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1569 inf
->insn_info_valid
= 0;
1571 addr_offset
= start_offset
;
1572 while (addr_offset
< stop_offset
)
1575 bfd_boolean need_nl
= FALSE
;
1576 int previous_octets
;
1578 /* Remember the length of the previous instruction. */
1579 previous_octets
= octets
;
1582 /* Make sure we don't use relocs from previous instructions. */
1585 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1587 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1590 if (! disassemble_zeroes
1591 && (inf
->insn_info_valid
== 0
1592 || inf
->branch_delay_insns
== 0)
1593 && (z
- addr_offset
* opb
>= skip_zeroes
1594 || (z
== stop_offset
* opb
&&
1595 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1597 /* If there are more nonzero octets to follow, we only skip
1598 zeroes in multiples of 4, to try to avoid running over
1599 the start of an instruction which happens to start with
1601 if (z
!= stop_offset
* opb
)
1602 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1604 octets
= z
- addr_offset
* opb
;
1606 /* If we are going to display more data, and we are displaying
1607 file offsets, then tell the user how many zeroes we skip
1608 and the file offset from where we resume dumping. */
1609 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1610 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1612 (unsigned long) (section
->filepos
1613 + (addr_offset
+ (octets
/ opb
))));
1623 if (with_line_numbers
|| with_source_code
)
1624 show_line (aux
->abfd
, section
, addr_offset
);
1626 if (! prefix_addresses
)
1630 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1631 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1635 printf ("%s:\t", buf
+ skip_addr_chars
);
1639 aux
->require_sec
= TRUE
;
1640 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1641 aux
->require_sec
= FALSE
;
1648 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1649 inf
->stream
= &sfile
;
1650 inf
->bytes_per_line
= 0;
1651 inf
->bytes_per_chunk
= 0;
1652 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1654 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1656 if (inf
->disassembler_needs_relocs
1657 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1658 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1659 && *relppp
< relppend
)
1661 bfd_signed_vma distance_to_rel
;
1663 distance_to_rel
= (**relppp
)->address
1664 - (rel_offset
+ addr_offset
);
1666 /* Check to see if the current reloc is associated with
1667 the instruction that we are about to disassemble. */
1668 if (distance_to_rel
== 0
1669 /* FIXME: This is wrong. We are trying to catch
1670 relocs that are addressed part way through the
1671 current instruction, as might happen with a packed
1672 VLIW instruction. Unfortunately we do not know the
1673 length of the current instruction since we have not
1674 disassembled it yet. Instead we take a guess based
1675 upon the length of the previous instruction. The
1676 proper solution is to have a new target-specific
1677 disassembler function which just returns the length
1678 of an instruction at a given address without trying
1679 to display its disassembly. */
1680 || (distance_to_rel
> 0
1681 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1683 inf
->flags
|= INSN_HAS_RELOC
;
1684 aux
->reloc
= **relppp
;
1688 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1689 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1690 inf
->stream
= stdout
;
1691 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1692 octets_per_line
= inf
->bytes_per_line
;
1693 if (octets
< (int) opb
)
1696 printf ("%s\n", sfile
.buffer
);
1699 non_fatal (_("disassemble_fn returned length %d"),
1710 octets
= octets_per_line
;
1711 if (addr_offset
+ octets
/ opb
> stop_offset
)
1712 octets
= (stop_offset
- addr_offset
) * opb
;
1714 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1716 if (ISPRINT (data
[j
]))
1717 buf
[j
- addr_offset
* opb
] = data
[j
];
1719 buf
[j
- addr_offset
* opb
] = '.';
1721 buf
[j
- addr_offset
* opb
] = '\0';
1724 if (prefix_addresses
1726 : show_raw_insn
>= 0)
1730 /* If ! prefix_addresses and ! wide_output, we print
1731 octets_per_line octets per line. */
1733 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1734 pb
= octets_per_line
;
1736 if (inf
->bytes_per_chunk
)
1737 bpc
= inf
->bytes_per_chunk
;
1741 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1745 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1747 for (k
= bpc
- 1; k
>= 0; k
--)
1748 printf ("%02x", (unsigned) data
[j
+ k
]);
1753 for (k
= 0; k
< bpc
; k
++)
1754 printf ("%02x", (unsigned) data
[j
+ k
]);
1759 for (; pb
< octets_per_line
; pb
+= bpc
)
1763 for (k
= 0; k
< bpc
; k
++)
1768 /* Separate raw data from instruction by extra space. */
1778 printf ("%s", sfile
.buffer
);
1780 if (prefix_addresses
1782 : show_raw_insn
>= 0)
1790 j
= addr_offset
* opb
+ pb
;
1792 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1793 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1797 printf ("%s:\t", buf
+ skip_addr_chars
);
1799 pb
+= octets_per_line
;
1802 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1806 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1808 for (k
= bpc
- 1; k
>= 0; k
--)
1809 printf ("%02x", (unsigned) data
[j
+ k
]);
1814 for (k
= 0; k
< bpc
; k
++)
1815 printf ("%02x", (unsigned) data
[j
+ k
]);
1828 while ((*relppp
) < relppend
1829 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1831 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1842 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1845 if (q
->howto
== NULL
)
1846 printf (": *unknown*\t");
1847 else if (q
->howto
->name
)
1848 printf (": %s\t", q
->howto
->name
);
1850 printf (": %d\t", q
->howto
->type
);
1852 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1853 printf ("*unknown*");
1856 const char *sym_name
;
1858 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1859 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1860 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1865 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1866 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1867 if (sym_name
== NULL
|| *sym_name
== '\0')
1868 sym_name
= "*unknown*";
1869 printf ("%s", sym_name
);
1875 bfd_signed_vma addend
= q
->addend
;
1883 objdump_print_value (addend
, inf
, TRUE
);
1895 addr_offset
+= octets
/ opb
;
1898 free (sfile
.buffer
);
1902 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1904 const struct elf_backend_data
* bed
;
1905 bfd_vma sign_adjust
= 0;
1906 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1907 struct objdump_disasm_info
* paux
;
1908 unsigned int opb
= pinfo
->octets_per_byte
;
1909 bfd_byte
* data
= NULL
;
1910 bfd_size_type datasize
= 0;
1911 arelent
** rel_pp
= NULL
;
1912 arelent
** rel_ppstart
= NULL
;
1913 arelent
** rel_ppend
;
1914 unsigned long stop_offset
;
1915 asymbol
* sym
= NULL
;
1919 unsigned long addr_offset
;
1921 /* Sections that do not contain machine
1922 code are not normally disassembled. */
1923 if (! disassemble_all
1924 && only_list
== NULL
1925 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1926 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1929 if (! process_section_p (section
))
1932 datasize
= bfd_get_section_size (section
);
1936 if (start_address
== (bfd_vma
) -1
1937 || start_address
< section
->vma
)
1940 addr_offset
= start_address
- section
->vma
;
1942 if (stop_address
== (bfd_vma
) -1)
1943 stop_offset
= datasize
/ opb
;
1946 if (stop_address
< section
->vma
)
1949 stop_offset
= stop_address
- section
->vma
;
1950 if (stop_offset
> datasize
/ opb
)
1951 stop_offset
= datasize
/ opb
;
1954 if (addr_offset
>= stop_offset
)
1957 /* Decide which set of relocs to use. Load them if necessary. */
1958 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1959 if (paux
->dynrelbuf
)
1961 rel_pp
= paux
->dynrelbuf
;
1962 rel_count
= paux
->dynrelcount
;
1963 /* Dynamic reloc addresses are absolute, non-dynamic are section
1964 relative. REL_OFFSET specifies the reloc address corresponding
1965 to the start of this section. */
1966 rel_offset
= section
->vma
;
1974 if ((section
->flags
& SEC_RELOC
) != 0
1975 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1979 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1981 bfd_fatal (bfd_get_filename (abfd
));
1985 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1986 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1988 bfd_fatal (bfd_get_filename (abfd
));
1990 /* Sort the relocs by address. */
1991 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1995 rel_ppend
= rel_pp
+ rel_count
;
1997 data
= (bfd_byte
*) xmalloc (datasize
);
1999 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2001 paux
->sec
= section
;
2002 pinfo
->buffer
= data
;
2003 pinfo
->buffer_vma
= section
->vma
;
2004 pinfo
->buffer_length
= datasize
;
2005 pinfo
->section
= section
;
2007 /* Skip over the relocs belonging to addresses below the
2009 while (rel_pp
< rel_ppend
2010 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2013 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2015 /* Find the nearest symbol forwards from our current position. */
2016 paux
->require_sec
= TRUE
;
2017 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2018 (struct disassemble_info
*) inf
,
2020 paux
->require_sec
= FALSE
;
2022 /* PR 9774: If the target used signed addresses then we must make
2023 sure that we sign extend the value that we calculate for 'addr'
2024 in the loop below. */
2025 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2026 && (bed
= get_elf_backend_data (abfd
)) != NULL
2027 && bed
->sign_extend_vma
)
2028 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2030 /* Disassemble a block of instructions up to the address associated with
2031 the symbol we have just found. Then print the symbol and find the
2032 next symbol on. Repeat until we have disassembled the entire section
2033 or we have reached the end of the address range we are interested in. */
2034 while (addr_offset
< stop_offset
)
2038 unsigned long nextstop_offset
;
2041 addr
= section
->vma
+ addr_offset
;
2042 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2044 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2049 (x
< sorted_symcount
2050 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2054 pinfo
->symbols
= sorted_syms
+ place
;
2055 pinfo
->num_symbols
= x
- place
;
2056 pinfo
->symtab_pos
= place
;
2060 pinfo
->symbols
= NULL
;
2061 pinfo
->num_symbols
= 0;
2062 pinfo
->symtab_pos
= -1;
2065 if (! prefix_addresses
)
2067 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2068 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2070 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2073 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2075 else if (sym
== NULL
)
2079 #define is_valid_next_sym(SYM) \
2080 ((SYM)->section == section \
2081 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2082 && pinfo->symbol_is_valid (SYM, pinfo))
2084 /* Search forward for the next appropriate symbol in
2085 SECTION. Note that all the symbols are sorted
2086 together into one big array, and that some sections
2087 may have overlapping addresses. */
2088 while (place
< sorted_symcount
2089 && ! is_valid_next_sym (sorted_syms
[place
]))
2092 if (place
>= sorted_symcount
)
2095 nextsym
= sorted_syms
[place
];
2098 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2099 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2100 else if (nextsym
== NULL
)
2101 nextstop_offset
= stop_offset
;
2103 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2105 if (nextstop_offset
> stop_offset
2106 || nextstop_offset
<= addr_offset
)
2107 nextstop_offset
= stop_offset
;
2109 /* If a symbol is explicitly marked as being an object
2110 rather than a function, just dump the bytes without
2111 disassembling them. */
2114 || sym
->section
!= section
2115 || bfd_asymbol_value (sym
) > addr
2116 || ((sym
->flags
& BSF_OBJECT
) == 0
2117 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2119 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2121 || (sym
->flags
& BSF_FUNCTION
) != 0)
2126 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2127 addr_offset
, nextstop_offset
,
2128 rel_offset
, &rel_pp
, rel_ppend
);
2130 addr_offset
= nextstop_offset
;
2136 if (rel_ppstart
!= NULL
)
2140 /* Disassemble the contents of an object file. */
2143 disassemble_data (bfd
*abfd
)
2145 struct disassemble_info disasm_info
;
2146 struct objdump_disasm_info aux
;
2150 prev_functionname
= NULL
;
2152 prev_discriminator
= 0;
2154 /* We make a copy of syms to sort. We don't want to sort syms
2155 because that will screw up the relocs. */
2156 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2157 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2158 * sizeof (asymbol
*));
2159 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2160 sorted_symcount
* sizeof (asymbol
*));
2162 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2164 for (i
= 0; i
< synthcount
; ++i
)
2166 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2170 /* Sort the symbols into section and symbol order. */
2171 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2173 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2175 disasm_info
.application_data
= (void *) &aux
;
2177 aux
.require_sec
= FALSE
;
2178 aux
.dynrelbuf
= NULL
;
2179 aux
.dynrelcount
= 0;
2182 disasm_info
.print_address_func
= objdump_print_address
;
2183 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2185 if (machine
!= NULL
)
2187 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2190 fatal (_("can't use supplied machine %s"), machine
);
2192 abfd
->arch_info
= inf
;
2195 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2197 struct bfd_target
*xvec
;
2199 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2200 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2201 xvec
->byteorder
= endian
;
2205 /* Use libopcodes to locate a suitable disassembler. */
2206 aux
.disassemble_fn
= disassembler (abfd
);
2207 if (!aux
.disassemble_fn
)
2209 non_fatal (_("can't disassemble for architecture %s\n"),
2210 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2215 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2216 disasm_info
.arch
= bfd_get_arch (abfd
);
2217 disasm_info
.mach
= bfd_get_mach (abfd
);
2218 disasm_info
.disassembler_options
= disassembler_options
;
2219 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2220 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2221 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2222 disasm_info
.disassembler_needs_relocs
= FALSE
;
2224 if (bfd_big_endian (abfd
))
2225 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2226 else if (bfd_little_endian (abfd
))
2227 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2229 /* ??? Aborting here seems too drastic. We could default to big or little
2231 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2233 /* Allow the target to customize the info structure. */
2234 disassemble_init_for_target (& disasm_info
);
2236 /* Pre-load the dynamic relocs if we are going
2237 to be dumping them along with the disassembly. */
2238 if (dump_dynamic_reloc_info
)
2240 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2243 bfd_fatal (bfd_get_filename (abfd
));
2247 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2248 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2251 if (aux
.dynrelcount
< 0)
2252 bfd_fatal (bfd_get_filename (abfd
));
2254 /* Sort the relocs by address. */
2255 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2259 disasm_info
.symtab
= sorted_syms
;
2260 disasm_info
.symtab_size
= sorted_symcount
;
2262 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2264 if (aux
.dynrelbuf
!= NULL
)
2265 free (aux
.dynrelbuf
);
2270 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2271 asection
*sec
, void *file
)
2273 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2274 bfd
*abfd
= (bfd
*) file
;
2277 /* If it is already loaded, do nothing. */
2278 if (section
->start
!= NULL
)
2281 section
->reloc_info
= NULL
;
2282 section
->num_relocs
= 0;
2283 section
->address
= bfd_get_section_vma (abfd
, sec
);
2284 section
->size
= bfd_get_section_size (sec
);
2285 section
->start
= NULL
;
2286 section
->user_data
= sec
;
2287 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2291 free_debug_section (debug
);
2292 printf (_("\nCan't get contents for section '%s'.\n"),
2297 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2299 bfd_cache_section_contents (sec
, section
->start
);
2301 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2308 free_debug_section (debug
);
2309 printf (_("\nCan't get contents for section '%s'.\n"),
2316 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2319 unsigned long reloc_count
;
2322 relocs
= (arelent
**) xmalloc (reloc_size
);
2324 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2325 if (reloc_count
== 0)
2329 section
->reloc_info
= relocs
;
2330 section
->num_relocs
= reloc_count
;
2339 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2344 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2347 relocs
= (arelent
**) dsec
->reloc_info
;
2349 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2350 if (rp
->address
== offset
)
2357 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2359 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2360 bfd
*abfd
= (bfd
*) file
;
2363 /* If it is already loaded, do nothing. */
2364 if (section
->start
!= NULL
)
2367 /* Locate the debug section. */
2368 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2370 section
->name
= section
->uncompressed_name
;
2373 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2375 section
->name
= section
->compressed_name
;
2380 return load_specific_debug_section (debug
, sec
, file
);
2384 free_debug_section (enum dwarf_section_display_enum debug
)
2386 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2388 if (section
->start
== NULL
)
2391 /* PR 17512: file: 0f67f69d. */
2392 if (section
->user_data
!= NULL
)
2394 asection
* sec
= (asection
*) section
->user_data
;
2396 /* If we are freeing contents that are also pointed to by the BFD
2397 library's section structure then make sure to update those pointers
2398 too. Otherwise, the next time we try to load data for this section
2399 we can end up using a stale pointer. */
2400 if (section
->start
== sec
->contents
)
2402 sec
->contents
= NULL
;
2403 sec
->flags
&= ~ SEC_IN_MEMORY
;
2404 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2408 free ((char *) section
->start
);
2409 section
->start
= NULL
;
2410 section
->address
= 0;
2415 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2416 void *arg ATTRIBUTE_UNUSED
)
2418 const char *name
= bfd_get_section_name (abfd
, section
);
2422 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2423 match
= ".debug_info";
2427 for (i
= 0; i
< max
; i
++)
2428 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2429 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2430 && debug_displays
[i
].enabled
!= NULL
2431 && *debug_displays
[i
].enabled
)
2433 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2435 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2436 sec
->name
= sec
->uncompressed_name
;
2438 sec
->name
= sec
->compressed_name
;
2439 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2442 debug_displays
[i
].display (sec
, abfd
);
2444 if (i
!= info
&& i
!= abbrev
)
2445 free_debug_section ((enum dwarf_section_display_enum
) i
);
2451 /* Dump the dwarf debugging information. */
2454 dump_dwarf (bfd
*abfd
)
2456 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2458 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2460 if (bfd_big_endian (abfd
))
2461 byte_get
= byte_get_big_endian
;
2462 else if (bfd_little_endian (abfd
))
2463 byte_get
= byte_get_little_endian
;
2465 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2467 warn (_("File %s does not contain any dwarf debug information\n"),
2468 bfd_get_filename (abfd
));
2472 switch (bfd_get_arch (abfd
))
2475 switch (bfd_get_mach (abfd
))
2477 case bfd_mach_x86_64
:
2478 case bfd_mach_x86_64_intel_syntax
:
2479 case bfd_mach_x86_64_nacl
:
2480 case bfd_mach_x64_32
:
2481 case bfd_mach_x64_32_intel_syntax
:
2482 case bfd_mach_x64_32_nacl
:
2483 init_dwarf_regnames_x86_64 ();
2487 init_dwarf_regnames_i386 ();
2492 case bfd_arch_iamcu
:
2493 init_dwarf_regnames_iamcu ();
2496 case bfd_arch_aarch64
:
2497 init_dwarf_regnames_aarch64();
2504 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2506 free_debug_memory ();
2509 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2510 it. Return NULL on failure. */
2513 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2519 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2520 if (stabsect
== NULL
)
2522 printf (_("No %s section present\n\n"), sect_name
);
2526 size
= bfd_section_size (abfd
, stabsect
);
2527 contents
= (char *) xmalloc (size
);
2529 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2531 non_fatal (_("reading %s section of %s failed: %s"),
2532 sect_name
, bfd_get_filename (abfd
),
2533 bfd_errmsg (bfd_get_error ()));
2544 /* Stabs entries use a 12 byte format:
2545 4 byte string table index
2547 1 byte stab other field
2548 2 byte stab desc field
2550 FIXME: This will have to change for a 64 bit object format. */
2552 #define STRDXOFF (0)
2554 #define OTHEROFF (5)
2557 #define STABSIZE (12)
2559 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2560 using string table section STRSECT_NAME (in `strtab'). */
2563 print_section_stabs (bfd
*abfd
,
2564 const char *stabsect_name
,
2565 unsigned *string_offset_ptr
)
2568 unsigned file_string_table_offset
= 0;
2569 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2570 bfd_byte
*stabp
, *stabs_end
;
2573 stabs_end
= stabp
+ stab_size
;
2575 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2576 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2578 /* Loop through all symbols and print them.
2580 We start the index at -1 because there is a dummy symbol on
2581 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2582 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2586 unsigned char type
, other
;
2587 unsigned short desc
;
2590 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2591 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2592 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2593 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2594 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2596 printf ("\n%-6d ", i
);
2597 /* Either print the stab name, or, if unnamed, print its number
2598 again (makes consistent formatting for tools like awk). */
2599 name
= bfd_get_stab_name (type
);
2601 printf ("%-6s", name
);
2602 else if (type
== N_UNDF
)
2605 printf ("%-6d", type
);
2606 printf (" %-6d %-6d ", other
, desc
);
2607 bfd_printf_vma (abfd
, value
);
2608 printf (" %-6lu", strx
);
2610 /* Symbols with type == 0 (N_UNDF) specify the length of the
2611 string table associated with this file. We use that info
2612 to know how to relocate the *next* file's string table indices. */
2615 file_string_table_offset
= next_file_string_table_offset
;
2616 next_file_string_table_offset
+= value
;
2620 bfd_size_type amt
= strx
+ file_string_table_offset
;
2622 /* Using the (possibly updated) string table offset, print the
2623 string (if any) associated with this symbol. */
2624 if (amt
< stabstr_size
)
2625 /* PR 17512: file: 079-79389-0.001:0.1. */
2626 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2632 *string_offset_ptr
= next_file_string_table_offset
;
2637 const char * section_name
;
2638 const char * string_section_name
;
2639 unsigned string_offset
;
2644 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2647 stab_section_names
* sought
= (stab_section_names
*) names
;
2649 /* Check for section names for which stabsect_name is a prefix, to
2650 handle .stab.N, etc. */
2651 len
= strlen (sought
->section_name
);
2653 /* If the prefix matches, and the files section name ends with a
2654 nul or a digit, then we match. I.e., we want either an exact
2655 match or a section followed by a number. */
2656 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2657 && (section
->name
[len
] == 0
2658 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2661 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2666 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2669 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2675 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2677 stab_section_names s
;
2679 s
.section_name
= stabsect_name
;
2680 s
.string_section_name
= strsect_name
;
2681 s
.string_offset
= 0;
2683 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2689 /* Dump the any sections containing stabs debugging information. */
2692 dump_stabs (bfd
*abfd
)
2694 dump_stabs_section (abfd
, ".stab", ".stabstr");
2695 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2696 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2699 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2701 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2705 dump_bfd_header (bfd
*abfd
)
2709 printf (_("architecture: %s, "),
2710 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2711 bfd_get_mach (abfd
)));
2712 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2714 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2715 PF (HAS_RELOC
, "HAS_RELOC");
2716 PF (EXEC_P
, "EXEC_P");
2717 PF (HAS_LINENO
, "HAS_LINENO");
2718 PF (HAS_DEBUG
, "HAS_DEBUG");
2719 PF (HAS_SYMS
, "HAS_SYMS");
2720 PF (HAS_LOCALS
, "HAS_LOCALS");
2721 PF (DYNAMIC
, "DYNAMIC");
2722 PF (WP_TEXT
, "WP_TEXT");
2723 PF (D_PAGED
, "D_PAGED");
2724 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2725 printf (_("\nstart address 0x"));
2726 bfd_printf_vma (abfd
, abfd
->start_address
);
2732 dump_bfd_private_header (bfd
*abfd
)
2734 bfd_print_private_bfd_data (abfd
, stdout
);
2738 dump_target_specific (bfd
*abfd
)
2740 const struct objdump_private_desc
* const *desc
;
2741 struct objdump_private_option
*opt
;
2744 /* Find the desc. */
2745 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2746 if ((*desc
)->filter (abfd
))
2751 non_fatal (_("option -P/--private not supported by this file"));
2755 /* Clear all options. */
2756 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2757 opt
->selected
= FALSE
;
2759 /* Decode options. */
2760 b
= dump_private_options
;
2763 e
= strchr (b
, ',');
2768 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2769 if (strcmp (opt
->name
, b
) == 0)
2771 opt
->selected
= TRUE
;
2774 if (opt
->name
== NULL
)
2775 non_fatal (_("target specific dump '%s' not supported"), b
);
2786 (*desc
)->dump (abfd
);
2789 /* Display a section in hexadecimal format with associated characters.
2790 Each line prefixed by the zero padded address. */
2793 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2796 bfd_size_type datasize
;
2797 bfd_size_type addr_offset
;
2798 bfd_size_type start_offset
;
2799 bfd_size_type stop_offset
;
2800 unsigned int opb
= bfd_octets_per_byte (abfd
);
2801 /* Bytes per line. */
2802 const int onaline
= 16;
2807 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2810 if (! process_section_p (section
))
2813 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2816 /* Compute the address range to display. */
2817 if (start_address
== (bfd_vma
) -1
2818 || start_address
< section
->vma
)
2821 start_offset
= start_address
- section
->vma
;
2823 if (stop_address
== (bfd_vma
) -1)
2824 stop_offset
= datasize
/ opb
;
2827 if (stop_address
< section
->vma
)
2830 stop_offset
= stop_address
- section
->vma
;
2832 if (stop_offset
> datasize
/ opb
)
2833 stop_offset
= datasize
/ opb
;
2836 if (start_offset
>= stop_offset
)
2839 printf (_("Contents of section %s:"), section
->name
);
2840 if (display_file_offsets
)
2841 printf (_(" (Starting at file offset: 0x%lx)"),
2842 (unsigned long) (section
->filepos
+ start_offset
));
2845 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2847 non_fatal (_("Reading section %s failed because: %s"),
2848 section
->name
, bfd_errmsg (bfd_get_error ()));
2854 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2855 if (strlen (buf
) >= sizeof (buf
))
2859 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2861 count
= strlen (buf
) - count
;
2865 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2866 if (strlen (buf
) >= sizeof (buf
))
2870 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2872 count
= strlen (buf
) - count
;
2876 for (addr_offset
= start_offset
;
2877 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2881 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2882 count
= strlen (buf
);
2883 if ((size_t) count
>= sizeof (buf
))
2887 while (count
< width
)
2892 fputs (buf
+ count
- width
, stdout
);
2895 for (j
= addr_offset
* opb
;
2896 j
< addr_offset
* opb
+ onaline
; j
++)
2898 if (j
< stop_offset
* opb
)
2899 printf ("%02x", (unsigned) (data
[j
]));
2907 for (j
= addr_offset
* opb
;
2908 j
< addr_offset
* opb
+ onaline
; j
++)
2910 if (j
>= stop_offset
* opb
)
2913 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2920 /* Actually display the various requested regions. */
2923 dump_data (bfd
*abfd
)
2925 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2928 /* Should perhaps share code and display with nm? */
2931 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2940 max_count
= dynsymcount
;
2941 printf ("DYNAMIC SYMBOL TABLE:\n");
2946 max_count
= symcount
;
2947 printf ("SYMBOL TABLE:\n");
2951 printf (_("no symbols\n"));
2953 for (count
= 0; count
< max_count
; count
++)
2957 if (*current
== NULL
)
2958 printf (_("no information for symbol number %ld\n"), count
);
2960 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2961 printf (_("could not determine the type of symbol number %ld\n"),
2964 else if (process_section_p ((* current
)->section
)
2965 && (dump_special_syms
2966 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2968 const char *name
= (*current
)->name
;
2970 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2974 /* If we want to demangle the name, we demangle it
2975 here, and temporarily clobber it while calling
2976 bfd_print_symbol. FIXME: This is a gross hack. */
2977 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2979 (*current
)->name
= alloc
;
2980 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2981 bfd_print_symbol_all
);
2984 (*current
)->name
= name
;
2989 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2990 bfd_print_symbol_all
);
3000 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3003 char *last_filename
, *last_functionname
;
3004 unsigned int last_line
;
3005 unsigned int last_discriminator
;
3007 /* Get column headers lined up reasonably. */
3015 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3016 width
= strlen (buf
) - 7;
3018 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3021 last_filename
= NULL
;
3022 last_functionname
= NULL
;
3024 last_discriminator
= 0;
3026 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3029 const char *filename
, *functionname
;
3030 unsigned int linenumber
;
3031 unsigned int discriminator
;
3032 const char *sym_name
;
3033 const char *section_name
;
3034 bfd_vma addend2
= 0;
3036 if (start_address
!= (bfd_vma
) -1
3037 && q
->address
< start_address
)
3039 if (stop_address
!= (bfd_vma
) -1
3040 && q
->address
> stop_address
)
3043 if (with_line_numbers
3045 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3046 &filename
, &functionname
,
3047 &linenumber
, &discriminator
))
3049 if (functionname
!= NULL
3050 && (last_functionname
== NULL
3051 || strcmp (functionname
, last_functionname
) != 0))
3053 printf ("%s():\n", functionname
);
3054 if (last_functionname
!= NULL
)
3055 free (last_functionname
);
3056 last_functionname
= xstrdup (functionname
);
3060 && (linenumber
!= last_line
3061 || (filename
!= NULL
3062 && last_filename
!= NULL
3063 && filename_cmp (filename
, last_filename
) != 0)
3064 || (discriminator
!= last_discriminator
)))
3066 if (discriminator
> 0)
3067 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3069 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3070 linenumber
, discriminator
);
3071 last_line
= linenumber
;
3072 last_discriminator
= discriminator
;
3073 if (last_filename
!= NULL
)
3074 free (last_filename
);
3075 if (filename
== NULL
)
3076 last_filename
= NULL
;
3078 last_filename
= xstrdup (filename
);
3082 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3084 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3085 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3090 section_name
= NULL
;
3093 bfd_printf_vma (abfd
, q
->address
);
3094 if (q
->howto
== NULL
)
3095 printf (" *unknown* ");
3096 else if (q
->howto
->name
)
3098 const char *name
= q
->howto
->name
;
3100 /* R_SPARC_OLO10 relocations contain two addends.
3101 But because 'arelent' lacks enough storage to
3102 store them both, the 64-bit ELF Sparc backend
3103 records this as two relocations. One R_SPARC_LO10
3104 and one R_SPARC_13, both pointing to the same
3105 address. This is merely so that we have some
3106 place to store both addend fields.
3108 Undo this transformation, otherwise the output
3109 will be confusing. */
3110 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3111 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3113 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3115 arelent
*q2
= *(p
+ 1);
3118 && q
->address
== q2
->address
3119 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3121 name
= "R_SPARC_OLO10";
3122 addend2
= q2
->addend
;
3126 printf (" %-16s ", name
);
3129 printf (" %-16d ", q
->howto
->type
);
3133 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3137 if (section_name
== NULL
)
3138 section_name
= "*unknown*";
3139 printf ("[%s]", section_name
);
3144 bfd_signed_vma addend
= q
->addend
;
3152 bfd_printf_vma (abfd
, addend
);
3157 bfd_printf_vma (abfd
, addend2
);
3163 if (last_filename
!= NULL
)
3164 free (last_filename
);
3165 if (last_functionname
!= NULL
)
3166 free (last_functionname
);
3170 dump_relocs_in_section (bfd
*abfd
,
3172 void *dummy ATTRIBUTE_UNUSED
)
3178 if ( bfd_is_abs_section (section
)
3179 || bfd_is_und_section (section
)
3180 || bfd_is_com_section (section
)
3181 || (! process_section_p (section
))
3182 || ((section
->flags
& SEC_RELOC
) == 0))
3185 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3187 bfd_fatal (bfd_get_filename (abfd
));
3189 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3193 printf (" (none)\n\n");
3197 relpp
= (arelent
**) xmalloc (relsize
);
3198 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3203 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3204 bfd_fatal (_("error message was"));
3206 else if (relcount
== 0)
3207 printf (" (none)\n\n");
3211 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3218 dump_relocs (bfd
*abfd
)
3220 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3224 dump_dynamic_relocs (bfd
*abfd
)
3230 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3232 bfd_fatal (bfd_get_filename (abfd
));
3234 printf ("DYNAMIC RELOCATION RECORDS");
3237 printf (" (none)\n\n");
3240 relpp
= (arelent
**) xmalloc (relsize
);
3241 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3244 bfd_fatal (bfd_get_filename (abfd
));
3245 else if (relcount
== 0)
3246 printf (" (none)\n\n");
3250 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3257 /* Creates a table of paths, to search for source files. */
3260 add_include_path (const char *path
)
3264 include_path_count
++;
3265 include_paths
= (const char **)
3266 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3267 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3268 if (path
[1] == ':' && path
[2] == 0)
3269 path
= concat (path
, ".", (const char *) 0);
3271 include_paths
[include_path_count
- 1] = path
;
3275 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3279 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3281 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3282 section
->vma
+= adjust_section_vma
;
3284 section
->lma
+= adjust_section_vma
;
3288 /* Dump selected contents of ABFD. */
3291 dump_bfd (bfd
*abfd
)
3293 /* If we are adjusting section VMA's, change them all now. Changing
3294 the BFD information is a hack. However, we must do it, or
3295 bfd_find_nearest_line will not do the right thing. */
3296 if (adjust_section_vma
!= 0)
3298 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3299 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3302 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3303 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3306 print_arelt_descr (stdout
, abfd
, TRUE
);
3307 if (dump_file_header
)
3308 dump_bfd_header (abfd
);
3309 if (dump_private_headers
)
3310 dump_bfd_private_header (abfd
);
3311 if (dump_private_options
!= NULL
)
3312 dump_target_specific (abfd
);
3313 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3320 || dump_dwarf_section_info
)
3321 syms
= slurp_symtab (abfd
);
3323 if (dump_section_headers
)
3324 dump_headers (abfd
);
3326 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3327 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3328 dynsyms
= slurp_dynamic_symtab (abfd
);
3331 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3332 dynsymcount
, dynsyms
, &synthsyms
);
3338 dump_symbols (abfd
, FALSE
);
3339 if (dump_dynamic_symtab
)
3340 dump_symbols (abfd
, TRUE
);
3341 if (dump_dwarf_section_info
)
3343 if (dump_stab_section_info
)
3345 if (dump_reloc_info
&& ! disassemble
)
3347 if (dump_dynamic_reloc_info
&& ! disassemble
)
3348 dump_dynamic_relocs (abfd
);
3349 if (dump_section_contents
)
3352 disassemble_data (abfd
);
3358 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3359 if (dhandle
!= NULL
)
3361 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3363 dump_debugging_tags
? TRUE
: FALSE
))
3365 non_fatal (_("%s: printing debugging information failed"),
3366 bfd_get_filename (abfd
));
3370 /* PR 6483: If there was no STABS or IEEE debug
3371 info in the file, try DWARF instead. */
3372 else if (! dump_dwarf_section_info
)
3374 dwarf_select_sections_all ();
3403 display_object_bfd (bfd
*abfd
)
3407 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3413 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3415 nonfatal (bfd_get_filename (abfd
));
3416 list_matching_formats (matching
);
3421 if (bfd_get_error () != bfd_error_file_not_recognized
)
3423 nonfatal (bfd_get_filename (abfd
));
3427 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3433 nonfatal (bfd_get_filename (abfd
));
3435 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3437 list_matching_formats (matching
);
3443 display_any_bfd (bfd
*file
, int level
)
3445 /* Decompress sections unless dumping the section contents. */
3446 if (!dump_section_contents
)
3447 file
->flags
|= BFD_DECOMPRESS
;
3449 /* If the file is an archive, process all of its elements. */
3450 if (bfd_check_format (file
, bfd_archive
))
3453 bfd
*last_arfile
= NULL
;
3456 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3457 else if (level
> 100)
3459 /* Prevent corrupted files from spinning us into an
3460 infinite loop. 100 is an arbitrary heuristic. */
3461 fatal (_("Archive nesting is too deep"));
3465 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3469 bfd_set_error (bfd_error_no_error
);
3471 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3474 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3475 nonfatal (bfd_get_filename (file
));
3479 display_any_bfd (arfile
, level
+ 1);
3481 if (last_arfile
!= NULL
)
3483 bfd_close (last_arfile
);
3484 /* PR 17512: file: ac585d01. */
3485 if (arfile
== last_arfile
)
3491 last_arfile
= arfile
;
3494 if (last_arfile
!= NULL
)
3495 bfd_close (last_arfile
);
3498 display_object_bfd (file
);
3502 display_file (char *filename
, char *target
)
3506 if (get_file_size (filename
) < 1)
3512 file
= bfd_openr (filename
, target
);
3515 nonfatal (filename
);
3519 display_any_bfd (file
, 0);
3525 main (int argc
, char **argv
)
3528 char *target
= default_target
;
3529 bfd_boolean seenflag
= FALSE
;
3531 #if defined (HAVE_SETLOCALE)
3532 #if defined (HAVE_LC_MESSAGES)
3533 setlocale (LC_MESSAGES
, "");
3535 setlocale (LC_CTYPE
, "");
3538 bindtextdomain (PACKAGE
, LOCALEDIR
);
3539 textdomain (PACKAGE
);
3541 program_name
= *argv
;
3542 xmalloc_set_program_name (program_name
);
3543 bfd_set_error_program_name (program_name
);
3545 START_PROGRESS (program_name
, 0);
3547 expandargv (&argc
, &argv
);
3550 set_default_bfd_target ();
3552 while ((c
= getopt_long (argc
, argv
,
3553 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3554 long_options
, (int *) 0))
3560 break; /* We've been given a long option. */
3565 if (disassembler_options
)
3566 /* Ignore potential memory leak for now. */
3567 disassembler_options
= concat (disassembler_options
, ",",
3568 optarg
, (const char *) NULL
);
3570 disassembler_options
= optarg
;
3576 display_file_offsets
= TRUE
;
3579 with_line_numbers
= TRUE
;
3588 enum demangling_styles style
;
3590 style
= cplus_demangle_name_to_style (optarg
);
3591 if (style
== unknown_demangling
)
3592 fatal (_("unknown demangling style `%s'"),
3595 cplus_demangle_set_style (style
);
3601 case OPTION_ADJUST_VMA
:
3602 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3604 case OPTION_START_ADDRESS
:
3605 start_address
= parse_vma (optarg
, "--start-address");
3606 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3607 fatal (_("error: the start address should be before the end address"));
3609 case OPTION_STOP_ADDRESS
:
3610 stop_address
= parse_vma (optarg
, "--stop-address");
3611 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3612 fatal (_("error: the stop address should be after the start address"));
3616 prefix_length
= strlen (prefix
);
3617 /* Remove an unnecessary trailing '/' */
3618 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3621 case OPTION_PREFIX_STRIP
:
3622 prefix_strip
= atoi (optarg
);
3623 if (prefix_strip
< 0)
3624 fatal (_("error: prefix strip must be non-negative"));
3626 case OPTION_INSN_WIDTH
:
3627 insn_width
= strtoul (optarg
, NULL
, 0);
3628 if (insn_width
<= 0)
3629 fatal (_("error: instruction width must be positive"));
3632 if (strcmp (optarg
, "B") == 0)
3633 endian
= BFD_ENDIAN_BIG
;
3634 else if (strcmp (optarg
, "L") == 0)
3635 endian
= BFD_ENDIAN_LITTLE
;
3638 nonfatal (_("unrecognized -E option"));
3643 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3644 endian
= BFD_ENDIAN_BIG
;
3645 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3646 endian
= BFD_ENDIAN_LITTLE
;
3649 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3656 dump_file_header
= TRUE
;
3660 formats_info
= TRUE
;
3664 add_include_path (optarg
);
3667 dump_private_headers
= TRUE
;
3671 dump_private_options
= optarg
;
3675 dump_private_headers
= TRUE
;
3677 dump_reloc_info
= TRUE
;
3678 dump_file_header
= TRUE
;
3679 dump_ar_hdrs
= TRUE
;
3680 dump_section_headers
= TRUE
;
3688 dump_dynamic_symtab
= TRUE
;
3696 disassemble_zeroes
= TRUE
;
3700 disassemble_all
= TRUE
;
3705 with_source_code
= TRUE
;
3714 dump_debugging_tags
= 1;
3719 dump_dwarf_section_info
= TRUE
;
3722 dwarf_select_sections_by_letters (optarg
);
3724 dwarf_select_sections_all ();
3727 dump_dwarf_section_info
= TRUE
;
3730 dwarf_select_sections_by_names (optarg
);
3732 dwarf_select_sections_all ();
3734 case OPTION_DWARF_DEPTH
:
3737 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3740 case OPTION_DWARF_START
:
3743 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3744 suppress_bfd_header
= 1;
3747 case OPTION_DWARF_CHECK
:
3751 dump_stab_section_info
= TRUE
;
3755 dump_section_contents
= TRUE
;
3759 dump_reloc_info
= TRUE
;
3763 dump_dynamic_reloc_info
= TRUE
;
3767 dump_ar_hdrs
= TRUE
;
3771 dump_section_headers
= TRUE
;
3776 show_version
= TRUE
;
3782 /* No need to set seenflag or to break - usage() does not return. */
3789 print_version ("objdump");
3795 exit_status
= display_info ();
3799 display_file ("a.out", target
);
3801 for (; optind
< argc
;)
3802 display_file (argv
[optind
++], target
);
3807 END_PROGRESS (program_name
);