1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2014 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. */
59 #include "safe-ctype.h"
61 #include "libiberty.h"
63 #include "filenames.h"
72 /* Internal headers for the ELF .stab-dump code - sorry. */
73 #define BYTES_IN_WORD 32
74 #include "aout/aout64.h"
77 static int exit_status
= 0;
79 static char *default_target
= NULL
; /* Default at runtime. */
81 /* The following variables are set based on arguments passed on the
83 static int show_version
= 0; /* Show the version number. */
84 static int dump_section_contents
; /* -s */
85 static int dump_section_headers
; /* -h */
86 static bfd_boolean dump_file_header
; /* -f */
87 static int dump_symtab
; /* -t */
88 static int dump_dynamic_symtab
; /* -T */
89 static int dump_reloc_info
; /* -r */
90 static int dump_dynamic_reloc_info
; /* -R */
91 static int dump_ar_hdrs
; /* -a */
92 static int dump_private_headers
; /* -p */
93 static char *dump_private_options
; /* -P */
94 static int prefix_addresses
; /* --prefix-addresses */
95 static int with_line_numbers
; /* -l */
96 static bfd_boolean with_source_code
; /* -S */
97 static int show_raw_insn
; /* --show-raw-insn */
98 static int dump_dwarf_section_info
; /* --dwarf */
99 static int dump_stab_section_info
; /* --stabs */
100 static int do_demangle
; /* -C, --demangle */
101 static bfd_boolean disassemble
; /* -d */
102 static bfd_boolean disassemble_all
; /* -D */
103 static int disassemble_zeroes
; /* --disassemble-zeroes */
104 static bfd_boolean formats_info
; /* -i */
105 static int wide_output
; /* -w */
106 static int insn_width
; /* --insn-width */
107 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
108 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
109 static int dump_debugging
; /* --debugging */
110 static int dump_debugging_tags
; /* --debugging-tags */
111 static int suppress_bfd_header
;
112 static int dump_special_syms
= 0; /* --special-syms */
113 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
114 static int file_start_context
= 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets
;/* -F */
116 static const char *prefix
; /* --prefix */
117 static int prefix_strip
; /* --prefix-strip */
118 static size_t prefix_length
;
120 /* A structure to record the sections mentioned in -j switches. */
123 const char * name
; /* The name of the section. */
124 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
125 struct only
* next
; /* Pointer to the next structure in the list. */
127 /* Pointer to an array of 'only' structures.
128 This pointer is NULL if the -j switch has not been used. */
129 static struct only
* only_list
= NULL
;
131 /* Variables for handling include file path table. */
132 static const char **include_paths
;
133 static int include_path_count
;
135 /* Extra info to pass to the section disassembler and address printing
137 struct objdump_disasm_info
141 bfd_boolean require_sec
;
142 arelent
** dynrelbuf
;
144 disassembler_ftype disassemble_fn
;
148 /* Architecture to disassemble for, or default if NULL. */
149 static char *machine
= NULL
;
151 /* Target specific options to the disassembler. */
152 static char *disassembler_options
= NULL
;
154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
155 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
157 /* The symbol table. */
158 static asymbol
**syms
;
160 /* Number of symbols in `syms'. */
161 static long symcount
= 0;
163 /* The sorted symbol table. */
164 static asymbol
**sorted_syms
;
166 /* Number of symbols in `sorted_syms'. */
167 static long sorted_symcount
= 0;
169 /* The dynamic symbol table. */
170 static asymbol
**dynsyms
;
172 /* The synthetic symbol table. */
173 static asymbol
*synthsyms
;
174 static long synthcount
= 0;
176 /* Number of symbols in `dynsyms'. */
177 static long dynsymcount
= 0;
179 static bfd_byte
*stabs
;
180 static bfd_size_type stab_size
;
183 static bfd_size_type stabstr_size
;
185 static bfd_boolean is_relocatable
= FALSE
;
187 /* Handlers for -P/--private. */
188 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
190 OBJDUMP_PRIVATE_VECTORS
194 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
196 usage (FILE *stream
, int status
)
198 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
199 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
200 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
201 fprintf (stream
, _("\
202 -a, --archive-headers Display archive header information\n\
203 -f, --file-headers Display the contents of the overall file header\n\
204 -p, --private-headers Display object format specific file header contents\n\
205 -P, --private=OPT,OPT... Display object format specific contents\n\
206 -h, --[section-]headers Display the contents of the section headers\n\
207 -x, --all-headers Display the contents of all headers\n\
208 -d, --disassemble Display assembler contents of executable sections\n\
209 -D, --disassemble-all Display assembler contents of all sections\n\
210 -S, --source Intermix source code with disassembly\n\
211 -s, --full-contents Display the full contents of all sections requested\n\
212 -g, --debugging Display debug information in object file\n\
213 -e, --debugging-tags Display debug information using ctags style\n\
214 -G, --stabs Display (in raw form) any STABS info in the file\n\
215 -W[lLiaprmfFsoRt] or\n\
216 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
217 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
218 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
220 Display DWARF info in the file\n\
221 -t, --syms Display the contents of the symbol table(s)\n\
222 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
223 -r, --reloc Display the relocation entries in the file\n\
224 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
225 @<file> Read options from <file>\n\
226 -v, --version Display this program's version number\n\
227 -i, --info List object formats and architectures supported\n\
228 -H, --help Display this information\n\
232 const struct objdump_private_desc
* const *desc
;
234 fprintf (stream
, _("\n The following switches are optional:\n"));
235 fprintf (stream
, _("\
236 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
237 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
238 -j, --section=NAME Only display information for section NAME\n\
239 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
240 -EB --endian=big Assume big endian format when disassembling\n\
241 -EL --endian=little Assume little endian format when disassembling\n\
242 --file-start-context Include context from start of file (with -S)\n\
243 -I, --include=DIR Add DIR to search list for source files\n\
244 -l, --line-numbers Include line numbers and filenames in output\n\
245 -F, --file-offsets Include file offsets when displaying information\n\
246 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
247 The STYLE, if specified, can be `auto', `gnu',\n\
248 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
250 -w, --wide Format output for more than 80 columns\n\
251 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
252 --start-address=ADDR Only process data whose address is >= ADDR\n\
253 --stop-address=ADDR Only process data whose address is <= ADDR\n\
254 --prefix-addresses Print complete address alongside disassembly\n\
255 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
256 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
257 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
258 --special-syms Include special symbols in symbol dumps\n\
259 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
260 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
261 fprintf (stream
, _("\
262 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
263 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
265 --dwarf-check Make additional dwarf internal consistency checks.\
267 list_supported_targets (program_name
, stream
);
268 list_supported_architectures (program_name
, stream
);
270 disassembler_usage (stream
);
272 if (objdump_private_vectors
[0] != NULL
)
275 _("\nOptions supported for -P/--private switch:\n"));
276 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
277 (*desc
)->help (stream
);
280 if (REPORT_BUGS_TO
[0] && status
== 0)
281 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
285 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
289 OPTION_START_ADDRESS
,
301 static struct option long_options
[]=
303 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
304 {"all-headers", no_argument
, NULL
, 'x'},
305 {"private-headers", no_argument
, NULL
, 'p'},
306 {"private", required_argument
, NULL
, 'P'},
307 {"architecture", required_argument
, NULL
, 'm'},
308 {"archive-headers", no_argument
, NULL
, 'a'},
309 {"debugging", no_argument
, NULL
, 'g'},
310 {"debugging-tags", no_argument
, NULL
, 'e'},
311 {"demangle", optional_argument
, NULL
, 'C'},
312 {"disassemble", no_argument
, NULL
, 'd'},
313 {"disassemble-all", no_argument
, NULL
, 'D'},
314 {"disassembler-options", required_argument
, NULL
, 'M'},
315 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
316 {"dynamic-reloc", no_argument
, NULL
, 'R'},
317 {"dynamic-syms", no_argument
, NULL
, 'T'},
318 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
319 {"file-headers", no_argument
, NULL
, 'f'},
320 {"file-offsets", no_argument
, NULL
, 'F'},
321 {"file-start-context", no_argument
, &file_start_context
, 1},
322 {"full-contents", no_argument
, NULL
, 's'},
323 {"headers", no_argument
, NULL
, 'h'},
324 {"help", no_argument
, NULL
, 'H'},
325 {"info", no_argument
, NULL
, 'i'},
326 {"line-numbers", no_argument
, NULL
, 'l'},
327 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
328 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
329 {"reloc", no_argument
, NULL
, 'r'},
330 {"section", required_argument
, NULL
, 'j'},
331 {"section-headers", no_argument
, NULL
, 'h'},
332 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
333 {"source", no_argument
, NULL
, 'S'},
334 {"special-syms", no_argument
, &dump_special_syms
, 1},
335 {"include", required_argument
, NULL
, 'I'},
336 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
337 {"stabs", no_argument
, NULL
, 'G'},
338 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
339 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
340 {"syms", no_argument
, NULL
, 't'},
341 {"target", required_argument
, NULL
, 'b'},
342 {"version", no_argument
, NULL
, 'V'},
343 {"wide", no_argument
, NULL
, 'w'},
344 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
345 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
346 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
347 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
348 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
349 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
350 {0, no_argument
, 0, 0}
354 nonfatal (const char *msg
)
360 /* Returns TRUE if the specified section should be dumped. */
363 process_section_p (asection
* section
)
367 if (only_list
== NULL
)
370 for (only
= only_list
; only
; only
= only
->next
)
371 if (strcmp (only
->name
, section
->name
) == 0)
380 /* Add an entry to the 'only' list. */
383 add_only (char * name
)
387 /* First check to make sure that we do not
388 already have an entry for this name. */
389 for (only
= only_list
; only
; only
= only
->next
)
390 if (strcmp (only
->name
, name
) == 0)
393 only
= xmalloc (sizeof * only
);
396 only
->next
= only_list
;
400 /* Release the memory used by the 'only' list.
401 PR 11225: Issue a warning message for unseen sections.
402 Only do this if none of the sections were seen. This is mainly to support
403 tools like the GAS testsuite where an object file is dumped with a list of
404 generic section names known to be present in a range of different file
408 free_only_list (void)
410 bfd_boolean at_least_one_seen
= FALSE
;
414 if (only_list
== NULL
)
417 for (only
= only_list
; only
; only
= only
->next
)
420 at_least_one_seen
= TRUE
;
424 for (only
= only_list
; only
; only
= next
)
426 if (! at_least_one_seen
)
428 non_fatal (_("section '%s' mentioned in a -j option, "
429 "but not found in any input file"),
440 dump_section_header (bfd
*abfd
, asection
*section
,
441 void *ignored ATTRIBUTE_UNUSED
)
444 unsigned int opb
= bfd_octets_per_byte (abfd
);
446 /* Ignore linker created section. See elfNN_ia64_object_p in
448 if (section
->flags
& SEC_LINKER_CREATED
)
451 /* PR 10413: Skip sections that we are ignoring. */
452 if (! process_section_p (section
))
455 printf ("%3d %-13s %08lx ", section
->index
,
456 bfd_get_section_name (abfd
, section
),
457 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
458 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
460 bfd_printf_vma (abfd
, section
->lma
);
461 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
462 bfd_get_section_alignment (abfd
, section
));
468 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
470 PF (SEC_HAS_CONTENTS
, "CONTENTS");
471 PF (SEC_ALLOC
, "ALLOC");
472 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
473 PF (SEC_LOAD
, "LOAD");
474 PF (SEC_RELOC
, "RELOC");
475 PF (SEC_READONLY
, "READONLY");
476 PF (SEC_CODE
, "CODE");
477 PF (SEC_DATA
, "DATA");
479 PF (SEC_DEBUGGING
, "DEBUGGING");
480 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
481 PF (SEC_EXCLUDE
, "EXCLUDE");
482 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
483 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
485 PF (SEC_TIC54X_BLOCK
, "BLOCK");
486 PF (SEC_TIC54X_CLINK
, "CLINK");
488 PF (SEC_SMALL_DATA
, "SMALL_DATA");
489 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
490 PF (SEC_COFF_SHARED
, "SHARED");
491 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
492 PF (SEC_GROUP
, "GROUP");
494 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
497 struct coff_comdat_info
*comdat
;
499 switch (section
->flags
& SEC_LINK_DUPLICATES
)
503 case SEC_LINK_DUPLICATES_DISCARD
:
504 ls
= "LINK_ONCE_DISCARD";
506 case SEC_LINK_DUPLICATES_ONE_ONLY
:
507 ls
= "LINK_ONCE_ONE_ONLY";
509 case SEC_LINK_DUPLICATES_SAME_SIZE
:
510 ls
= "LINK_ONCE_SAME_SIZE";
512 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
513 ls
= "LINK_ONCE_SAME_CONTENTS";
516 printf ("%s%s", comma
, ls
);
518 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
520 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
530 dump_headers (bfd
*abfd
)
532 printf (_("Sections:\n"));
535 printf (_("Idx Name Size VMA LMA File off Algn"));
537 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
538 if (bfd_get_arch_size (abfd
) == 32)
539 printf (_("Idx Name Size VMA LMA File off Algn"));
541 printf (_("Idx Name Size VMA LMA File off Algn"));
545 printf (_(" Flags"));
548 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
552 slurp_symtab (bfd
*abfd
)
557 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
563 storage
= bfd_get_symtab_upper_bound (abfd
);
566 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
567 bfd_fatal (_("error message was"));
570 sy
= (asymbol
**) xmalloc (storage
);
572 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
574 bfd_fatal (bfd_get_filename (abfd
));
578 /* Read in the dynamic symbols. */
581 slurp_dynamic_symtab (bfd
*abfd
)
586 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
589 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
591 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
597 bfd_fatal (bfd_get_filename (abfd
));
600 sy
= (asymbol
**) xmalloc (storage
);
602 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
604 bfd_fatal (bfd_get_filename (abfd
));
608 /* Filter out (in place) symbols that are useless for disassembly.
609 COUNT is the number of elements in SYMBOLS.
610 Return the number of useful symbols. */
613 remove_useless_symbols (asymbol
**symbols
, long count
)
615 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
619 asymbol
*sym
= *in_ptr
++;
621 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
623 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
625 if (bfd_is_und_section (sym
->section
)
626 || bfd_is_com_section (sym
->section
))
631 return out_ptr
- symbols
;
634 /* Sort symbols into value order. */
637 compare_symbols (const void *ap
, const void *bp
)
639 const asymbol
*a
= * (const asymbol
**) ap
;
640 const asymbol
*b
= * (const asymbol
**) bp
;
650 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
652 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
655 if (a
->section
> b
->section
)
657 else if (a
->section
< b
->section
)
660 an
= bfd_asymbol_name (a
);
661 bn
= bfd_asymbol_name (b
);
665 /* The symbols gnu_compiled and gcc2_compiled convey no real
666 information, so put them after other symbols with the same value. */
667 af
= (strstr (an
, "gnu_compiled") != NULL
668 || strstr (an
, "gcc2_compiled") != NULL
);
669 bf
= (strstr (bn
, "gnu_compiled") != NULL
670 || strstr (bn
, "gcc2_compiled") != NULL
);
677 /* We use a heuristic for the file name, to try to sort it after
678 more useful symbols. It may not work on non Unix systems, but it
679 doesn't really matter; the only difference is precisely which
680 symbol names get printed. */
682 #define file_symbol(s, sn, snl) \
683 (((s)->flags & BSF_FILE) != 0 \
684 || ((sn)[(snl) - 2] == '.' \
685 && ((sn)[(snl) - 1] == 'o' \
686 || (sn)[(snl) - 1] == 'a')))
688 af
= file_symbol (a
, an
, anl
);
689 bf
= file_symbol (b
, bn
, bnl
);
696 /* Try to sort global symbols before local symbols before function
697 symbols before debugging symbols. */
702 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
704 if ((aflags
& BSF_DEBUGGING
) != 0)
709 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
711 if ((aflags
& BSF_FUNCTION
) != 0)
716 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
718 if ((aflags
& BSF_LOCAL
) != 0)
723 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
725 if ((aflags
& BSF_GLOBAL
) != 0)
731 /* Symbols that start with '.' might be section names, so sort them
732 after symbols that don't start with '.'. */
733 if (an
[0] == '.' && bn
[0] != '.')
735 if (an
[0] != '.' && bn
[0] == '.')
738 /* Finally, if we can't distinguish them in any other way, try to
739 get consistent results by sorting the symbols by name. */
740 return strcmp (an
, bn
);
743 /* Sort relocs into address order. */
746 compare_relocs (const void *ap
, const void *bp
)
748 const arelent
*a
= * (const arelent
**) ap
;
749 const arelent
*b
= * (const arelent
**) bp
;
751 if (a
->address
> b
->address
)
753 else if (a
->address
< b
->address
)
756 /* So that associated relocations tied to the same address show up
757 in the correct order, we don't do any further sorting. */
766 /* Print an address (VMA) to the output stream in INFO.
767 If SKIP_ZEROES is TRUE, omit leading zeroes. */
770 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
771 bfd_boolean skip_zeroes
)
775 struct objdump_disasm_info
*aux
;
777 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
778 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
783 for (p
= buf
; *p
== '0'; ++p
)
788 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
791 /* Print the name of a symbol. */
794 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
798 const char *name
, *version_string
= NULL
;
799 bfd_boolean hidden
= FALSE
;
802 name
= bfd_asymbol_name (sym
);
803 if (do_demangle
&& name
[0] != '\0')
805 /* Demangle the name. */
806 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
811 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
812 version_string
= bfd_elf_get_symbol_version_string (abfd
, sym
,
815 if (bfd_is_und_section (bfd_get_section (sym
)))
820 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
821 if (version_string
&& *version_string
!= '\0')
822 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
828 if (version_string
&& *version_string
!= '\0')
829 printf (hidden
? "@%s" : "@@%s", version_string
);
836 /* Locate a symbol given a bfd and a section (from INFO->application_data),
837 and a VMA. If INFO->application_data->require_sec is TRUE, then always
838 require the symbol to be in the section. Returns NULL if there is no
839 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
840 of the symbol in sorted_syms. */
843 find_symbol_for_address (bfd_vma vma
,
844 struct disassemble_info
*inf
,
847 /* @@ Would it speed things up to cache the last two symbols returned,
848 and maybe their address ranges? For many processors, only one memory
849 operand can be present at a time, so the 2-entry cache wouldn't be
850 constantly churned by code doing heavy memory accesses. */
852 /* Indices in `sorted_syms'. */
854 long max_count
= sorted_symcount
;
856 struct objdump_disasm_info
*aux
;
860 bfd_boolean want_section
;
862 if (sorted_symcount
< 1)
865 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
868 opb
= inf
->octets_per_byte
;
870 /* Perform a binary search looking for the closest symbol to the
871 required value. We are searching the range (min, max_count]. */
872 while (min
+ 1 < max_count
)
876 thisplace
= (max_count
+ min
) / 2;
877 sym
= sorted_syms
[thisplace
];
879 if (bfd_asymbol_value (sym
) > vma
)
880 max_count
= thisplace
;
881 else if (bfd_asymbol_value (sym
) < vma
)
890 /* The symbol we want is now in min, the low end of the range we
891 were searching. If there are several symbols with the same
892 value, we want the first one. */
895 && (bfd_asymbol_value (sorted_syms
[thisplace
])
896 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
899 /* Prefer a symbol in the current section if we have multple symbols
900 with the same value, as can occur with overlays or zero size
903 while (min
< max_count
904 && (bfd_asymbol_value (sorted_syms
[min
])
905 == bfd_asymbol_value (sorted_syms
[thisplace
])))
907 if (sorted_syms
[min
]->section
== sec
908 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
915 return sorted_syms
[thisplace
];
920 /* If the file is relocatable, and the symbol could be from this
921 section, prefer a symbol from this section over symbols from
922 others, even if the other symbol's value might be closer.
924 Note that this may be wrong for some symbol references if the
925 sections have overlapping memory ranges, but in that case there's
926 no way to tell what's desired without looking at the relocation
929 Also give the target a chance to reject symbols. */
930 want_section
= (aux
->require_sec
931 || ((abfd
->flags
& HAS_RELOC
) != 0
932 && vma
>= bfd_get_section_vma (abfd
, sec
)
933 && vma
< (bfd_get_section_vma (abfd
, sec
)
934 + bfd_section_size (abfd
, sec
) / opb
)));
935 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
936 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
939 long newplace
= sorted_symcount
;
941 for (i
= min
- 1; i
>= 0; i
--)
943 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
944 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
946 if (newplace
== sorted_symcount
)
949 if (bfd_asymbol_value (sorted_syms
[i
])
950 != bfd_asymbol_value (sorted_syms
[newplace
]))
953 /* Remember this symbol and keep searching until we reach
954 an earlier address. */
959 if (newplace
!= sorted_symcount
)
960 thisplace
= newplace
;
963 /* We didn't find a good symbol with a smaller value.
964 Look for one with a larger value. */
965 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
967 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
968 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
976 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
977 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
978 /* There is no suitable symbol. */
985 return sorted_syms
[thisplace
];
988 /* Print an address and the offset to the nearest symbol. */
991 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
992 bfd_vma vma
, struct disassemble_info
*inf
,
993 bfd_boolean skip_zeroes
)
995 objdump_print_value (vma
, inf
, skip_zeroes
);
1001 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1002 bfd_get_section_name (abfd
, sec
));
1003 secaddr
= bfd_get_section_vma (abfd
, sec
);
1006 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1007 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1009 else if (vma
> secaddr
)
1011 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1012 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1014 (*inf
->fprintf_func
) (inf
->stream
, ">");
1018 (*inf
->fprintf_func
) (inf
->stream
, " <");
1019 objdump_print_symname (abfd
, inf
, sym
);
1020 if (bfd_asymbol_value (sym
) > vma
)
1022 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1023 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1025 else if (vma
> bfd_asymbol_value (sym
))
1027 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1028 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1030 (*inf
->fprintf_func
) (inf
->stream
, ">");
1033 if (display_file_offsets
)
1034 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1035 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1038 /* Print an address (VMA), symbolically if possible.
1039 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1042 objdump_print_addr (bfd_vma vma
,
1043 struct disassemble_info
*inf
,
1044 bfd_boolean skip_zeroes
)
1046 struct objdump_disasm_info
*aux
;
1047 asymbol
*sym
= NULL
;
1048 bfd_boolean skip_find
= FALSE
;
1050 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1052 if (sorted_symcount
< 1)
1054 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1055 objdump_print_value (vma
, inf
, skip_zeroes
);
1057 if (display_file_offsets
)
1058 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1059 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1063 if (aux
->reloc
!= NULL
1064 && aux
->reloc
->sym_ptr_ptr
!= NULL
1065 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1067 sym
= * aux
->reloc
->sym_ptr_ptr
;
1069 /* Adjust the vma to the reloc. */
1070 vma
+= bfd_asymbol_value (sym
);
1072 if (bfd_is_und_section (bfd_get_section (sym
)))
1077 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1079 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1083 /* Print VMA to INFO. This function is passed to the disassembler
1087 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1089 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1092 /* Determine if the given address has a symbol associated with it. */
1095 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1099 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1101 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1104 /* Hold the last function name and the last line number we displayed
1105 in a disassembly. */
1107 static char *prev_functionname
;
1108 static unsigned int prev_line
;
1109 static unsigned int prev_discriminator
;
1111 /* We keep a list of all files that we have seen when doing a
1112 disassembly with source, so that we know how much of the file to
1113 display. This can be important for inlined functions. */
1115 struct print_file_list
1117 struct print_file_list
*next
;
1118 const char *filename
;
1119 const char *modname
;
1122 const char **linemap
;
1128 static struct print_file_list
*print_files
;
1130 /* The number of preceding context lines to show when we start
1131 displaying a file for the first time. */
1133 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1135 /* Read a complete file into memory. */
1138 slurp_file (const char *fn
, size_t *size
)
1141 int ps
= getpagesize ();
1146 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1150 if (fstat (fd
, &st
) < 0)
1157 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1158 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1159 if (map
!= (char *) -1L)
1165 map
= (const char *) malloc (*size
);
1166 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1168 free ((void *) map
);
1175 #define line_map_decrease 5
1177 /* Precompute array of lines for a mapped file. */
1179 static const char **
1180 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1182 const char *p
, *lstart
, *end
;
1183 int chars_per_line
= 45; /* First iteration will use 40. */
1184 unsigned int lineno
;
1185 const char **linemap
= NULL
;
1186 unsigned long line_map_size
= 0;
1192 for (p
= map
; p
< end
; p
++)
1196 if (p
+ 1 < end
&& p
[1] == '\r')
1199 else if (*p
== '\r')
1201 if (p
+ 1 < end
&& p
[1] == '\n')
1207 /* End of line found. */
1209 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1211 unsigned long newsize
;
1213 chars_per_line
-= line_map_decrease
;
1214 if (chars_per_line
<= 1)
1216 line_map_size
= size
/ chars_per_line
+ 1;
1217 if (line_map_size
< lineno
+ 1)
1218 line_map_size
= lineno
+ 1;
1219 newsize
= line_map_size
* sizeof (char *);
1220 linemap
= (const char **) xrealloc (linemap
, newsize
);
1223 linemap
[lineno
++] = lstart
;
1231 /* Tries to open MODNAME, and if successful adds a node to print_files
1232 linked list and returns that node. Returns NULL on failure. */
1234 static struct print_file_list
*
1235 try_print_file_open (const char *origname
, const char *modname
)
1237 struct print_file_list
*p
;
1239 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1241 p
->map
= slurp_file (modname
, &p
->mapsize
);
1248 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1250 p
->filename
= origname
;
1251 p
->modname
= modname
;
1252 p
->next
= print_files
;
1258 /* If the source file, as described in the symtab, is not found
1259 try to locate it in one of the paths specified with -I
1260 If found, add location to print_files linked list. */
1262 static struct print_file_list
*
1263 update_source_path (const char *filename
)
1265 struct print_file_list
*p
;
1269 p
= try_print_file_open (filename
, filename
);
1273 if (include_path_count
== 0)
1276 /* Get the name of the file. */
1277 fname
= lbasename (filename
);
1279 /* If file exists under a new path, we need to add it to the list
1280 so that show_line knows about it. */
1281 for (i
= 0; i
< include_path_count
; i
++)
1283 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1285 p
= try_print_file_open (filename
, modname
);
1295 /* Print a source file line. */
1298 print_line (struct print_file_list
*p
, unsigned int linenum
)
1304 if (linenum
>= p
->maxline
)
1306 l
= p
->linemap
[linenum
];
1307 /* Test fwrite return value to quiet glibc warning. */
1308 len
= strcspn (l
, "\n\r");
1309 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1313 /* Print a range of source code lines. */
1316 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1320 while (start
<= end
)
1322 print_line (p
, start
);
1327 /* Show the line number, or the source line, in a disassembly
1331 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1333 const char *filename
;
1334 const char *functionname
;
1335 unsigned int linenumber
;
1336 unsigned int discriminator
;
1339 if (! with_line_numbers
&& ! with_source_code
)
1342 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1343 &filename
, &functionname
,
1344 &linenumber
, &discriminator
))
1347 if (filename
!= NULL
&& *filename
== '\0')
1349 if (functionname
!= NULL
&& *functionname
== '\0')
1350 functionname
= NULL
;
1353 && IS_ABSOLUTE_PATH (filename
)
1357 const char *fname
= filename
;
1358 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1361 memcpy (path
, prefix
, prefix_length
);
1362 path_up
= path
+ prefix_length
;
1364 /* Build relocated filename, stripping off leading directories
1365 from the initial filename if requested. */
1366 if (prefix_strip
> 0)
1371 /* Skip selected directory levels. */
1372 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1373 if (IS_DIR_SEPARATOR(*s
))
1380 /* Update complete filename. */
1381 strncpy (path_up
, fname
, PATH_MAX
);
1382 path_up
[PATH_MAX
] = '\0';
1390 if (with_line_numbers
)
1392 if (functionname
!= NULL
1393 && (prev_functionname
== NULL
1394 || strcmp (functionname
, prev_functionname
) != 0))
1395 printf ("%s():\n", functionname
);
1396 if (linenumber
> 0 && (linenumber
!= prev_line
||
1397 (discriminator
!= prev_discriminator
)))
1399 if (discriminator
> 0)
1400 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1401 linenumber
, discriminator
);
1403 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1407 if (with_source_code
1411 struct print_file_list
**pp
, *p
;
1414 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1415 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1422 filename
= xstrdup (filename
);
1423 p
= update_source_path (filename
);
1426 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1428 if (file_start_context
&& p
->first
)
1432 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1433 if (l
>= linenumber
)
1435 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1436 l
= p
->last_line
+ 1;
1438 dump_lines (p
, l
, linenumber
);
1439 p
->last_line
= linenumber
;
1444 if (functionname
!= NULL
1445 && (prev_functionname
== NULL
1446 || strcmp (functionname
, prev_functionname
) != 0))
1448 if (prev_functionname
!= NULL
)
1449 free (prev_functionname
);
1450 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1451 strcpy (prev_functionname
, functionname
);
1454 if (linenumber
> 0 && linenumber
!= prev_line
)
1455 prev_line
= linenumber
;
1457 if (discriminator
!= prev_discriminator
)
1458 prev_discriminator
= discriminator
;
1461 /* Pseudo FILE object for strings. */
1469 /* sprintf to a "stream". */
1471 static int ATTRIBUTE_PRINTF_2
1472 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1479 size_t space
= f
->alloc
- f
->pos
;
1481 va_start (args
, format
);
1482 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1488 f
->alloc
= (f
->alloc
+ n
) * 2;
1489 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1496 /* The number of zeroes we want to see before we start skipping them.
1497 The number is arbitrarily chosen. */
1499 #define DEFAULT_SKIP_ZEROES 8
1501 /* The number of zeroes to skip at the end of a section. If the
1502 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1503 SKIP_ZEROES, they will be disassembled. If there are fewer than
1504 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1505 attempt to avoid disassembling zeroes inserted by section
1508 #define DEFAULT_SKIP_ZEROES_AT_END 3
1510 /* Disassemble some data in memory between given values. */
1513 disassemble_bytes (struct disassemble_info
* inf
,
1514 disassembler_ftype disassemble_fn
,
1517 bfd_vma start_offset
,
1518 bfd_vma stop_offset
,
1521 arelent
** relppend
)
1523 struct objdump_disasm_info
*aux
;
1525 int octets_per_line
;
1526 int skip_addr_chars
;
1527 bfd_vma addr_offset
;
1528 unsigned int opb
= inf
->octets_per_byte
;
1529 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1530 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1534 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1538 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1542 octets_per_line
= insn_width
;
1544 octets_per_line
= 4;
1546 octets_per_line
= 16;
1548 /* Figure out how many characters to skip at the start of an
1549 address, to make the disassembly look nicer. We discard leading
1550 zeroes in chunks of 4, ensuring that there is always a leading
1552 skip_addr_chars
= 0;
1553 if (! prefix_addresses
)
1557 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1559 while (buf
[skip_addr_chars
] == '0')
1562 /* Don't discard zeros on overflow. */
1563 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1564 skip_addr_chars
= 0;
1566 if (skip_addr_chars
!= 0)
1567 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1570 inf
->insn_info_valid
= 0;
1572 addr_offset
= start_offset
;
1573 while (addr_offset
< stop_offset
)
1576 bfd_boolean need_nl
= FALSE
;
1577 int previous_octets
;
1579 /* Remember the length of the previous instruction. */
1580 previous_octets
= octets
;
1583 /* Make sure we don't use relocs from previous instructions. */
1586 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1588 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1591 if (! disassemble_zeroes
1592 && (inf
->insn_info_valid
== 0
1593 || inf
->branch_delay_insns
== 0)
1594 && (z
- addr_offset
* opb
>= skip_zeroes
1595 || (z
== stop_offset
* opb
&&
1596 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1598 /* If there are more nonzero octets to follow, we only skip
1599 zeroes in multiples of 4, to try to avoid running over
1600 the start of an instruction which happens to start with
1602 if (z
!= stop_offset
* opb
)
1603 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1605 octets
= z
- addr_offset
* opb
;
1607 /* If we are going to display more data, and we are displaying
1608 file offsets, then tell the user how many zeroes we skip
1609 and the file offset from where we resume dumping. */
1610 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1611 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1613 (unsigned long) (section
->filepos
1614 + (addr_offset
+ (octets
/ opb
))));
1624 if (with_line_numbers
|| with_source_code
)
1625 show_line (aux
->abfd
, section
, addr_offset
);
1627 if (! prefix_addresses
)
1631 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1632 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1636 printf ("%s:\t", buf
+ skip_addr_chars
);
1640 aux
->require_sec
= TRUE
;
1641 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1642 aux
->require_sec
= FALSE
;
1649 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1650 inf
->stream
= &sfile
;
1651 inf
->bytes_per_line
= 0;
1652 inf
->bytes_per_chunk
= 0;
1653 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1655 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1657 if (inf
->disassembler_needs_relocs
1658 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1659 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1660 && *relppp
< relppend
)
1662 bfd_signed_vma distance_to_rel
;
1664 distance_to_rel
= (**relppp
)->address
1665 - (rel_offset
+ addr_offset
);
1667 /* Check to see if the current reloc is associated with
1668 the instruction that we are about to disassemble. */
1669 if (distance_to_rel
== 0
1670 /* FIXME: This is wrong. We are trying to catch
1671 relocs that are addressed part way through the
1672 current instruction, as might happen with a packed
1673 VLIW instruction. Unfortunately we do not know the
1674 length of the current instruction since we have not
1675 disassembled it yet. Instead we take a guess based
1676 upon the length of the previous instruction. The
1677 proper solution is to have a new target-specific
1678 disassembler function which just returns the length
1679 of an instruction at a given address without trying
1680 to display its disassembly. */
1681 || (distance_to_rel
> 0
1682 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1684 inf
->flags
|= INSN_HAS_RELOC
;
1685 aux
->reloc
= **relppp
;
1689 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1690 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1691 inf
->stream
= stdout
;
1692 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1693 octets_per_line
= inf
->bytes_per_line
;
1694 if (octets
< (int) opb
)
1697 printf ("%s\n", sfile
.buffer
);
1700 non_fatal (_("disassemble_fn returned length %d"),
1711 octets
= octets_per_line
;
1712 if (addr_offset
+ octets
/ opb
> stop_offset
)
1713 octets
= (stop_offset
- addr_offset
) * opb
;
1715 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1717 if (ISPRINT (data
[j
]))
1718 buf
[j
- addr_offset
* opb
] = data
[j
];
1720 buf
[j
- addr_offset
* opb
] = '.';
1722 buf
[j
- addr_offset
* opb
] = '\0';
1725 if (prefix_addresses
1727 : show_raw_insn
>= 0)
1731 /* If ! prefix_addresses and ! wide_output, we print
1732 octets_per_line octets per line. */
1734 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1735 pb
= octets_per_line
;
1737 if (inf
->bytes_per_chunk
)
1738 bpc
= inf
->bytes_per_chunk
;
1742 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1746 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1748 for (k
= bpc
- 1; k
>= 0; k
--)
1749 printf ("%02x", (unsigned) data
[j
+ k
]);
1754 for (k
= 0; k
< bpc
; k
++)
1755 printf ("%02x", (unsigned) data
[j
+ k
]);
1760 for (; pb
< octets_per_line
; pb
+= bpc
)
1764 for (k
= 0; k
< bpc
; k
++)
1769 /* Separate raw data from instruction by extra space. */
1779 printf ("%s", sfile
.buffer
);
1781 if (prefix_addresses
1783 : show_raw_insn
>= 0)
1791 j
= addr_offset
* opb
+ pb
;
1793 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1794 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1798 printf ("%s:\t", buf
+ skip_addr_chars
);
1800 pb
+= octets_per_line
;
1803 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1807 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1809 for (k
= bpc
- 1; k
>= 0; k
--)
1810 printf ("%02x", (unsigned) data
[j
+ k
]);
1815 for (k
= 0; k
< bpc
; k
++)
1816 printf ("%02x", (unsigned) data
[j
+ k
]);
1829 while ((*relppp
) < relppend
1830 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1832 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1843 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1846 if (q
->howto
== NULL
)
1847 printf (": *unknown*\t");
1848 else if (q
->howto
->name
)
1849 printf (": %s\t", q
->howto
->name
);
1851 printf (": %d\t", q
->howto
->type
);
1853 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1854 printf ("*unknown*");
1857 const char *sym_name
;
1859 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1860 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1861 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1866 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1867 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1868 if (sym_name
== NULL
|| *sym_name
== '\0')
1869 sym_name
= "*unknown*";
1870 printf ("%s", sym_name
);
1876 bfd_signed_vma addend
= q
->addend
;
1884 objdump_print_value (addend
, inf
, TRUE
);
1896 addr_offset
+= octets
/ opb
;
1899 free (sfile
.buffer
);
1903 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1905 const struct elf_backend_data
* bed
;
1906 bfd_vma sign_adjust
= 0;
1907 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1908 struct objdump_disasm_info
* paux
;
1909 unsigned int opb
= pinfo
->octets_per_byte
;
1910 bfd_byte
* data
= NULL
;
1911 bfd_size_type datasize
= 0;
1912 arelent
** rel_pp
= NULL
;
1913 arelent
** rel_ppstart
= NULL
;
1914 arelent
** rel_ppend
;
1915 unsigned long stop_offset
;
1916 asymbol
* sym
= NULL
;
1920 unsigned long addr_offset
;
1922 /* Sections that do not contain machine
1923 code are not normally disassembled. */
1924 if (! disassemble_all
1925 && only_list
== NULL
1926 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1927 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1930 if (! process_section_p (section
))
1933 datasize
= bfd_get_section_size (section
);
1937 if (start_address
== (bfd_vma
) -1
1938 || start_address
< section
->vma
)
1941 addr_offset
= start_address
- section
->vma
;
1943 if (stop_address
== (bfd_vma
) -1)
1944 stop_offset
= datasize
/ opb
;
1947 if (stop_address
< section
->vma
)
1950 stop_offset
= stop_address
- section
->vma
;
1951 if (stop_offset
> datasize
/ opb
)
1952 stop_offset
= datasize
/ opb
;
1955 if (addr_offset
>= stop_offset
)
1958 /* Decide which set of relocs to use. Load them if necessary. */
1959 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1960 if (paux
->dynrelbuf
)
1962 rel_pp
= paux
->dynrelbuf
;
1963 rel_count
= paux
->dynrelcount
;
1964 /* Dynamic reloc addresses are absolute, non-dynamic are section
1965 relative. REL_OFFSET specifies the reloc address corresponding
1966 to the start of this section. */
1967 rel_offset
= section
->vma
;
1975 if ((section
->flags
& SEC_RELOC
) != 0
1976 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1980 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1982 bfd_fatal (bfd_get_filename (abfd
));
1986 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1987 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1989 bfd_fatal (bfd_get_filename (abfd
));
1991 /* Sort the relocs by address. */
1992 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1996 rel_ppend
= rel_pp
+ rel_count
;
1998 data
= (bfd_byte
*) xmalloc (datasize
);
2000 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2002 paux
->sec
= section
;
2003 pinfo
->buffer
= data
;
2004 pinfo
->buffer_vma
= section
->vma
;
2005 pinfo
->buffer_length
= datasize
;
2006 pinfo
->section
= section
;
2008 /* Skip over the relocs belonging to addresses below the
2010 while (rel_pp
< rel_ppend
2011 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2014 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2016 /* Find the nearest symbol forwards from our current position. */
2017 paux
->require_sec
= TRUE
;
2018 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2019 (struct disassemble_info
*) inf
,
2021 paux
->require_sec
= FALSE
;
2023 /* PR 9774: If the target used signed addresses then we must make
2024 sure that we sign extend the value that we calculate for 'addr'
2025 in the loop below. */
2026 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2027 && (bed
= get_elf_backend_data (abfd
)) != NULL
2028 && bed
->sign_extend_vma
)
2029 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2031 /* Disassemble a block of instructions up to the address associated with
2032 the symbol we have just found. Then print the symbol and find the
2033 next symbol on. Repeat until we have disassembled the entire section
2034 or we have reached the end of the address range we are interested in. */
2035 while (addr_offset
< stop_offset
)
2039 unsigned long nextstop_offset
;
2042 addr
= section
->vma
+ addr_offset
;
2043 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2045 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2050 (x
< sorted_symcount
2051 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2055 pinfo
->symbols
= sorted_syms
+ place
;
2056 pinfo
->num_symbols
= x
- place
;
2057 pinfo
->symtab_pos
= place
;
2061 pinfo
->symbols
= NULL
;
2062 pinfo
->num_symbols
= 0;
2063 pinfo
->symtab_pos
= -1;
2066 if (! prefix_addresses
)
2068 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2069 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2071 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2074 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2076 else if (sym
== NULL
)
2080 #define is_valid_next_sym(SYM) \
2081 ((SYM)->section == section \
2082 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2083 && pinfo->symbol_is_valid (SYM, pinfo))
2085 /* Search forward for the next appropriate symbol in
2086 SECTION. Note that all the symbols are sorted
2087 together into one big array, and that some sections
2088 may have overlapping addresses. */
2089 while (place
< sorted_symcount
2090 && ! is_valid_next_sym (sorted_syms
[place
]))
2093 if (place
>= sorted_symcount
)
2096 nextsym
= sorted_syms
[place
];
2099 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2100 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2101 else if (nextsym
== NULL
)
2102 nextstop_offset
= stop_offset
;
2104 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2106 if (nextstop_offset
> stop_offset
2107 || nextstop_offset
<= addr_offset
)
2108 nextstop_offset
= stop_offset
;
2110 /* If a symbol is explicitly marked as being an object
2111 rather than a function, just dump the bytes without
2112 disassembling them. */
2115 || sym
->section
!= section
2116 || bfd_asymbol_value (sym
) > addr
2117 || ((sym
->flags
& BSF_OBJECT
) == 0
2118 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2120 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2122 || (sym
->flags
& BSF_FUNCTION
) != 0)
2127 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2128 addr_offset
, nextstop_offset
,
2129 rel_offset
, &rel_pp
, rel_ppend
);
2131 addr_offset
= nextstop_offset
;
2137 if (rel_ppstart
!= NULL
)
2141 /* Disassemble the contents of an object file. */
2144 disassemble_data (bfd
*abfd
)
2146 struct disassemble_info disasm_info
;
2147 struct objdump_disasm_info aux
;
2151 prev_functionname
= NULL
;
2153 prev_discriminator
= 0;
2155 /* We make a copy of syms to sort. We don't want to sort syms
2156 because that will screw up the relocs. */
2157 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2158 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2159 * sizeof (asymbol
*));
2160 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2161 sorted_symcount
* sizeof (asymbol
*));
2163 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2165 for (i
= 0; i
< synthcount
; ++i
)
2167 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2171 /* Sort the symbols into section and symbol order. */
2172 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2174 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2176 disasm_info
.application_data
= (void *) &aux
;
2178 aux
.require_sec
= FALSE
;
2179 aux
.dynrelbuf
= NULL
;
2180 aux
.dynrelcount
= 0;
2183 disasm_info
.print_address_func
= objdump_print_address
;
2184 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2186 if (machine
!= NULL
)
2188 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2191 fatal (_("can't use supplied machine %s"), machine
);
2193 abfd
->arch_info
= inf
;
2196 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2198 struct bfd_target
*xvec
;
2200 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2201 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2202 xvec
->byteorder
= endian
;
2206 /* Use libopcodes to locate a suitable disassembler. */
2207 aux
.disassemble_fn
= disassembler (abfd
);
2208 if (!aux
.disassemble_fn
)
2210 non_fatal (_("can't disassemble for architecture %s\n"),
2211 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2216 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2217 disasm_info
.arch
= bfd_get_arch (abfd
);
2218 disasm_info
.mach
= bfd_get_mach (abfd
);
2219 disasm_info
.disassembler_options
= disassembler_options
;
2220 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2221 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2222 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2223 disasm_info
.disassembler_needs_relocs
= FALSE
;
2225 if (bfd_big_endian (abfd
))
2226 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2227 else if (bfd_little_endian (abfd
))
2228 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2230 /* ??? Aborting here seems too drastic. We could default to big or little
2232 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2234 /* Allow the target to customize the info structure. */
2235 disassemble_init_for_target (& disasm_info
);
2237 /* Pre-load the dynamic relocs if we are going
2238 to be dumping them along with the disassembly. */
2239 if (dump_dynamic_reloc_info
)
2241 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2244 bfd_fatal (bfd_get_filename (abfd
));
2248 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2249 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2252 if (aux
.dynrelcount
< 0)
2253 bfd_fatal (bfd_get_filename (abfd
));
2255 /* Sort the relocs by address. */
2256 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2260 disasm_info
.symtab
= sorted_syms
;
2261 disasm_info
.symtab_size
= sorted_symcount
;
2263 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2265 if (aux
.dynrelbuf
!= NULL
)
2266 free (aux
.dynrelbuf
);
2271 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2272 asection
*sec
, void *file
)
2274 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2275 bfd
*abfd
= (bfd
*) file
;
2278 /* If it is already loaded, do nothing. */
2279 if (section
->start
!= NULL
)
2282 section
->address
= bfd_get_section_vma (abfd
, sec
);
2283 section
->size
= bfd_get_section_size (sec
);
2284 section
->start
= NULL
;
2285 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2289 free_debug_section (debug
);
2290 printf (_("\nCan't get contents for section '%s'.\n"),
2295 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2297 bfd_cache_section_contents (sec
, section
->start
);
2299 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2306 free_debug_section (debug
);
2307 printf (_("\nCan't get contents for section '%s'.\n"),
2317 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2319 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2320 bfd
*abfd
= (bfd
*) file
;
2323 /* If it is already loaded, do nothing. */
2324 if (section
->start
!= NULL
)
2327 /* Locate the debug section. */
2328 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2330 section
->name
= section
->uncompressed_name
;
2333 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2335 section
->name
= section
->compressed_name
;
2340 return load_specific_debug_section (debug
, sec
, file
);
2344 free_debug_section (enum dwarf_section_display_enum debug
)
2346 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2348 if (section
->start
== NULL
)
2351 free ((char *) section
->start
);
2352 section
->start
= NULL
;
2353 section
->address
= 0;
2358 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2359 void *arg ATTRIBUTE_UNUSED
)
2361 const char *name
= bfd_get_section_name (abfd
, section
);
2365 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2366 match
= ".debug_info";
2370 for (i
= 0; i
< max
; i
++)
2371 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2372 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2373 && debug_displays
[i
].enabled
!= NULL
2374 && *debug_displays
[i
].enabled
)
2376 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2378 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2379 sec
->name
= sec
->uncompressed_name
;
2381 sec
->name
= sec
->compressed_name
;
2382 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2385 debug_displays
[i
].display (sec
, abfd
);
2387 if (i
!= info
&& i
!= abbrev
)
2388 free_debug_section ((enum dwarf_section_display_enum
) i
);
2394 /* Dump the dwarf debugging information. */
2397 dump_dwarf (bfd
*abfd
)
2399 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2401 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2403 if (bfd_big_endian (abfd
))
2404 byte_get
= byte_get_big_endian
;
2405 else if (bfd_little_endian (abfd
))
2406 byte_get
= byte_get_little_endian
;
2408 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2410 warn (_("File %s does not contain any dwarf debug information\n"),
2411 bfd_get_filename (abfd
));
2415 switch (bfd_get_arch (abfd
))
2418 switch (bfd_get_mach (abfd
))
2420 case bfd_mach_x86_64
:
2421 case bfd_mach_x86_64_intel_syntax
:
2422 case bfd_mach_x86_64_nacl
:
2423 case bfd_mach_x64_32
:
2424 case bfd_mach_x64_32_intel_syntax
:
2425 case bfd_mach_x64_32_nacl
:
2426 init_dwarf_regnames_x86_64 ();
2430 init_dwarf_regnames_i386 ();
2435 case bfd_arch_aarch64
:
2436 init_dwarf_regnames_aarch64();
2443 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2445 free_debug_memory ();
2448 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2449 it. Return NULL on failure. */
2452 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2458 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2459 if (stabsect
== NULL
)
2461 printf (_("No %s section present\n\n"), sect_name
);
2465 size
= bfd_section_size (abfd
, stabsect
);
2466 contents
= (char *) xmalloc (size
);
2468 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2470 non_fatal (_("reading %s section of %s failed: %s"),
2471 sect_name
, bfd_get_filename (abfd
),
2472 bfd_errmsg (bfd_get_error ()));
2483 /* Stabs entries use a 12 byte format:
2484 4 byte string table index
2486 1 byte stab other field
2487 2 byte stab desc field
2489 FIXME: This will have to change for a 64 bit object format. */
2491 #define STRDXOFF (0)
2493 #define OTHEROFF (5)
2496 #define STABSIZE (12)
2498 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2499 using string table section STRSECT_NAME (in `strtab'). */
2502 print_section_stabs (bfd
*abfd
,
2503 const char *stabsect_name
,
2504 unsigned *string_offset_ptr
)
2507 unsigned file_string_table_offset
= 0;
2508 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2509 bfd_byte
*stabp
, *stabs_end
;
2512 stabs_end
= stabp
+ stab_size
;
2514 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2515 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2517 /* Loop through all symbols and print them.
2519 We start the index at -1 because there is a dummy symbol on
2520 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2521 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2525 unsigned char type
, other
;
2526 unsigned short desc
;
2529 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2530 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2531 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2532 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2533 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2535 printf ("\n%-6d ", i
);
2536 /* Either print the stab name, or, if unnamed, print its number
2537 again (makes consistent formatting for tools like awk). */
2538 name
= bfd_get_stab_name (type
);
2540 printf ("%-6s", name
);
2541 else if (type
== N_UNDF
)
2544 printf ("%-6d", type
);
2545 printf (" %-6d %-6d ", other
, desc
);
2546 bfd_printf_vma (abfd
, value
);
2547 printf (" %-6lu", strx
);
2549 /* Symbols with type == 0 (N_UNDF) specify the length of the
2550 string table associated with this file. We use that info
2551 to know how to relocate the *next* file's string table indices. */
2554 file_string_table_offset
= next_file_string_table_offset
;
2555 next_file_string_table_offset
+= value
;
2559 bfd_size_type amt
= strx
+ file_string_table_offset
;
2561 /* Using the (possibly updated) string table offset, print the
2562 string (if any) associated with this symbol. */
2563 if (amt
< stabstr_size
)
2564 /* PR 17512: file: 079-79389-0.001:0.1. */
2565 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2571 *string_offset_ptr
= next_file_string_table_offset
;
2576 const char * section_name
;
2577 const char * string_section_name
;
2578 unsigned string_offset
;
2583 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2586 stab_section_names
* sought
= (stab_section_names
*) names
;
2588 /* Check for section names for which stabsect_name is a prefix, to
2589 handle .stab.N, etc. */
2590 len
= strlen (sought
->section_name
);
2592 /* If the prefix matches, and the files section name ends with a
2593 nul or a digit, then we match. I.e., we want either an exact
2594 match or a section followed by a number. */
2595 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2596 && (section
->name
[len
] == 0
2597 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2600 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2605 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2608 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2614 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2616 stab_section_names s
;
2618 s
.section_name
= stabsect_name
;
2619 s
.string_section_name
= strsect_name
;
2620 s
.string_offset
= 0;
2622 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2628 /* Dump the any sections containing stabs debugging information. */
2631 dump_stabs (bfd
*abfd
)
2633 dump_stabs_section (abfd
, ".stab", ".stabstr");
2634 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2635 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2638 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2640 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2644 dump_bfd_header (bfd
*abfd
)
2648 printf (_("architecture: %s, "),
2649 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2650 bfd_get_mach (abfd
)));
2651 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2653 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2654 PF (HAS_RELOC
, "HAS_RELOC");
2655 PF (EXEC_P
, "EXEC_P");
2656 PF (HAS_LINENO
, "HAS_LINENO");
2657 PF (HAS_DEBUG
, "HAS_DEBUG");
2658 PF (HAS_SYMS
, "HAS_SYMS");
2659 PF (HAS_LOCALS
, "HAS_LOCALS");
2660 PF (DYNAMIC
, "DYNAMIC");
2661 PF (WP_TEXT
, "WP_TEXT");
2662 PF (D_PAGED
, "D_PAGED");
2663 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2664 printf (_("\nstart address 0x"));
2665 bfd_printf_vma (abfd
, abfd
->start_address
);
2671 dump_bfd_private_header (bfd
*abfd
)
2673 bfd_print_private_bfd_data (abfd
, stdout
);
2677 dump_target_specific (bfd
*abfd
)
2679 const struct objdump_private_desc
* const *desc
;
2680 struct objdump_private_option
*opt
;
2683 /* Find the desc. */
2684 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2685 if ((*desc
)->filter (abfd
))
2690 non_fatal (_("option -P/--private not supported by this file"));
2694 /* Clear all options. */
2695 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2696 opt
->selected
= FALSE
;
2698 /* Decode options. */
2699 b
= dump_private_options
;
2702 e
= strchr (b
, ',');
2707 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2708 if (strcmp (opt
->name
, b
) == 0)
2710 opt
->selected
= TRUE
;
2713 if (opt
->name
== NULL
)
2714 non_fatal (_("target specific dump '%s' not supported"), b
);
2725 (*desc
)->dump (abfd
);
2728 /* Display a section in hexadecimal format with associated characters.
2729 Each line prefixed by the zero padded address. */
2732 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2735 bfd_size_type datasize
;
2736 bfd_size_type addr_offset
;
2737 bfd_size_type start_offset
;
2738 bfd_size_type stop_offset
;
2739 unsigned int opb
= bfd_octets_per_byte (abfd
);
2740 /* Bytes per line. */
2741 const int onaline
= 16;
2746 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2749 if (! process_section_p (section
))
2752 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2755 /* Compute the address range to display. */
2756 if (start_address
== (bfd_vma
) -1
2757 || start_address
< section
->vma
)
2760 start_offset
= start_address
- section
->vma
;
2762 if (stop_address
== (bfd_vma
) -1)
2763 stop_offset
= datasize
/ opb
;
2766 if (stop_address
< section
->vma
)
2769 stop_offset
= stop_address
- section
->vma
;
2771 if (stop_offset
> datasize
/ opb
)
2772 stop_offset
= datasize
/ opb
;
2775 if (start_offset
>= stop_offset
)
2778 printf (_("Contents of section %s:"), section
->name
);
2779 if (display_file_offsets
)
2780 printf (_(" (Starting at file offset: 0x%lx)"),
2781 (unsigned long) (section
->filepos
+ start_offset
));
2784 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2786 non_fatal (_("Reading section failed"));
2792 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2793 if (strlen (buf
) >= sizeof (buf
))
2797 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2799 count
= strlen (buf
) - count
;
2803 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2804 if (strlen (buf
) >= sizeof (buf
))
2808 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2810 count
= strlen (buf
) - count
;
2814 for (addr_offset
= start_offset
;
2815 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2819 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2820 count
= strlen (buf
);
2821 if ((size_t) count
>= sizeof (buf
))
2825 while (count
< width
)
2830 fputs (buf
+ count
- width
, stdout
);
2833 for (j
= addr_offset
* opb
;
2834 j
< addr_offset
* opb
+ onaline
; j
++)
2836 if (j
< stop_offset
* opb
)
2837 printf ("%02x", (unsigned) (data
[j
]));
2845 for (j
= addr_offset
* opb
;
2846 j
< addr_offset
* opb
+ onaline
; j
++)
2848 if (j
>= stop_offset
* opb
)
2851 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2858 /* Actually display the various requested regions. */
2861 dump_data (bfd
*abfd
)
2863 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2866 /* Should perhaps share code and display with nm? */
2869 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2878 max_count
= dynsymcount
;
2879 printf ("DYNAMIC SYMBOL TABLE:\n");
2884 max_count
= symcount
;
2885 printf ("SYMBOL TABLE:\n");
2889 printf (_("no symbols\n"));
2891 for (count
= 0; count
< max_count
; count
++)
2895 if (*current
== NULL
)
2896 printf (_("no information for symbol number %ld\n"), count
);
2898 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2899 printf (_("could not determine the type of symbol number %ld\n"),
2902 else if (process_section_p ((* current
)->section
)
2903 && (dump_special_syms
2904 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2906 const char *name
= (*current
)->name
;
2908 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2912 /* If we want to demangle the name, we demangle it
2913 here, and temporarily clobber it while calling
2914 bfd_print_symbol. FIXME: This is a gross hack. */
2915 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2917 (*current
)->name
= alloc
;
2918 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2919 bfd_print_symbol_all
);
2922 (*current
)->name
= name
;
2927 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2928 bfd_print_symbol_all
);
2938 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2941 char *last_filename
, *last_functionname
;
2942 unsigned int last_line
;
2943 unsigned int last_discriminator
;
2945 /* Get column headers lined up reasonably. */
2953 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2954 width
= strlen (buf
) - 7;
2956 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2959 last_filename
= NULL
;
2960 last_functionname
= NULL
;
2962 last_discriminator
= 0;
2964 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2967 const char *filename
, *functionname
;
2968 unsigned int linenumber
;
2969 unsigned int discriminator
;
2970 const char *sym_name
;
2971 const char *section_name
;
2972 bfd_vma addend2
= 0;
2974 if (start_address
!= (bfd_vma
) -1
2975 && q
->address
< start_address
)
2977 if (stop_address
!= (bfd_vma
) -1
2978 && q
->address
> stop_address
)
2981 if (with_line_numbers
2983 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
2984 &filename
, &functionname
,
2985 &linenumber
, &discriminator
))
2987 if (functionname
!= NULL
2988 && (last_functionname
== NULL
2989 || strcmp (functionname
, last_functionname
) != 0))
2991 printf ("%s():\n", functionname
);
2992 if (last_functionname
!= NULL
)
2993 free (last_functionname
);
2994 last_functionname
= xstrdup (functionname
);
2998 && (linenumber
!= last_line
2999 || (filename
!= NULL
3000 && last_filename
!= NULL
3001 && filename_cmp (filename
, last_filename
) != 0)
3002 || (discriminator
!= last_discriminator
)))
3004 if (discriminator
> 0)
3005 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3007 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3008 linenumber
, discriminator
);
3009 last_line
= linenumber
;
3010 last_discriminator
= discriminator
;
3011 if (last_filename
!= NULL
)
3012 free (last_filename
);
3013 if (filename
== NULL
)
3014 last_filename
= NULL
;
3016 last_filename
= xstrdup (filename
);
3020 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3022 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3023 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3028 section_name
= NULL
;
3031 bfd_printf_vma (abfd
, q
->address
);
3032 if (q
->howto
== NULL
)
3033 printf (" *unknown* ");
3034 else if (q
->howto
->name
)
3036 const char *name
= q
->howto
->name
;
3038 /* R_SPARC_OLO10 relocations contain two addends.
3039 But because 'arelent' lacks enough storage to
3040 store them both, the 64-bit ELF Sparc backend
3041 records this as two relocations. One R_SPARC_LO10
3042 and one R_SPARC_13, both pointing to the same
3043 address. This is merely so that we have some
3044 place to store both addend fields.
3046 Undo this transformation, otherwise the output
3047 will be confusing. */
3048 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3049 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3051 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3053 arelent
*q2
= *(p
+ 1);
3056 && q
->address
== q2
->address
3057 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3059 name
= "R_SPARC_OLO10";
3060 addend2
= q2
->addend
;
3064 printf (" %-16s ", name
);
3067 printf (" %-16d ", q
->howto
->type
);
3071 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3075 if (section_name
== NULL
)
3076 section_name
= "*unknown*";
3077 printf ("[%s]", section_name
);
3082 bfd_signed_vma addend
= q
->addend
;
3090 bfd_printf_vma (abfd
, addend
);
3095 bfd_printf_vma (abfd
, addend2
);
3101 if (last_filename
!= NULL
)
3102 free (last_filename
);
3103 if (last_functionname
!= NULL
)
3104 free (last_functionname
);
3108 dump_relocs_in_section (bfd
*abfd
,
3110 void *dummy ATTRIBUTE_UNUSED
)
3116 if ( bfd_is_abs_section (section
)
3117 || bfd_is_und_section (section
)
3118 || bfd_is_com_section (section
)
3119 || (! process_section_p (section
))
3120 || ((section
->flags
& SEC_RELOC
) == 0))
3123 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3125 bfd_fatal (bfd_get_filename (abfd
));
3127 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3131 printf (" (none)\n\n");
3135 relpp
= (arelent
**) xmalloc (relsize
);
3136 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3141 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3142 bfd_fatal (_("error message was"));
3144 else if (relcount
== 0)
3145 printf (" (none)\n\n");
3149 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3156 dump_relocs (bfd
*abfd
)
3158 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3162 dump_dynamic_relocs (bfd
*abfd
)
3168 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3170 bfd_fatal (bfd_get_filename (abfd
));
3172 printf ("DYNAMIC RELOCATION RECORDS");
3175 printf (" (none)\n\n");
3178 relpp
= (arelent
**) xmalloc (relsize
);
3179 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3182 bfd_fatal (bfd_get_filename (abfd
));
3183 else if (relcount
== 0)
3184 printf (" (none)\n\n");
3188 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3195 /* Creates a table of paths, to search for source files. */
3198 add_include_path (const char *path
)
3202 include_path_count
++;
3203 include_paths
= (const char **)
3204 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3205 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3206 if (path
[1] == ':' && path
[2] == 0)
3207 path
= concat (path
, ".", (const char *) 0);
3209 include_paths
[include_path_count
- 1] = path
;
3213 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3217 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3219 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3220 section
->vma
+= adjust_section_vma
;
3222 section
->lma
+= adjust_section_vma
;
3226 /* Dump selected contents of ABFD. */
3229 dump_bfd (bfd
*abfd
)
3231 /* If we are adjusting section VMA's, change them all now. Changing
3232 the BFD information is a hack. However, we must do it, or
3233 bfd_find_nearest_line will not do the right thing. */
3234 if (adjust_section_vma
!= 0)
3236 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3237 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3240 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3241 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3244 print_arelt_descr (stdout
, abfd
, TRUE
);
3245 if (dump_file_header
)
3246 dump_bfd_header (abfd
);
3247 if (dump_private_headers
)
3248 dump_bfd_private_header (abfd
);
3249 if (dump_private_options
!= NULL
)
3250 dump_target_specific (abfd
);
3251 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3258 || dump_dwarf_section_info
)
3259 syms
= slurp_symtab (abfd
);
3261 if (dump_section_headers
)
3262 dump_headers (abfd
);
3264 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3265 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3266 dynsyms
= slurp_dynamic_symtab (abfd
);
3269 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3270 dynsymcount
, dynsyms
, &synthsyms
);
3276 dump_symbols (abfd
, FALSE
);
3277 if (dump_dynamic_symtab
)
3278 dump_symbols (abfd
, TRUE
);
3279 if (dump_dwarf_section_info
)
3281 if (dump_stab_section_info
)
3283 if (dump_reloc_info
&& ! disassemble
)
3285 if (dump_dynamic_reloc_info
&& ! disassemble
)
3286 dump_dynamic_relocs (abfd
);
3287 if (dump_section_contents
)
3290 disassemble_data (abfd
);
3296 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3297 if (dhandle
!= NULL
)
3299 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3301 dump_debugging_tags
? TRUE
: FALSE
))
3303 non_fatal (_("%s: printing debugging information failed"),
3304 bfd_get_filename (abfd
));
3308 /* PR 6483: If there was no STABS or IEEE debug
3309 info in the file, try DWARF instead. */
3310 else if (! dump_dwarf_section_info
)
3312 dwarf_select_sections_all ();
3341 display_object_bfd (bfd
*abfd
)
3345 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3351 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3353 nonfatal (bfd_get_filename (abfd
));
3354 list_matching_formats (matching
);
3359 if (bfd_get_error () != bfd_error_file_not_recognized
)
3361 nonfatal (bfd_get_filename (abfd
));
3365 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3371 nonfatal (bfd_get_filename (abfd
));
3373 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3375 list_matching_formats (matching
);
3381 display_any_bfd (bfd
*file
, int level
)
3383 /* Decompress sections unless dumping the section contents. */
3384 if (!dump_section_contents
)
3385 file
->flags
|= BFD_DECOMPRESS
;
3387 /* If the file is an archive, process all of its elements. */
3388 if (bfd_check_format (file
, bfd_archive
))
3391 bfd
*last_arfile
= NULL
;
3394 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3396 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3400 bfd_set_error (bfd_error_no_error
);
3402 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3405 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3406 nonfatal (bfd_get_filename (file
));
3410 display_any_bfd (arfile
, level
+ 1);
3412 if (last_arfile
!= NULL
)
3413 bfd_close (last_arfile
);
3414 last_arfile
= arfile
;
3417 if (last_arfile
!= NULL
)
3418 bfd_close (last_arfile
);
3421 display_object_bfd (file
);
3425 display_file (char *filename
, char *target
)
3429 if (get_file_size (filename
) < 1)
3435 file
= bfd_openr (filename
, target
);
3438 nonfatal (filename
);
3442 display_any_bfd (file
, 0);
3448 main (int argc
, char **argv
)
3451 char *target
= default_target
;
3452 bfd_boolean seenflag
= FALSE
;
3454 #if defined (HAVE_SETLOCALE)
3455 #if defined (HAVE_LC_MESSAGES)
3456 setlocale (LC_MESSAGES
, "");
3458 setlocale (LC_CTYPE
, "");
3461 bindtextdomain (PACKAGE
, LOCALEDIR
);
3462 textdomain (PACKAGE
);
3464 program_name
= *argv
;
3465 xmalloc_set_program_name (program_name
);
3467 START_PROGRESS (program_name
, 0);
3469 expandargv (&argc
, &argv
);
3472 set_default_bfd_target ();
3474 while ((c
= getopt_long (argc
, argv
,
3475 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3476 long_options
, (int *) 0))
3482 break; /* We've been given a long option. */
3487 if (disassembler_options
)
3488 /* Ignore potential memory leak for now. */
3489 disassembler_options
= concat (disassembler_options
, ",",
3490 optarg
, (const char *) NULL
);
3492 disassembler_options
= optarg
;
3498 display_file_offsets
= TRUE
;
3501 with_line_numbers
= TRUE
;
3510 enum demangling_styles style
;
3512 style
= cplus_demangle_name_to_style (optarg
);
3513 if (style
== unknown_demangling
)
3514 fatal (_("unknown demangling style `%s'"),
3517 cplus_demangle_set_style (style
);
3523 case OPTION_ADJUST_VMA
:
3524 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3526 case OPTION_START_ADDRESS
:
3527 start_address
= parse_vma (optarg
, "--start-address");
3528 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3529 fatal (_("error: the start address should be before the end address"));
3531 case OPTION_STOP_ADDRESS
:
3532 stop_address
= parse_vma (optarg
, "--stop-address");
3533 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3534 fatal (_("error: the stop address should be after the start address"));
3538 prefix_length
= strlen (prefix
);
3539 /* Remove an unnecessary trailing '/' */
3540 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3543 case OPTION_PREFIX_STRIP
:
3544 prefix_strip
= atoi (optarg
);
3545 if (prefix_strip
< 0)
3546 fatal (_("error: prefix strip must be non-negative"));
3548 case OPTION_INSN_WIDTH
:
3549 insn_width
= strtoul (optarg
, NULL
, 0);
3550 if (insn_width
<= 0)
3551 fatal (_("error: instruction width must be positive"));
3554 if (strcmp (optarg
, "B") == 0)
3555 endian
= BFD_ENDIAN_BIG
;
3556 else if (strcmp (optarg
, "L") == 0)
3557 endian
= BFD_ENDIAN_LITTLE
;
3560 nonfatal (_("unrecognized -E option"));
3565 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3566 endian
= BFD_ENDIAN_BIG
;
3567 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3568 endian
= BFD_ENDIAN_LITTLE
;
3571 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3578 dump_file_header
= TRUE
;
3582 formats_info
= TRUE
;
3586 add_include_path (optarg
);
3589 dump_private_headers
= TRUE
;
3593 dump_private_options
= optarg
;
3597 dump_private_headers
= TRUE
;
3599 dump_reloc_info
= TRUE
;
3600 dump_file_header
= TRUE
;
3601 dump_ar_hdrs
= TRUE
;
3602 dump_section_headers
= TRUE
;
3610 dump_dynamic_symtab
= TRUE
;
3618 disassemble_zeroes
= TRUE
;
3622 disassemble_all
= TRUE
;
3627 with_source_code
= TRUE
;
3636 dump_debugging_tags
= 1;
3641 dump_dwarf_section_info
= TRUE
;
3644 dwarf_select_sections_by_letters (optarg
);
3646 dwarf_select_sections_all ();
3649 dump_dwarf_section_info
= TRUE
;
3652 dwarf_select_sections_by_names (optarg
);
3654 dwarf_select_sections_all ();
3656 case OPTION_DWARF_DEPTH
:
3659 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3662 case OPTION_DWARF_START
:
3665 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3666 suppress_bfd_header
= 1;
3669 case OPTION_DWARF_CHECK
:
3673 dump_stab_section_info
= TRUE
;
3677 dump_section_contents
= TRUE
;
3681 dump_reloc_info
= TRUE
;
3685 dump_dynamic_reloc_info
= TRUE
;
3689 dump_ar_hdrs
= TRUE
;
3693 dump_section_headers
= TRUE
;
3698 show_version
= TRUE
;
3704 /* No need to set seenflag or to break - usage() does not return. */
3711 print_version ("objdump");
3717 exit_status
= display_info ();
3721 display_file ("a.out", target
);
3723 for (; optind
< argc
;)
3724 display_file (argv
[optind
++], target
);
3729 END_PROGRESS (program_name
);