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
,
801 name
= bfd_asymbol_name (sym
);
802 if (do_demangle
&& name
[0] != '\0')
804 /* Demangle the name. */
805 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
811 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
819 /* Locate a symbol given a bfd and a section (from INFO->application_data),
820 and a VMA. If INFO->application_data->require_sec is TRUE, then always
821 require the symbol to be in the section. Returns NULL if there is no
822 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
823 of the symbol in sorted_syms. */
826 find_symbol_for_address (bfd_vma vma
,
827 struct disassemble_info
*inf
,
830 /* @@ Would it speed things up to cache the last two symbols returned,
831 and maybe their address ranges? For many processors, only one memory
832 operand can be present at a time, so the 2-entry cache wouldn't be
833 constantly churned by code doing heavy memory accesses. */
835 /* Indices in `sorted_syms'. */
837 long max_count
= sorted_symcount
;
839 struct objdump_disasm_info
*aux
;
843 bfd_boolean want_section
;
845 if (sorted_symcount
< 1)
848 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
851 opb
= inf
->octets_per_byte
;
853 /* Perform a binary search looking for the closest symbol to the
854 required value. We are searching the range (min, max_count]. */
855 while (min
+ 1 < max_count
)
859 thisplace
= (max_count
+ min
) / 2;
860 sym
= sorted_syms
[thisplace
];
862 if (bfd_asymbol_value (sym
) > vma
)
863 max_count
= thisplace
;
864 else if (bfd_asymbol_value (sym
) < vma
)
873 /* The symbol we want is now in min, the low end of the range we
874 were searching. If there are several symbols with the same
875 value, we want the first one. */
878 && (bfd_asymbol_value (sorted_syms
[thisplace
])
879 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
882 /* Prefer a symbol in the current section if we have multple symbols
883 with the same value, as can occur with overlays or zero size
886 while (min
< max_count
887 && (bfd_asymbol_value (sorted_syms
[min
])
888 == bfd_asymbol_value (sorted_syms
[thisplace
])))
890 if (sorted_syms
[min
]->section
== sec
891 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
898 return sorted_syms
[thisplace
];
903 /* If the file is relocatable, and the symbol could be from this
904 section, prefer a symbol from this section over symbols from
905 others, even if the other symbol's value might be closer.
907 Note that this may be wrong for some symbol references if the
908 sections have overlapping memory ranges, but in that case there's
909 no way to tell what's desired without looking at the relocation
912 Also give the target a chance to reject symbols. */
913 want_section
= (aux
->require_sec
914 || ((abfd
->flags
& HAS_RELOC
) != 0
915 && vma
>= bfd_get_section_vma (abfd
, sec
)
916 && vma
< (bfd_get_section_vma (abfd
, sec
)
917 + bfd_section_size (abfd
, sec
) / opb
)));
918 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
919 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
922 long newplace
= sorted_symcount
;
924 for (i
= min
- 1; i
>= 0; i
--)
926 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
927 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
929 if (newplace
== sorted_symcount
)
932 if (bfd_asymbol_value (sorted_syms
[i
])
933 != bfd_asymbol_value (sorted_syms
[newplace
]))
936 /* Remember this symbol and keep searching until we reach
937 an earlier address. */
942 if (newplace
!= sorted_symcount
)
943 thisplace
= newplace
;
946 /* We didn't find a good symbol with a smaller value.
947 Look for one with a larger value. */
948 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
950 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
951 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
959 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
960 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
961 /* There is no suitable symbol. */
968 return sorted_syms
[thisplace
];
971 /* Print an address and the offset to the nearest symbol. */
974 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
975 bfd_vma vma
, struct disassemble_info
*inf
,
976 bfd_boolean skip_zeroes
)
978 objdump_print_value (vma
, inf
, skip_zeroes
);
984 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
985 bfd_get_section_name (abfd
, sec
));
986 secaddr
= bfd_get_section_vma (abfd
, sec
);
989 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
990 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
992 else if (vma
> secaddr
)
994 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
995 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
997 (*inf
->fprintf_func
) (inf
->stream
, ">");
1001 (*inf
->fprintf_func
) (inf
->stream
, " <");
1002 objdump_print_symname (abfd
, inf
, sym
);
1003 if (bfd_asymbol_value (sym
) > vma
)
1005 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1006 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1008 else if (vma
> bfd_asymbol_value (sym
))
1010 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1011 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1013 (*inf
->fprintf_func
) (inf
->stream
, ">");
1016 if (display_file_offsets
)
1017 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1018 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1021 /* Print an address (VMA), symbolically if possible.
1022 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1025 objdump_print_addr (bfd_vma vma
,
1026 struct disassemble_info
*inf
,
1027 bfd_boolean skip_zeroes
)
1029 struct objdump_disasm_info
*aux
;
1030 asymbol
*sym
= NULL
;
1031 bfd_boolean skip_find
= FALSE
;
1033 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1035 if (sorted_symcount
< 1)
1037 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1038 objdump_print_value (vma
, inf
, skip_zeroes
);
1040 if (display_file_offsets
)
1041 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1042 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1046 if (aux
->reloc
!= NULL
1047 && aux
->reloc
->sym_ptr_ptr
!= NULL
1048 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1050 sym
= * aux
->reloc
->sym_ptr_ptr
;
1052 /* Adjust the vma to the reloc. */
1053 vma
+= bfd_asymbol_value (sym
);
1055 if (bfd_is_und_section (bfd_get_section (sym
)))
1060 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1062 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1066 /* Print VMA to INFO. This function is passed to the disassembler
1070 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1072 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1075 /* Determine if the given address has a symbol associated with it. */
1078 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1082 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1084 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1087 /* Hold the last function name and the last line number we displayed
1088 in a disassembly. */
1090 static char *prev_functionname
;
1091 static unsigned int prev_line
;
1092 static unsigned int prev_discriminator
;
1094 /* We keep a list of all files that we have seen when doing a
1095 disassembly with source, so that we know how much of the file to
1096 display. This can be important for inlined functions. */
1098 struct print_file_list
1100 struct print_file_list
*next
;
1101 const char *filename
;
1102 const char *modname
;
1105 const char **linemap
;
1111 static struct print_file_list
*print_files
;
1113 /* The number of preceding context lines to show when we start
1114 displaying a file for the first time. */
1116 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1118 /* Read a complete file into memory. */
1121 slurp_file (const char *fn
, size_t *size
)
1124 int ps
= getpagesize ();
1129 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1133 if (fstat (fd
, &st
) < 0)
1140 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1141 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1142 if (map
!= (char *) -1L)
1148 map
= (const char *) malloc (*size
);
1149 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1151 free ((void *) map
);
1158 #define line_map_decrease 5
1160 /* Precompute array of lines for a mapped file. */
1162 static const char **
1163 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1165 const char *p
, *lstart
, *end
;
1166 int chars_per_line
= 45; /* First iteration will use 40. */
1167 unsigned int lineno
;
1168 const char **linemap
= NULL
;
1169 unsigned long line_map_size
= 0;
1175 for (p
= map
; p
< end
; p
++)
1179 if (p
+ 1 < end
&& p
[1] == '\r')
1182 else if (*p
== '\r')
1184 if (p
+ 1 < end
&& p
[1] == '\n')
1190 /* End of line found. */
1192 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1194 unsigned long newsize
;
1196 chars_per_line
-= line_map_decrease
;
1197 if (chars_per_line
<= 1)
1199 line_map_size
= size
/ chars_per_line
+ 1;
1200 if (line_map_size
< lineno
+ 1)
1201 line_map_size
= lineno
+ 1;
1202 newsize
= line_map_size
* sizeof (char *);
1203 linemap
= (const char **) xrealloc (linemap
, newsize
);
1206 linemap
[lineno
++] = lstart
;
1214 /* Tries to open MODNAME, and if successful adds a node to print_files
1215 linked list and returns that node. Returns NULL on failure. */
1217 static struct print_file_list
*
1218 try_print_file_open (const char *origname
, const char *modname
)
1220 struct print_file_list
*p
;
1222 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1224 p
->map
= slurp_file (modname
, &p
->mapsize
);
1231 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1233 p
->filename
= origname
;
1234 p
->modname
= modname
;
1235 p
->next
= print_files
;
1241 /* If the source file, as described in the symtab, is not found
1242 try to locate it in one of the paths specified with -I
1243 If found, add location to print_files linked list. */
1245 static struct print_file_list
*
1246 update_source_path (const char *filename
)
1248 struct print_file_list
*p
;
1252 p
= try_print_file_open (filename
, filename
);
1256 if (include_path_count
== 0)
1259 /* Get the name of the file. */
1260 fname
= lbasename (filename
);
1262 /* If file exists under a new path, we need to add it to the list
1263 so that show_line knows about it. */
1264 for (i
= 0; i
< include_path_count
; i
++)
1266 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1268 p
= try_print_file_open (filename
, modname
);
1278 /* Print a source file line. */
1281 print_line (struct print_file_list
*p
, unsigned int linenum
)
1287 if (linenum
>= p
->maxline
)
1289 l
= p
->linemap
[linenum
];
1290 /* Test fwrite return value to quiet glibc warning. */
1291 len
= strcspn (l
, "\n\r");
1292 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1296 /* Print a range of source code lines. */
1299 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1303 while (start
<= end
)
1305 print_line (p
, start
);
1310 /* Show the line number, or the source line, in a disassembly
1314 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1316 const char *filename
;
1317 const char *functionname
;
1318 unsigned int linenumber
;
1319 unsigned int discriminator
;
1322 if (! with_line_numbers
&& ! with_source_code
)
1325 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1326 &filename
, &functionname
,
1327 &linenumber
, &discriminator
))
1330 if (filename
!= NULL
&& *filename
== '\0')
1332 if (functionname
!= NULL
&& *functionname
== '\0')
1333 functionname
= NULL
;
1336 && IS_ABSOLUTE_PATH (filename
)
1340 const char *fname
= filename
;
1341 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1344 memcpy (path
, prefix
, prefix_length
);
1345 path_up
= path
+ prefix_length
;
1347 /* Build relocated filename, stripping off leading directories
1348 from the initial filename if requested. */
1349 if (prefix_strip
> 0)
1354 /* Skip selected directory levels. */
1355 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1356 if (IS_DIR_SEPARATOR(*s
))
1363 /* Update complete filename. */
1364 strncpy (path_up
, fname
, PATH_MAX
);
1365 path_up
[PATH_MAX
] = '\0';
1373 if (with_line_numbers
)
1375 if (functionname
!= NULL
1376 && (prev_functionname
== NULL
1377 || strcmp (functionname
, prev_functionname
) != 0))
1378 printf ("%s():\n", functionname
);
1379 if (linenumber
> 0 && (linenumber
!= prev_line
||
1380 (discriminator
!= prev_discriminator
)))
1382 if (discriminator
> 0)
1383 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1384 linenumber
, discriminator
);
1386 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1390 if (with_source_code
1394 struct print_file_list
**pp
, *p
;
1397 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1398 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1405 filename
= xstrdup (filename
);
1406 p
= update_source_path (filename
);
1409 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1411 if (file_start_context
&& p
->first
)
1415 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1416 if (l
>= linenumber
)
1418 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1419 l
= p
->last_line
+ 1;
1421 dump_lines (p
, l
, linenumber
);
1422 p
->last_line
= linenumber
;
1427 if (functionname
!= NULL
1428 && (prev_functionname
== NULL
1429 || strcmp (functionname
, prev_functionname
) != 0))
1431 if (prev_functionname
!= NULL
)
1432 free (prev_functionname
);
1433 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1434 strcpy (prev_functionname
, functionname
);
1437 if (linenumber
> 0 && linenumber
!= prev_line
)
1438 prev_line
= linenumber
;
1440 if (discriminator
!= prev_discriminator
)
1441 prev_discriminator
= discriminator
;
1444 /* Pseudo FILE object for strings. */
1452 /* sprintf to a "stream". */
1454 static int ATTRIBUTE_PRINTF_2
1455 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1462 size_t space
= f
->alloc
- f
->pos
;
1464 va_start (args
, format
);
1465 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1471 f
->alloc
= (f
->alloc
+ n
) * 2;
1472 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1479 /* The number of zeroes we want to see before we start skipping them.
1480 The number is arbitrarily chosen. */
1482 #define DEFAULT_SKIP_ZEROES 8
1484 /* The number of zeroes to skip at the end of a section. If the
1485 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1486 SKIP_ZEROES, they will be disassembled. If there are fewer than
1487 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1488 attempt to avoid disassembling zeroes inserted by section
1491 #define DEFAULT_SKIP_ZEROES_AT_END 3
1493 /* Disassemble some data in memory between given values. */
1496 disassemble_bytes (struct disassemble_info
* inf
,
1497 disassembler_ftype disassemble_fn
,
1500 bfd_vma start_offset
,
1501 bfd_vma stop_offset
,
1504 arelent
** relppend
)
1506 struct objdump_disasm_info
*aux
;
1508 int octets_per_line
;
1509 int skip_addr_chars
;
1510 bfd_vma addr_offset
;
1511 unsigned int opb
= inf
->octets_per_byte
;
1512 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1513 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1517 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1521 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1525 octets_per_line
= insn_width
;
1527 octets_per_line
= 4;
1529 octets_per_line
= 16;
1531 /* Figure out how many characters to skip at the start of an
1532 address, to make the disassembly look nicer. We discard leading
1533 zeroes in chunks of 4, ensuring that there is always a leading
1535 skip_addr_chars
= 0;
1536 if (! prefix_addresses
)
1540 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1542 while (buf
[skip_addr_chars
] == '0')
1545 /* Don't discard zeros on overflow. */
1546 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1547 skip_addr_chars
= 0;
1549 if (skip_addr_chars
!= 0)
1550 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1553 inf
->insn_info_valid
= 0;
1555 addr_offset
= start_offset
;
1556 while (addr_offset
< stop_offset
)
1559 bfd_boolean need_nl
= FALSE
;
1560 int previous_octets
;
1562 /* Remember the length of the previous instruction. */
1563 previous_octets
= octets
;
1566 /* Make sure we don't use relocs from previous instructions. */
1569 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1571 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1574 if (! disassemble_zeroes
1575 && (inf
->insn_info_valid
== 0
1576 || inf
->branch_delay_insns
== 0)
1577 && (z
- addr_offset
* opb
>= skip_zeroes
1578 || (z
== stop_offset
* opb
&&
1579 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1581 /* If there are more nonzero octets to follow, we only skip
1582 zeroes in multiples of 4, to try to avoid running over
1583 the start of an instruction which happens to start with
1585 if (z
!= stop_offset
* opb
)
1586 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1588 octets
= z
- addr_offset
* opb
;
1590 /* If we are going to display more data, and we are displaying
1591 file offsets, then tell the user how many zeroes we skip
1592 and the file offset from where we resume dumping. */
1593 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1594 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1596 (unsigned long) (section
->filepos
1597 + (addr_offset
+ (octets
/ opb
))));
1607 if (with_line_numbers
|| with_source_code
)
1608 show_line (aux
->abfd
, section
, addr_offset
);
1610 if (! prefix_addresses
)
1614 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1615 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1619 printf ("%s:\t", buf
+ skip_addr_chars
);
1623 aux
->require_sec
= TRUE
;
1624 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1625 aux
->require_sec
= FALSE
;
1632 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1633 inf
->stream
= &sfile
;
1634 inf
->bytes_per_line
= 0;
1635 inf
->bytes_per_chunk
= 0;
1636 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1638 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1640 if (inf
->disassembler_needs_relocs
1641 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1642 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1643 && *relppp
< relppend
)
1645 bfd_signed_vma distance_to_rel
;
1647 distance_to_rel
= (**relppp
)->address
1648 - (rel_offset
+ addr_offset
);
1650 /* Check to see if the current reloc is associated with
1651 the instruction that we are about to disassemble. */
1652 if (distance_to_rel
== 0
1653 /* FIXME: This is wrong. We are trying to catch
1654 relocs that are addressed part way through the
1655 current instruction, as might happen with a packed
1656 VLIW instruction. Unfortunately we do not know the
1657 length of the current instruction since we have not
1658 disassembled it yet. Instead we take a guess based
1659 upon the length of the previous instruction. The
1660 proper solution is to have a new target-specific
1661 disassembler function which just returns the length
1662 of an instruction at a given address without trying
1663 to display its disassembly. */
1664 || (distance_to_rel
> 0
1665 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1667 inf
->flags
|= INSN_HAS_RELOC
;
1668 aux
->reloc
= **relppp
;
1672 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1673 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1674 inf
->stream
= stdout
;
1675 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1676 octets_per_line
= inf
->bytes_per_line
;
1677 if (octets
< (int) opb
)
1680 printf ("%s\n", sfile
.buffer
);
1683 non_fatal (_("disassemble_fn returned length %d"),
1694 octets
= octets_per_line
;
1695 if (addr_offset
+ octets
/ opb
> stop_offset
)
1696 octets
= (stop_offset
- addr_offset
) * opb
;
1698 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1700 if (ISPRINT (data
[j
]))
1701 buf
[j
- addr_offset
* opb
] = data
[j
];
1703 buf
[j
- addr_offset
* opb
] = '.';
1705 buf
[j
- addr_offset
* opb
] = '\0';
1708 if (prefix_addresses
1710 : show_raw_insn
>= 0)
1714 /* If ! prefix_addresses and ! wide_output, we print
1715 octets_per_line octets per line. */
1717 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1718 pb
= octets_per_line
;
1720 if (inf
->bytes_per_chunk
)
1721 bpc
= inf
->bytes_per_chunk
;
1725 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1729 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1731 for (k
= bpc
- 1; k
>= 0; k
--)
1732 printf ("%02x", (unsigned) data
[j
+ k
]);
1737 for (k
= 0; k
< bpc
; k
++)
1738 printf ("%02x", (unsigned) data
[j
+ k
]);
1743 for (; pb
< octets_per_line
; pb
+= bpc
)
1747 for (k
= 0; k
< bpc
; k
++)
1752 /* Separate raw data from instruction by extra space. */
1762 printf ("%s", sfile
.buffer
);
1764 if (prefix_addresses
1766 : show_raw_insn
>= 0)
1774 j
= addr_offset
* opb
+ pb
;
1776 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1777 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1781 printf ("%s:\t", buf
+ skip_addr_chars
);
1783 pb
+= octets_per_line
;
1786 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1790 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1792 for (k
= bpc
- 1; k
>= 0; k
--)
1793 printf ("%02x", (unsigned) data
[j
+ k
]);
1798 for (k
= 0; k
< bpc
; k
++)
1799 printf ("%02x", (unsigned) data
[j
+ k
]);
1812 while ((*relppp
) < relppend
1813 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1815 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1826 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1829 if (q
->howto
== NULL
)
1830 printf (": *unknown*\t");
1831 else if (q
->howto
->name
)
1832 printf (": %s\t", q
->howto
->name
);
1834 printf (": %d\t", q
->howto
->type
);
1836 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1837 printf ("*unknown*");
1840 const char *sym_name
;
1842 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1843 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1844 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1849 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1850 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1851 if (sym_name
== NULL
|| *sym_name
== '\0')
1852 sym_name
= "*unknown*";
1853 printf ("%s", sym_name
);
1859 bfd_signed_vma addend
= q
->addend
;
1867 objdump_print_value (addend
, inf
, TRUE
);
1879 addr_offset
+= octets
/ opb
;
1882 free (sfile
.buffer
);
1886 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1888 const struct elf_backend_data
* bed
;
1889 bfd_vma sign_adjust
= 0;
1890 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1891 struct objdump_disasm_info
* paux
;
1892 unsigned int opb
= pinfo
->octets_per_byte
;
1893 bfd_byte
* data
= NULL
;
1894 bfd_size_type datasize
= 0;
1895 arelent
** rel_pp
= NULL
;
1896 arelent
** rel_ppstart
= NULL
;
1897 arelent
** rel_ppend
;
1898 unsigned long stop_offset
;
1899 asymbol
* sym
= NULL
;
1903 unsigned long addr_offset
;
1905 /* Sections that do not contain machine
1906 code are not normally disassembled. */
1907 if (! disassemble_all
1908 && only_list
== NULL
1909 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1910 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1913 if (! process_section_p (section
))
1916 datasize
= bfd_get_section_size (section
);
1920 if (start_address
== (bfd_vma
) -1
1921 || start_address
< section
->vma
)
1924 addr_offset
= start_address
- section
->vma
;
1926 if (stop_address
== (bfd_vma
) -1)
1927 stop_offset
= datasize
/ opb
;
1930 if (stop_address
< section
->vma
)
1933 stop_offset
= stop_address
- section
->vma
;
1934 if (stop_offset
> datasize
/ opb
)
1935 stop_offset
= datasize
/ opb
;
1938 if (addr_offset
>= stop_offset
)
1941 /* Decide which set of relocs to use. Load them if necessary. */
1942 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1943 if (paux
->dynrelbuf
)
1945 rel_pp
= paux
->dynrelbuf
;
1946 rel_count
= paux
->dynrelcount
;
1947 /* Dynamic reloc addresses are absolute, non-dynamic are section
1948 relative. REL_OFFSET specifies the reloc address corresponding
1949 to the start of this section. */
1950 rel_offset
= section
->vma
;
1958 if ((section
->flags
& SEC_RELOC
) != 0
1959 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1963 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1965 bfd_fatal (bfd_get_filename (abfd
));
1969 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1970 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1972 bfd_fatal (bfd_get_filename (abfd
));
1974 /* Sort the relocs by address. */
1975 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1979 rel_ppend
= rel_pp
+ rel_count
;
1981 data
= (bfd_byte
*) xmalloc (datasize
);
1983 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1985 paux
->sec
= section
;
1986 pinfo
->buffer
= data
;
1987 pinfo
->buffer_vma
= section
->vma
;
1988 pinfo
->buffer_length
= datasize
;
1989 pinfo
->section
= section
;
1991 /* Skip over the relocs belonging to addresses below the
1993 while (rel_pp
< rel_ppend
1994 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1997 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1999 /* Find the nearest symbol forwards from our current position. */
2000 paux
->require_sec
= TRUE
;
2001 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2002 (struct disassemble_info
*) inf
,
2004 paux
->require_sec
= FALSE
;
2006 /* PR 9774: If the target used signed addresses then we must make
2007 sure that we sign extend the value that we calculate for 'addr'
2008 in the loop below. */
2009 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2010 && (bed
= get_elf_backend_data (abfd
)) != NULL
2011 && bed
->sign_extend_vma
)
2012 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2014 /* Disassemble a block of instructions up to the address associated with
2015 the symbol we have just found. Then print the symbol and find the
2016 next symbol on. Repeat until we have disassembled the entire section
2017 or we have reached the end of the address range we are interested in. */
2018 while (addr_offset
< stop_offset
)
2022 unsigned long nextstop_offset
;
2025 addr
= section
->vma
+ addr_offset
;
2026 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2028 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2033 (x
< sorted_symcount
2034 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2038 pinfo
->symbols
= sorted_syms
+ place
;
2039 pinfo
->num_symbols
= x
- place
;
2040 pinfo
->symtab_pos
= place
;
2044 pinfo
->symbols
= NULL
;
2045 pinfo
->num_symbols
= 0;
2046 pinfo
->symtab_pos
= -1;
2049 if (! prefix_addresses
)
2051 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2052 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2054 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2057 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2059 else if (sym
== NULL
)
2063 #define is_valid_next_sym(SYM) \
2064 ((SYM)->section == section \
2065 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2066 && pinfo->symbol_is_valid (SYM, pinfo))
2068 /* Search forward for the next appropriate symbol in
2069 SECTION. Note that all the symbols are sorted
2070 together into one big array, and that some sections
2071 may have overlapping addresses. */
2072 while (place
< sorted_symcount
2073 && ! is_valid_next_sym (sorted_syms
[place
]))
2076 if (place
>= sorted_symcount
)
2079 nextsym
= sorted_syms
[place
];
2082 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2083 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2084 else if (nextsym
== NULL
)
2085 nextstop_offset
= stop_offset
;
2087 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2089 if (nextstop_offset
> stop_offset
2090 || nextstop_offset
<= addr_offset
)
2091 nextstop_offset
= stop_offset
;
2093 /* If a symbol is explicitly marked as being an object
2094 rather than a function, just dump the bytes without
2095 disassembling them. */
2098 || sym
->section
!= section
2099 || bfd_asymbol_value (sym
) > addr
2100 || ((sym
->flags
& BSF_OBJECT
) == 0
2101 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2103 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2105 || (sym
->flags
& BSF_FUNCTION
) != 0)
2110 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2111 addr_offset
, nextstop_offset
,
2112 rel_offset
, &rel_pp
, rel_ppend
);
2114 addr_offset
= nextstop_offset
;
2120 if (rel_ppstart
!= NULL
)
2124 /* Disassemble the contents of an object file. */
2127 disassemble_data (bfd
*abfd
)
2129 struct disassemble_info disasm_info
;
2130 struct objdump_disasm_info aux
;
2134 prev_functionname
= NULL
;
2136 prev_discriminator
= 0;
2138 /* We make a copy of syms to sort. We don't want to sort syms
2139 because that will screw up the relocs. */
2140 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2141 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2142 * sizeof (asymbol
*));
2143 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2144 sorted_symcount
* sizeof (asymbol
*));
2146 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2148 for (i
= 0; i
< synthcount
; ++i
)
2150 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2154 /* Sort the symbols into section and symbol order. */
2155 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2157 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2159 disasm_info
.application_data
= (void *) &aux
;
2161 aux
.require_sec
= FALSE
;
2162 aux
.dynrelbuf
= NULL
;
2163 aux
.dynrelcount
= 0;
2166 disasm_info
.print_address_func
= objdump_print_address
;
2167 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2169 if (machine
!= NULL
)
2171 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2174 fatal (_("can't use supplied machine %s"), machine
);
2176 abfd
->arch_info
= inf
;
2179 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2181 struct bfd_target
*xvec
;
2183 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2184 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2185 xvec
->byteorder
= endian
;
2189 /* Use libopcodes to locate a suitable disassembler. */
2190 aux
.disassemble_fn
= disassembler (abfd
);
2191 if (!aux
.disassemble_fn
)
2193 non_fatal (_("can't disassemble for architecture %s\n"),
2194 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2199 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2200 disasm_info
.arch
= bfd_get_arch (abfd
);
2201 disasm_info
.mach
= bfd_get_mach (abfd
);
2202 disasm_info
.disassembler_options
= disassembler_options
;
2203 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2204 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2205 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2206 disasm_info
.disassembler_needs_relocs
= FALSE
;
2208 if (bfd_big_endian (abfd
))
2209 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2210 else if (bfd_little_endian (abfd
))
2211 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2213 /* ??? Aborting here seems too drastic. We could default to big or little
2215 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2217 /* Allow the target to customize the info structure. */
2218 disassemble_init_for_target (& disasm_info
);
2220 /* Pre-load the dynamic relocs if we are going
2221 to be dumping them along with the disassembly. */
2222 if (dump_dynamic_reloc_info
)
2224 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2227 bfd_fatal (bfd_get_filename (abfd
));
2231 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2232 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2235 if (aux
.dynrelcount
< 0)
2236 bfd_fatal (bfd_get_filename (abfd
));
2238 /* Sort the relocs by address. */
2239 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2243 disasm_info
.symtab
= sorted_syms
;
2244 disasm_info
.symtab_size
= sorted_symcount
;
2246 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2248 if (aux
.dynrelbuf
!= NULL
)
2249 free (aux
.dynrelbuf
);
2254 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2255 asection
*sec
, void *file
)
2257 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2258 bfd
*abfd
= (bfd
*) file
;
2261 /* If it is already loaded, do nothing. */
2262 if (section
->start
!= NULL
)
2265 section
->address
= bfd_get_section_vma (abfd
, sec
);
2266 section
->size
= bfd_get_section_size (sec
);
2267 section
->start
= NULL
;
2268 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2272 free_debug_section (debug
);
2273 printf (_("\nCan't get contents for section '%s'.\n"),
2278 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2280 bfd_cache_section_contents (sec
, section
->start
);
2282 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2289 free_debug_section (debug
);
2290 printf (_("\nCan't get contents for section '%s'.\n"),
2300 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2302 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2303 bfd
*abfd
= (bfd
*) file
;
2306 /* If it is already loaded, do nothing. */
2307 if (section
->start
!= NULL
)
2310 /* Locate the debug section. */
2311 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2313 section
->name
= section
->uncompressed_name
;
2316 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2318 section
->name
= section
->compressed_name
;
2323 return load_specific_debug_section (debug
, sec
, file
);
2327 free_debug_section (enum dwarf_section_display_enum debug
)
2329 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2331 if (section
->start
== NULL
)
2334 free ((char *) section
->start
);
2335 section
->start
= NULL
;
2336 section
->address
= 0;
2341 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2342 void *arg ATTRIBUTE_UNUSED
)
2344 const char *name
= bfd_get_section_name (abfd
, section
);
2348 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2349 match
= ".debug_info";
2353 for (i
= 0; i
< max
; i
++)
2354 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2355 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2356 && debug_displays
[i
].enabled
!= NULL
2357 && *debug_displays
[i
].enabled
)
2359 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2361 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2362 sec
->name
= sec
->uncompressed_name
;
2364 sec
->name
= sec
->compressed_name
;
2365 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2368 debug_displays
[i
].display (sec
, abfd
);
2370 if (i
!= info
&& i
!= abbrev
)
2371 free_debug_section ((enum dwarf_section_display_enum
) i
);
2377 /* Dump the dwarf debugging information. */
2380 dump_dwarf (bfd
*abfd
)
2382 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2384 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2386 if (bfd_big_endian (abfd
))
2387 byte_get
= byte_get_big_endian
;
2388 else if (bfd_little_endian (abfd
))
2389 byte_get
= byte_get_little_endian
;
2393 switch (bfd_get_arch (abfd
))
2396 switch (bfd_get_mach (abfd
))
2398 case bfd_mach_x86_64
:
2399 case bfd_mach_x86_64_intel_syntax
:
2400 case bfd_mach_x86_64_nacl
:
2401 case bfd_mach_x64_32
:
2402 case bfd_mach_x64_32_intel_syntax
:
2403 case bfd_mach_x64_32_nacl
:
2404 init_dwarf_regnames_x86_64 ();
2408 init_dwarf_regnames_i386 ();
2413 case bfd_arch_aarch64
:
2414 init_dwarf_regnames_aarch64();
2421 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2423 free_debug_memory ();
2426 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2427 it. Return NULL on failure. */
2430 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2436 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2437 if (stabsect
== NULL
)
2439 printf (_("No %s section present\n\n"), sect_name
);
2443 size
= bfd_section_size (abfd
, stabsect
);
2444 contents
= (char *) xmalloc (size
);
2446 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2448 non_fatal (_("reading %s section of %s failed: %s"),
2449 sect_name
, bfd_get_filename (abfd
),
2450 bfd_errmsg (bfd_get_error ()));
2461 /* Stabs entries use a 12 byte format:
2462 4 byte string table index
2464 1 byte stab other field
2465 2 byte stab desc field
2467 FIXME: This will have to change for a 64 bit object format. */
2469 #define STRDXOFF (0)
2471 #define OTHEROFF (5)
2474 #define STABSIZE (12)
2476 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2477 using string table section STRSECT_NAME (in `strtab'). */
2480 print_section_stabs (bfd
*abfd
,
2481 const char *stabsect_name
,
2482 unsigned *string_offset_ptr
)
2485 unsigned file_string_table_offset
= 0;
2486 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2487 bfd_byte
*stabp
, *stabs_end
;
2490 stabs_end
= stabp
+ stab_size
;
2492 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2493 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2495 /* Loop through all symbols and print them.
2497 We start the index at -1 because there is a dummy symbol on
2498 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2499 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2503 unsigned char type
, other
;
2504 unsigned short desc
;
2507 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2508 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2509 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2510 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2511 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2513 printf ("\n%-6d ", i
);
2514 /* Either print the stab name, or, if unnamed, print its number
2515 again (makes consistent formatting for tools like awk). */
2516 name
= bfd_get_stab_name (type
);
2518 printf ("%-6s", name
);
2519 else if (type
== N_UNDF
)
2522 printf ("%-6d", type
);
2523 printf (" %-6d %-6d ", other
, desc
);
2524 bfd_printf_vma (abfd
, value
);
2525 printf (" %-6lu", strx
);
2527 /* Symbols with type == 0 (N_UNDF) specify the length of the
2528 string table associated with this file. We use that info
2529 to know how to relocate the *next* file's string table indices. */
2532 file_string_table_offset
= next_file_string_table_offset
;
2533 next_file_string_table_offset
+= value
;
2537 /* Using the (possibly updated) string table offset, print the
2538 string (if any) associated with this symbol. */
2539 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2540 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2546 *string_offset_ptr
= next_file_string_table_offset
;
2551 const char * section_name
;
2552 const char * string_section_name
;
2553 unsigned string_offset
;
2558 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2561 stab_section_names
* sought
= (stab_section_names
*) names
;
2563 /* Check for section names for which stabsect_name is a prefix, to
2564 handle .stab.N, etc. */
2565 len
= strlen (sought
->section_name
);
2567 /* If the prefix matches, and the files section name ends with a
2568 nul or a digit, then we match. I.e., we want either an exact
2569 match or a section followed by a number. */
2570 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2571 && (section
->name
[len
] == 0
2572 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2575 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2580 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2583 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2589 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2591 stab_section_names s
;
2593 s
.section_name
= stabsect_name
;
2594 s
.string_section_name
= strsect_name
;
2595 s
.string_offset
= 0;
2597 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2603 /* Dump the any sections containing stabs debugging information. */
2606 dump_stabs (bfd
*abfd
)
2608 dump_stabs_section (abfd
, ".stab", ".stabstr");
2609 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2610 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2613 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2615 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2619 dump_bfd_header (bfd
*abfd
)
2623 printf (_("architecture: %s, "),
2624 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2625 bfd_get_mach (abfd
)));
2626 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2628 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2629 PF (HAS_RELOC
, "HAS_RELOC");
2630 PF (EXEC_P
, "EXEC_P");
2631 PF (HAS_LINENO
, "HAS_LINENO");
2632 PF (HAS_DEBUG
, "HAS_DEBUG");
2633 PF (HAS_SYMS
, "HAS_SYMS");
2634 PF (HAS_LOCALS
, "HAS_LOCALS");
2635 PF (DYNAMIC
, "DYNAMIC");
2636 PF (WP_TEXT
, "WP_TEXT");
2637 PF (D_PAGED
, "D_PAGED");
2638 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2639 printf (_("\nstart address 0x"));
2640 bfd_printf_vma (abfd
, abfd
->start_address
);
2646 dump_bfd_private_header (bfd
*abfd
)
2648 bfd_print_private_bfd_data (abfd
, stdout
);
2652 dump_target_specific (bfd
*abfd
)
2654 const struct objdump_private_desc
* const *desc
;
2655 struct objdump_private_option
*opt
;
2658 /* Find the desc. */
2659 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2660 if ((*desc
)->filter (abfd
))
2665 non_fatal (_("option -P/--private not supported by this file"));
2669 /* Clear all options. */
2670 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2671 opt
->selected
= FALSE
;
2673 /* Decode options. */
2674 b
= dump_private_options
;
2677 e
= strchr (b
, ',');
2682 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2683 if (strcmp (opt
->name
, b
) == 0)
2685 opt
->selected
= TRUE
;
2688 if (opt
->name
== NULL
)
2689 non_fatal (_("target specific dump '%s' not supported"), b
);
2700 (*desc
)->dump (abfd
);
2703 /* Display a section in hexadecimal format with associated characters.
2704 Each line prefixed by the zero padded address. */
2707 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2710 bfd_size_type datasize
;
2711 bfd_size_type addr_offset
;
2712 bfd_size_type start_offset
;
2713 bfd_size_type stop_offset
;
2714 unsigned int opb
= bfd_octets_per_byte (abfd
);
2715 /* Bytes per line. */
2716 const int onaline
= 16;
2721 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2724 if (! process_section_p (section
))
2727 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2730 /* Compute the address range to display. */
2731 if (start_address
== (bfd_vma
) -1
2732 || start_address
< section
->vma
)
2735 start_offset
= start_address
- section
->vma
;
2737 if (stop_address
== (bfd_vma
) -1)
2738 stop_offset
= datasize
/ opb
;
2741 if (stop_address
< section
->vma
)
2744 stop_offset
= stop_address
- section
->vma
;
2746 if (stop_offset
> datasize
/ opb
)
2747 stop_offset
= datasize
/ opb
;
2750 if (start_offset
>= stop_offset
)
2753 printf (_("Contents of section %s:"), section
->name
);
2754 if (display_file_offsets
)
2755 printf (_(" (Starting at file offset: 0x%lx)"),
2756 (unsigned long) (section
->filepos
+ start_offset
));
2759 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2761 non_fatal (_("Reading section failed"));
2767 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2768 if (strlen (buf
) >= sizeof (buf
))
2772 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2774 count
= strlen (buf
) - count
;
2778 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2779 if (strlen (buf
) >= sizeof (buf
))
2783 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2785 count
= strlen (buf
) - count
;
2789 for (addr_offset
= start_offset
;
2790 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2794 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2795 count
= strlen (buf
);
2796 if ((size_t) count
>= sizeof (buf
))
2800 while (count
< width
)
2805 fputs (buf
+ count
- width
, stdout
);
2808 for (j
= addr_offset
* opb
;
2809 j
< addr_offset
* opb
+ onaline
; j
++)
2811 if (j
< stop_offset
* opb
)
2812 printf ("%02x", (unsigned) (data
[j
]));
2820 for (j
= addr_offset
* opb
;
2821 j
< addr_offset
* opb
+ onaline
; j
++)
2823 if (j
>= stop_offset
* opb
)
2826 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2833 /* Actually display the various requested regions. */
2836 dump_data (bfd
*abfd
)
2838 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2841 /* Should perhaps share code and display with nm? */
2844 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2853 max_count
= dynsymcount
;
2854 printf ("DYNAMIC SYMBOL TABLE:\n");
2859 max_count
= symcount
;
2860 printf ("SYMBOL TABLE:\n");
2864 printf (_("no symbols\n"));
2866 for (count
= 0; count
< max_count
; count
++)
2870 if (*current
== NULL
)
2871 printf (_("no information for symbol number %ld\n"), count
);
2873 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2874 printf (_("could not determine the type of symbol number %ld\n"),
2877 else if (process_section_p ((* current
)->section
)
2878 && (dump_special_syms
2879 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2881 const char *name
= (*current
)->name
;
2883 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2887 /* If we want to demangle the name, we demangle it
2888 here, and temporarily clobber it while calling
2889 bfd_print_symbol. FIXME: This is a gross hack. */
2890 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2892 (*current
)->name
= alloc
;
2893 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2894 bfd_print_symbol_all
);
2897 (*current
)->name
= name
;
2902 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2903 bfd_print_symbol_all
);
2913 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2916 char *last_filename
, *last_functionname
;
2917 unsigned int last_line
;
2918 unsigned int last_discriminator
;
2920 /* Get column headers lined up reasonably. */
2928 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2929 width
= strlen (buf
) - 7;
2931 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2934 last_filename
= NULL
;
2935 last_functionname
= NULL
;
2937 last_discriminator
= 0;
2939 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2942 const char *filename
, *functionname
;
2943 unsigned int linenumber
;
2944 unsigned int discriminator
;
2945 const char *sym_name
;
2946 const char *section_name
;
2947 bfd_vma addend2
= 0;
2949 if (start_address
!= (bfd_vma
) -1
2950 && q
->address
< start_address
)
2952 if (stop_address
!= (bfd_vma
) -1
2953 && q
->address
> stop_address
)
2956 if (with_line_numbers
2958 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
2959 &filename
, &functionname
,
2960 &linenumber
, &discriminator
))
2962 if (functionname
!= NULL
2963 && (last_functionname
== NULL
2964 || strcmp (functionname
, last_functionname
) != 0))
2966 printf ("%s():\n", functionname
);
2967 if (last_functionname
!= NULL
)
2968 free (last_functionname
);
2969 last_functionname
= xstrdup (functionname
);
2973 && (linenumber
!= last_line
2974 || (filename
!= NULL
2975 && last_filename
!= NULL
2976 && filename_cmp (filename
, last_filename
) != 0)
2977 || (discriminator
!= last_discriminator
)))
2979 if (discriminator
> 0)
2980 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2982 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
2983 linenumber
, discriminator
);
2984 last_line
= linenumber
;
2985 last_discriminator
= discriminator
;
2986 if (last_filename
!= NULL
)
2987 free (last_filename
);
2988 if (filename
== NULL
)
2989 last_filename
= NULL
;
2991 last_filename
= xstrdup (filename
);
2995 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2997 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2998 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3003 section_name
= NULL
;
3006 bfd_printf_vma (abfd
, q
->address
);
3007 if (q
->howto
== NULL
)
3008 printf (" *unknown* ");
3009 else if (q
->howto
->name
)
3011 const char *name
= q
->howto
->name
;
3013 /* R_SPARC_OLO10 relocations contain two addends.
3014 But because 'arelent' lacks enough storage to
3015 store them both, the 64-bit ELF Sparc backend
3016 records this as two relocations. One R_SPARC_LO10
3017 and one R_SPARC_13, both pointing to the same
3018 address. This is merely so that we have some
3019 place to store both addend fields.
3021 Undo this transformation, otherwise the output
3022 will be confusing. */
3023 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3024 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3026 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3028 arelent
*q2
= *(p
+ 1);
3031 && q
->address
== q2
->address
3032 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3034 name
= "R_SPARC_OLO10";
3035 addend2
= q2
->addend
;
3039 printf (" %-16s ", name
);
3042 printf (" %-16d ", q
->howto
->type
);
3046 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3050 if (section_name
== NULL
)
3051 section_name
= "*unknown*";
3052 printf ("[%s]", section_name
);
3057 bfd_signed_vma addend
= q
->addend
;
3065 bfd_printf_vma (abfd
, addend
);
3070 bfd_printf_vma (abfd
, addend2
);
3076 if (last_filename
!= NULL
)
3077 free (last_filename
);
3078 if (last_functionname
!= NULL
)
3079 free (last_functionname
);
3083 dump_relocs_in_section (bfd
*abfd
,
3085 void *dummy ATTRIBUTE_UNUSED
)
3091 if ( bfd_is_abs_section (section
)
3092 || bfd_is_und_section (section
)
3093 || bfd_is_com_section (section
)
3094 || (! process_section_p (section
))
3095 || ((section
->flags
& SEC_RELOC
) == 0))
3098 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3100 bfd_fatal (bfd_get_filename (abfd
));
3102 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3106 printf (" (none)\n\n");
3110 relpp
= (arelent
**) xmalloc (relsize
);
3111 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3116 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3117 bfd_fatal (_("error message was"));
3119 else if (relcount
== 0)
3120 printf (" (none)\n\n");
3124 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3131 dump_relocs (bfd
*abfd
)
3133 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3137 dump_dynamic_relocs (bfd
*abfd
)
3143 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3145 bfd_fatal (bfd_get_filename (abfd
));
3147 printf ("DYNAMIC RELOCATION RECORDS");
3150 printf (" (none)\n\n");
3153 relpp
= (arelent
**) xmalloc (relsize
);
3154 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3157 bfd_fatal (bfd_get_filename (abfd
));
3158 else if (relcount
== 0)
3159 printf (" (none)\n\n");
3163 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3170 /* Creates a table of paths, to search for source files. */
3173 add_include_path (const char *path
)
3177 include_path_count
++;
3178 include_paths
= (const char **)
3179 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3180 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3181 if (path
[1] == ':' && path
[2] == 0)
3182 path
= concat (path
, ".", (const char *) 0);
3184 include_paths
[include_path_count
- 1] = path
;
3188 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3192 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3194 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3195 section
->vma
+= adjust_section_vma
;
3197 section
->lma
+= adjust_section_vma
;
3201 /* Dump selected contents of ABFD. */
3204 dump_bfd (bfd
*abfd
)
3206 /* If we are adjusting section VMA's, change them all now. Changing
3207 the BFD information is a hack. However, we must do it, or
3208 bfd_find_nearest_line will not do the right thing. */
3209 if (adjust_section_vma
!= 0)
3211 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3212 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3215 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3216 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3219 print_arelt_descr (stdout
, abfd
, TRUE
);
3220 if (dump_file_header
)
3221 dump_bfd_header (abfd
);
3222 if (dump_private_headers
)
3223 dump_bfd_private_header (abfd
);
3224 if (dump_private_options
!= NULL
)
3225 dump_target_specific (abfd
);
3226 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3233 || dump_dwarf_section_info
)
3234 syms
= slurp_symtab (abfd
);
3236 if (dump_section_headers
)
3237 dump_headers (abfd
);
3239 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3240 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3241 dynsyms
= slurp_dynamic_symtab (abfd
);
3244 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3245 dynsymcount
, dynsyms
, &synthsyms
);
3251 dump_symbols (abfd
, FALSE
);
3252 if (dump_dynamic_symtab
)
3253 dump_symbols (abfd
, TRUE
);
3254 if (dump_dwarf_section_info
)
3256 if (dump_stab_section_info
)
3258 if (dump_reloc_info
&& ! disassemble
)
3260 if (dump_dynamic_reloc_info
&& ! disassemble
)
3261 dump_dynamic_relocs (abfd
);
3262 if (dump_section_contents
)
3265 disassemble_data (abfd
);
3271 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3272 if (dhandle
!= NULL
)
3274 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3276 dump_debugging_tags
? TRUE
: FALSE
))
3278 non_fatal (_("%s: printing debugging information failed"),
3279 bfd_get_filename (abfd
));
3283 /* PR 6483: If there was no STABS or IEEE debug
3284 info in the file, try DWARF instead. */
3285 else if (! dump_dwarf_section_info
)
3287 dwarf_select_sections_all ();
3316 display_object_bfd (bfd
*abfd
)
3320 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3326 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3328 nonfatal (bfd_get_filename (abfd
));
3329 list_matching_formats (matching
);
3334 if (bfd_get_error () != bfd_error_file_not_recognized
)
3336 nonfatal (bfd_get_filename (abfd
));
3340 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3346 nonfatal (bfd_get_filename (abfd
));
3348 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3350 list_matching_formats (matching
);
3356 display_any_bfd (bfd
*file
, int level
)
3358 /* Decompress sections unless dumping the section contents. */
3359 if (!dump_section_contents
)
3360 file
->flags
|= BFD_DECOMPRESS
;
3362 /* If the file is an archive, process all of its elements. */
3363 if (bfd_check_format (file
, bfd_archive
))
3366 bfd
*last_arfile
= NULL
;
3369 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3371 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3375 bfd_set_error (bfd_error_no_error
);
3377 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3380 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3381 nonfatal (bfd_get_filename (file
));
3385 display_any_bfd (arfile
, level
+ 1);
3387 if (last_arfile
!= NULL
)
3388 bfd_close (last_arfile
);
3389 last_arfile
= arfile
;
3392 if (last_arfile
!= NULL
)
3393 bfd_close (last_arfile
);
3396 display_object_bfd (file
);
3400 display_file (char *filename
, char *target
)
3404 if (get_file_size (filename
) < 1)
3410 file
= bfd_openr (filename
, target
);
3413 nonfatal (filename
);
3417 display_any_bfd (file
, 0);
3423 main (int argc
, char **argv
)
3426 char *target
= default_target
;
3427 bfd_boolean seenflag
= FALSE
;
3429 #if defined (HAVE_SETLOCALE)
3430 #if defined (HAVE_LC_MESSAGES)
3431 setlocale (LC_MESSAGES
, "");
3433 setlocale (LC_CTYPE
, "");
3436 bindtextdomain (PACKAGE
, LOCALEDIR
);
3437 textdomain (PACKAGE
);
3439 program_name
= *argv
;
3440 xmalloc_set_program_name (program_name
);
3442 START_PROGRESS (program_name
, 0);
3444 expandargv (&argc
, &argv
);
3447 set_default_bfd_target ();
3449 while ((c
= getopt_long (argc
, argv
,
3450 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3451 long_options
, (int *) 0))
3457 break; /* We've been given a long option. */
3462 if (disassembler_options
)
3463 /* Ignore potential memory leak for now. */
3464 disassembler_options
= concat (disassembler_options
, ",",
3465 optarg
, (const char *) NULL
);
3467 disassembler_options
= optarg
;
3473 display_file_offsets
= TRUE
;
3476 with_line_numbers
= TRUE
;
3485 enum demangling_styles style
;
3487 style
= cplus_demangle_name_to_style (optarg
);
3488 if (style
== unknown_demangling
)
3489 fatal (_("unknown demangling style `%s'"),
3492 cplus_demangle_set_style (style
);
3498 case OPTION_ADJUST_VMA
:
3499 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3501 case OPTION_START_ADDRESS
:
3502 start_address
= parse_vma (optarg
, "--start-address");
3503 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3504 fatal (_("error: the start address should be before the end address"));
3506 case OPTION_STOP_ADDRESS
:
3507 stop_address
= parse_vma (optarg
, "--stop-address");
3508 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3509 fatal (_("error: the stop address should be after the start address"));
3513 prefix_length
= strlen (prefix
);
3514 /* Remove an unnecessary trailing '/' */
3515 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3518 case OPTION_PREFIX_STRIP
:
3519 prefix_strip
= atoi (optarg
);
3520 if (prefix_strip
< 0)
3521 fatal (_("error: prefix strip must be non-negative"));
3523 case OPTION_INSN_WIDTH
:
3524 insn_width
= strtoul (optarg
, NULL
, 0);
3525 if (insn_width
<= 0)
3526 fatal (_("error: instruction width must be positive"));
3529 if (strcmp (optarg
, "B") == 0)
3530 endian
= BFD_ENDIAN_BIG
;
3531 else if (strcmp (optarg
, "L") == 0)
3532 endian
= BFD_ENDIAN_LITTLE
;
3535 nonfatal (_("unrecognized -E option"));
3540 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3541 endian
= BFD_ENDIAN_BIG
;
3542 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3543 endian
= BFD_ENDIAN_LITTLE
;
3546 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3553 dump_file_header
= TRUE
;
3557 formats_info
= TRUE
;
3561 add_include_path (optarg
);
3564 dump_private_headers
= TRUE
;
3568 dump_private_options
= optarg
;
3572 dump_private_headers
= TRUE
;
3574 dump_reloc_info
= TRUE
;
3575 dump_file_header
= TRUE
;
3576 dump_ar_hdrs
= TRUE
;
3577 dump_section_headers
= TRUE
;
3585 dump_dynamic_symtab
= TRUE
;
3593 disassemble_zeroes
= TRUE
;
3597 disassemble_all
= TRUE
;
3602 with_source_code
= TRUE
;
3611 dump_debugging_tags
= 1;
3616 dump_dwarf_section_info
= TRUE
;
3619 dwarf_select_sections_by_letters (optarg
);
3621 dwarf_select_sections_all ();
3624 dump_dwarf_section_info
= TRUE
;
3627 dwarf_select_sections_by_names (optarg
);
3629 dwarf_select_sections_all ();
3631 case OPTION_DWARF_DEPTH
:
3634 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3637 case OPTION_DWARF_START
:
3640 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3641 suppress_bfd_header
= 1;
3644 case OPTION_DWARF_CHECK
:
3648 dump_stab_section_info
= TRUE
;
3652 dump_section_contents
= TRUE
;
3656 dump_reloc_info
= TRUE
;
3660 dump_dynamic_reloc_info
= TRUE
;
3664 dump_ar_hdrs
= TRUE
;
3668 dump_section_headers
= TRUE
;
3673 show_version
= TRUE
;
3679 /* No need to set seenflag or to break - usage() does not return. */
3686 print_version ("objdump");
3692 exit_status
= display_info ();
3696 display_file ("a.out", target
);
3698 for (; optind
< argc
;)
3699 display_file (argv
[optind
++], target
);
3704 END_PROGRESS (program_name
);