1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int do_demangle
; /* -C, --demangle */
103 static bfd_boolean disassemble
; /* -d */
104 static bfd_boolean disassemble_all
; /* -D */
105 static int disassemble_zeroes
; /* --disassemble-zeroes */
106 static bfd_boolean formats_info
; /* -i */
107 static int wide_output
; /* -w */
108 static int insn_width
; /* --insn-width */
109 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
110 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
111 static int dump_debugging
; /* --debugging */
112 static int dump_debugging_tags
; /* --debugging-tags */
113 static int suppress_bfd_header
;
114 static int dump_special_syms
= 0; /* --special-syms */
115 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
116 static int file_start_context
= 0; /* --file-start-context */
117 static bfd_boolean display_file_offsets
;/* -F */
118 static const char *prefix
; /* --prefix */
119 static int prefix_strip
; /* --prefix-strip */
120 static size_t prefix_length
;
122 /* A structure to record the sections mentioned in -j switches. */
125 const char * name
; /* The name of the section. */
126 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
127 struct only
* next
; /* Pointer to the next structure in the list. */
129 /* Pointer to an array of 'only' structures.
130 This pointer is NULL if the -j switch has not been used. */
131 static struct only
* only_list
= NULL
;
133 /* Variables for handling include file path table. */
134 static const char **include_paths
;
135 static int include_path_count
;
137 /* Extra info to pass to the section disassembler and address printing
139 struct objdump_disasm_info
143 bfd_boolean require_sec
;
144 arelent
** dynrelbuf
;
146 disassembler_ftype disassemble_fn
;
150 /* Architecture to disassemble for, or default if NULL. */
151 static char *machine
= NULL
;
153 /* Target specific options to the disassembler. */
154 static char *disassembler_options
= NULL
;
156 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
157 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
159 /* The symbol table. */
160 static asymbol
**syms
;
162 /* Number of symbols in `syms'. */
163 static long symcount
= 0;
165 /* The sorted symbol table. */
166 static asymbol
**sorted_syms
;
168 /* Number of symbols in `sorted_syms'. */
169 static long sorted_symcount
= 0;
171 /* The dynamic symbol table. */
172 static asymbol
**dynsyms
;
174 /* The synthetic symbol table. */
175 static asymbol
*synthsyms
;
176 static long synthcount
= 0;
178 /* Number of symbols in `dynsyms'. */
179 static long dynsymcount
= 0;
181 static bfd_byte
*stabs
;
182 static bfd_size_type stab_size
;
185 static bfd_size_type stabstr_size
;
187 static bfd_boolean is_relocatable
= FALSE
;
189 /* Handlers for -P/--private. */
190 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
192 OBJDUMP_PRIVATE_VECTORS
197 usage (FILE *stream
, int status
)
199 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
200 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
201 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
202 fprintf (stream
, _("\
203 -a, --archive-headers Display archive header information\n\
204 -f, --file-headers Display the contents of the overall file header\n\
205 -p, --private-headers Display object format specific file header contents\n\
206 -P, --private=OPT,OPT... Display object format specific contents\n\
207 -h, --[section-]headers Display the contents of the section headers\n\
208 -x, --all-headers Display the contents of all headers\n\
209 -d, --disassemble Display assembler contents of executable sections\n\
210 -D, --disassemble-all Display assembler contents of all sections\n\
211 -S, --source Intermix source code with disassembly\n\
212 -s, --full-contents Display the full contents of all sections requested\n\
213 -g, --debugging Display debug information in object file\n\
214 -e, --debugging-tags Display debug information using ctags style\n\
215 -G, --stabs Display (in raw form) any STABS info in the file\n\
216 -W[lLiaprmfFsoRt] or\n\
217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 Display DWARF info in the file\n\
222 -t, --syms Display the contents of the symbol table(s)\n\
223 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
224 -r, --reloc Display the relocation entries in the file\n\
225 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
226 @<file> Read options from <file>\n\
227 -v, --version Display this program's version number\n\
228 -i, --info List object formats and architectures supported\n\
229 -H, --help Display this information\n\
233 const struct objdump_private_desc
* const *desc
;
235 fprintf (stream
, _("\n The following switches are optional:\n"));
236 fprintf (stream
, _("\
237 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
238 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
239 -j, --section=NAME Only display information for section NAME\n\
240 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
241 -EB --endian=big Assume big endian format when disassembling\n\
242 -EL --endian=little Assume little endian format when disassembling\n\
243 --file-start-context Include context from start of file (with -S)\n\
244 -I, --include=DIR Add DIR to search list for source files\n\
245 -l, --line-numbers Include line numbers and filenames in output\n\
246 -F, --file-offsets Include file offsets when displaying information\n\
247 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
248 The STYLE, if specified, can be `auto', `gnu',\n\
249 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251 -w, --wide Format output for more than 80 columns\n\
252 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
253 --start-address=ADDR Only process data whose address is >= ADDR\n\
254 --stop-address=ADDR Only process data whose address is <= ADDR\n\
255 --prefix-addresses Print complete address alongside disassembly\n\
256 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
257 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
258 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
259 --special-syms Include special symbols in symbol dumps\n\
260 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
261 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
262 fprintf (stream
, _("\
263 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
264 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
266 --dwarf-check Make additional dwarf internal consistency checks.\
268 list_supported_targets (program_name
, stream
);
269 list_supported_architectures (program_name
, stream
);
271 disassembler_usage (stream
);
273 if (objdump_private_vectors
[0] != NULL
)
276 _("\nOptions supported for -P/--private switch:\n"));
277 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
278 (*desc
)->help (stream
);
281 if (REPORT_BUGS_TO
[0] && status
== 0)
282 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
286 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
290 OPTION_START_ADDRESS
,
302 static struct option long_options
[]=
304 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
305 {"all-headers", no_argument
, NULL
, 'x'},
306 {"private-headers", no_argument
, NULL
, 'p'},
307 {"private", required_argument
, NULL
, 'P'},
308 {"architecture", required_argument
, NULL
, 'm'},
309 {"archive-headers", no_argument
, NULL
, 'a'},
310 {"debugging", no_argument
, NULL
, 'g'},
311 {"debugging-tags", no_argument
, NULL
, 'e'},
312 {"demangle", optional_argument
, NULL
, 'C'},
313 {"disassemble", no_argument
, NULL
, 'd'},
314 {"disassemble-all", no_argument
, NULL
, 'D'},
315 {"disassembler-options", required_argument
, NULL
, 'M'},
316 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
317 {"dynamic-reloc", no_argument
, NULL
, 'R'},
318 {"dynamic-syms", no_argument
, NULL
, 'T'},
319 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
320 {"file-headers", no_argument
, NULL
, 'f'},
321 {"file-offsets", no_argument
, NULL
, 'F'},
322 {"file-start-context", no_argument
, &file_start_context
, 1},
323 {"full-contents", no_argument
, NULL
, 's'},
324 {"headers", no_argument
, NULL
, 'h'},
325 {"help", no_argument
, NULL
, 'H'},
326 {"info", no_argument
, NULL
, 'i'},
327 {"line-numbers", no_argument
, NULL
, 'l'},
328 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
329 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
330 {"reloc", no_argument
, NULL
, 'r'},
331 {"section", required_argument
, NULL
, 'j'},
332 {"section-headers", no_argument
, NULL
, 'h'},
333 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
334 {"source", no_argument
, NULL
, 'S'},
335 {"special-syms", no_argument
, &dump_special_syms
, 1},
336 {"include", required_argument
, NULL
, 'I'},
337 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
338 {"stabs", no_argument
, NULL
, 'G'},
339 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
340 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
341 {"syms", no_argument
, NULL
, 't'},
342 {"target", required_argument
, NULL
, 'b'},
343 {"version", no_argument
, NULL
, 'V'},
344 {"wide", no_argument
, NULL
, 'w'},
345 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
346 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
347 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
348 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
349 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
350 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
351 {0, no_argument
, 0, 0}
355 nonfatal (const char *msg
)
361 /* Returns TRUE if the specified section should be dumped. */
364 process_section_p (asection
* section
)
368 if (only_list
== NULL
)
371 for (only
= only_list
; only
; only
= only
->next
)
372 if (strcmp (only
->name
, section
->name
) == 0)
381 /* Add an entry to the 'only' list. */
384 add_only (char * name
)
388 /* First check to make sure that we do not
389 already have an entry for this name. */
390 for (only
= only_list
; only
; only
= only
->next
)
391 if (strcmp (only
->name
, name
) == 0)
394 only
= xmalloc (sizeof * only
);
397 only
->next
= only_list
;
401 /* Release the memory used by the 'only' list.
402 PR 11225: Issue a warning message for unseen sections.
403 Only do this if none of the sections were seen. This is mainly to support
404 tools like the GAS testsuite where an object file is dumped with a list of
405 generic section names known to be present in a range of different file
409 free_only_list (void)
411 bfd_boolean at_least_one_seen
= FALSE
;
415 if (only_list
== NULL
)
418 for (only
= only_list
; only
; only
= only
->next
)
421 at_least_one_seen
= TRUE
;
425 for (only
= only_list
; only
; only
= next
)
427 if (! at_least_one_seen
)
429 non_fatal (_("section '%s' mentioned in a -j option, "
430 "but not found in any input file"),
441 dump_section_header (bfd
*abfd
, asection
*section
,
442 void *ignored ATTRIBUTE_UNUSED
)
445 unsigned int opb
= bfd_octets_per_byte (abfd
);
447 /* Ignore linker created section. See elfNN_ia64_object_p in
449 if (section
->flags
& SEC_LINKER_CREATED
)
452 /* PR 10413: Skip sections that we are ignoring. */
453 if (! process_section_p (section
))
456 printf ("%3d %-13s %08lx ", section
->index
,
457 bfd_get_section_name (abfd
, section
),
458 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
459 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
461 bfd_printf_vma (abfd
, section
->lma
);
462 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
463 bfd_get_section_alignment (abfd
, section
));
469 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
471 PF (SEC_HAS_CONTENTS
, "CONTENTS");
472 PF (SEC_ALLOC
, "ALLOC");
473 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
474 PF (SEC_LOAD
, "LOAD");
475 PF (SEC_RELOC
, "RELOC");
476 PF (SEC_READONLY
, "READONLY");
477 PF (SEC_CODE
, "CODE");
478 PF (SEC_DATA
, "DATA");
480 PF (SEC_DEBUGGING
, "DEBUGGING");
481 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
482 PF (SEC_EXCLUDE
, "EXCLUDE");
483 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
484 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
486 PF (SEC_TIC54X_BLOCK
, "BLOCK");
487 PF (SEC_TIC54X_CLINK
, "CLINK");
489 PF (SEC_SMALL_DATA
, "SMALL_DATA");
490 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
491 PF (SEC_COFF_SHARED
, "SHARED");
492 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
493 PF (SEC_GROUP
, "GROUP");
495 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
498 struct coff_comdat_info
*comdat
;
500 switch (section
->flags
& SEC_LINK_DUPLICATES
)
504 case SEC_LINK_DUPLICATES_DISCARD
:
505 ls
= "LINK_ONCE_DISCARD";
507 case SEC_LINK_DUPLICATES_ONE_ONLY
:
508 ls
= "LINK_ONCE_ONE_ONLY";
510 case SEC_LINK_DUPLICATES_SAME_SIZE
:
511 ls
= "LINK_ONCE_SAME_SIZE";
513 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
514 ls
= "LINK_ONCE_SAME_CONTENTS";
517 printf ("%s%s", comma
, ls
);
519 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
521 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
531 dump_headers (bfd
*abfd
)
533 printf (_("Sections:\n"));
536 printf (_("Idx Name Size VMA LMA File off Algn"));
538 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
539 if (bfd_get_arch_size (abfd
) == 32)
540 printf (_("Idx Name Size VMA LMA File off Algn"));
542 printf (_("Idx Name Size VMA LMA File off Algn"));
546 printf (_(" Flags"));
549 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
553 slurp_symtab (bfd
*abfd
)
558 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
564 storage
= bfd_get_symtab_upper_bound (abfd
);
566 bfd_fatal (bfd_get_filename (abfd
));
568 sy
= (asymbol
**) xmalloc (storage
);
570 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
572 bfd_fatal (bfd_get_filename (abfd
));
576 /* Read in the dynamic symbols. */
579 slurp_dynamic_symtab (bfd
*abfd
)
584 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
587 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
589 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
595 bfd_fatal (bfd_get_filename (abfd
));
598 sy
= (asymbol
**) xmalloc (storage
);
600 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
602 bfd_fatal (bfd_get_filename (abfd
));
606 /* Filter out (in place) symbols that are useless for disassembly.
607 COUNT is the number of elements in SYMBOLS.
608 Return the number of useful symbols. */
611 remove_useless_symbols (asymbol
**symbols
, long count
)
613 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
617 asymbol
*sym
= *in_ptr
++;
619 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
621 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
623 if (bfd_is_und_section (sym
->section
)
624 || bfd_is_com_section (sym
->section
))
629 return out_ptr
- symbols
;
632 /* Sort symbols into value order. */
635 compare_symbols (const void *ap
, const void *bp
)
637 const asymbol
*a
= * (const asymbol
**) ap
;
638 const asymbol
*b
= * (const asymbol
**) bp
;
648 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
650 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
653 if (a
->section
> b
->section
)
655 else if (a
->section
< b
->section
)
658 an
= bfd_asymbol_name (a
);
659 bn
= bfd_asymbol_name (b
);
663 /* The symbols gnu_compiled and gcc2_compiled convey no real
664 information, so put them after other symbols with the same value. */
665 af
= (strstr (an
, "gnu_compiled") != NULL
666 || strstr (an
, "gcc2_compiled") != NULL
);
667 bf
= (strstr (bn
, "gnu_compiled") != NULL
668 || strstr (bn
, "gcc2_compiled") != NULL
);
675 /* We use a heuristic for the file name, to try to sort it after
676 more useful symbols. It may not work on non Unix systems, but it
677 doesn't really matter; the only difference is precisely which
678 symbol names get printed. */
680 #define file_symbol(s, sn, snl) \
681 (((s)->flags & BSF_FILE) != 0 \
682 || ((sn)[(snl) - 2] == '.' \
683 && ((sn)[(snl) - 1] == 'o' \
684 || (sn)[(snl) - 1] == 'a')))
686 af
= file_symbol (a
, an
, anl
);
687 bf
= file_symbol (b
, bn
, bnl
);
694 /* Try to sort global symbols before local symbols before function
695 symbols before debugging symbols. */
700 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
702 if ((aflags
& BSF_DEBUGGING
) != 0)
707 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
709 if ((aflags
& BSF_FUNCTION
) != 0)
714 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
716 if ((aflags
& BSF_LOCAL
) != 0)
721 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
723 if ((aflags
& BSF_GLOBAL
) != 0)
729 /* Symbols that start with '.' might be section names, so sort them
730 after symbols that don't start with '.'. */
731 if (an
[0] == '.' && bn
[0] != '.')
733 if (an
[0] != '.' && bn
[0] == '.')
736 /* Finally, if we can't distinguish them in any other way, try to
737 get consistent results by sorting the symbols by name. */
738 return strcmp (an
, bn
);
741 /* Sort relocs into address order. */
744 compare_relocs (const void *ap
, const void *bp
)
746 const arelent
*a
= * (const arelent
**) ap
;
747 const arelent
*b
= * (const arelent
**) bp
;
749 if (a
->address
> b
->address
)
751 else if (a
->address
< b
->address
)
754 /* So that associated relocations tied to the same address show up
755 in the correct order, we don't do any further sorting. */
764 /* Print an address (VMA) to the output stream in INFO.
765 If SKIP_ZEROES is TRUE, omit leading zeroes. */
768 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
769 bfd_boolean skip_zeroes
)
773 struct objdump_disasm_info
*aux
;
775 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
776 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
781 for (p
= buf
; *p
== '0'; ++p
)
786 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
789 /* Print the name of a symbol. */
792 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
799 name
= bfd_asymbol_name (sym
);
800 if (do_demangle
&& name
[0] != '\0')
802 /* Demangle the name. */
803 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
809 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
817 /* Locate a symbol given a bfd and a section (from INFO->application_data),
818 and a VMA. If INFO->application_data->require_sec is TRUE, then always
819 require the symbol to be in the section. Returns NULL if there is no
820 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
821 of the symbol in sorted_syms. */
824 find_symbol_for_address (bfd_vma vma
,
825 struct disassemble_info
*inf
,
828 /* @@ Would it speed things up to cache the last two symbols returned,
829 and maybe their address ranges? For many processors, only one memory
830 operand can be present at a time, so the 2-entry cache wouldn't be
831 constantly churned by code doing heavy memory accesses. */
833 /* Indices in `sorted_syms'. */
835 long max_count
= sorted_symcount
;
837 struct objdump_disasm_info
*aux
;
841 bfd_boolean want_section
;
843 if (sorted_symcount
< 1)
846 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
849 opb
= inf
->octets_per_byte
;
851 /* Perform a binary search looking for the closest symbol to the
852 required value. We are searching the range (min, max_count]. */
853 while (min
+ 1 < max_count
)
857 thisplace
= (max_count
+ min
) / 2;
858 sym
= sorted_syms
[thisplace
];
860 if (bfd_asymbol_value (sym
) > vma
)
861 max_count
= thisplace
;
862 else if (bfd_asymbol_value (sym
) < vma
)
871 /* The symbol we want is now in min, the low end of the range we
872 were searching. If there are several symbols with the same
873 value, we want the first one. */
876 && (bfd_asymbol_value (sorted_syms
[thisplace
])
877 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
880 /* Prefer a symbol in the current section if we have multple symbols
881 with the same value, as can occur with overlays or zero size
884 while (min
< max_count
885 && (bfd_asymbol_value (sorted_syms
[min
])
886 == bfd_asymbol_value (sorted_syms
[thisplace
])))
888 if (sorted_syms
[min
]->section
== sec
889 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
896 return sorted_syms
[thisplace
];
901 /* If the file is relocatable, and the symbol could be from this
902 section, prefer a symbol from this section over symbols from
903 others, even if the other symbol's value might be closer.
905 Note that this may be wrong for some symbol references if the
906 sections have overlapping memory ranges, but in that case there's
907 no way to tell what's desired without looking at the relocation
910 Also give the target a chance to reject symbols. */
911 want_section
= (aux
->require_sec
912 || ((abfd
->flags
& HAS_RELOC
) != 0
913 && vma
>= bfd_get_section_vma (abfd
, sec
)
914 && vma
< (bfd_get_section_vma (abfd
, sec
)
915 + bfd_section_size (abfd
, sec
) / opb
)));
916 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
917 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
920 long newplace
= sorted_symcount
;
922 for (i
= min
- 1; i
>= 0; i
--)
924 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
925 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
927 if (newplace
== sorted_symcount
)
930 if (bfd_asymbol_value (sorted_syms
[i
])
931 != bfd_asymbol_value (sorted_syms
[newplace
]))
934 /* Remember this symbol and keep searching until we reach
935 an earlier address. */
940 if (newplace
!= sorted_symcount
)
941 thisplace
= newplace
;
944 /* We didn't find a good symbol with a smaller value.
945 Look for one with a larger value. */
946 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
948 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
949 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
957 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
958 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
959 /* There is no suitable symbol. */
966 return sorted_syms
[thisplace
];
969 /* Print an address and the offset to the nearest symbol. */
972 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
973 bfd_vma vma
, struct disassemble_info
*inf
,
974 bfd_boolean skip_zeroes
)
976 objdump_print_value (vma
, inf
, skip_zeroes
);
982 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
983 bfd_get_section_name (abfd
, sec
));
984 secaddr
= bfd_get_section_vma (abfd
, sec
);
987 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
988 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
990 else if (vma
> secaddr
)
992 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
993 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
995 (*inf
->fprintf_func
) (inf
->stream
, ">");
999 (*inf
->fprintf_func
) (inf
->stream
, " <");
1000 objdump_print_symname (abfd
, inf
, sym
);
1001 if (bfd_asymbol_value (sym
) > vma
)
1003 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1004 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1006 else if (vma
> bfd_asymbol_value (sym
))
1008 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1009 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1011 (*inf
->fprintf_func
) (inf
->stream
, ">");
1014 if (display_file_offsets
)
1015 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1016 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1019 /* Print an address (VMA), symbolically if possible.
1020 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1023 objdump_print_addr (bfd_vma vma
,
1024 struct disassemble_info
*inf
,
1025 bfd_boolean skip_zeroes
)
1027 struct objdump_disasm_info
*aux
;
1028 asymbol
*sym
= NULL
;
1029 bfd_boolean skip_find
= FALSE
;
1031 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1033 if (sorted_symcount
< 1)
1035 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1036 objdump_print_value (vma
, inf
, skip_zeroes
);
1038 if (display_file_offsets
)
1039 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1040 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1044 if (aux
->reloc
!= NULL
1045 && aux
->reloc
->sym_ptr_ptr
!= NULL
1046 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1048 sym
= * aux
->reloc
->sym_ptr_ptr
;
1050 /* Adjust the vma to the reloc. */
1051 vma
+= bfd_asymbol_value (sym
);
1053 if (bfd_is_und_section (bfd_get_section (sym
)))
1058 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1060 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1064 /* Print VMA to INFO. This function is passed to the disassembler
1068 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1070 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1073 /* Determine if the given address has a symbol associated with it. */
1076 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1080 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1082 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1085 /* Hold the last function name and the last line number we displayed
1086 in a disassembly. */
1088 static char *prev_functionname
;
1089 static unsigned int prev_line
;
1090 static unsigned int prev_discriminator
;
1092 /* We keep a list of all files that we have seen when doing a
1093 disassembly with source, so that we know how much of the file to
1094 display. This can be important for inlined functions. */
1096 struct print_file_list
1098 struct print_file_list
*next
;
1099 const char *filename
;
1100 const char *modname
;
1103 const char **linemap
;
1109 static struct print_file_list
*print_files
;
1111 /* The number of preceding context lines to show when we start
1112 displaying a file for the first time. */
1114 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1116 /* Read a complete file into memory. */
1119 slurp_file (const char *fn
, size_t *size
)
1122 int ps
= getpagesize ();
1127 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1131 if (fstat (fd
, &st
) < 0)
1138 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1139 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1140 if (map
!= (char *) -1L)
1146 map
= (const char *) malloc (*size
);
1147 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1149 free ((void *) map
);
1156 #define line_map_decrease 5
1158 /* Precompute array of lines for a mapped file. */
1160 static const char **
1161 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1163 const char *p
, *lstart
, *end
;
1164 int chars_per_line
= 45; /* First iteration will use 40. */
1165 unsigned int lineno
;
1166 const char **linemap
= NULL
;
1167 unsigned long line_map_size
= 0;
1173 for (p
= map
; p
< end
; p
++)
1177 if (p
+ 1 < end
&& p
[1] == '\r')
1180 else if (*p
== '\r')
1182 if (p
+ 1 < end
&& p
[1] == '\n')
1188 /* End of line found. */
1190 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1192 unsigned long newsize
;
1194 chars_per_line
-= line_map_decrease
;
1195 if (chars_per_line
<= 1)
1197 line_map_size
= size
/ chars_per_line
+ 1;
1198 if (line_map_size
< lineno
+ 1)
1199 line_map_size
= lineno
+ 1;
1200 newsize
= line_map_size
* sizeof (char *);
1201 linemap
= (const char **) xrealloc (linemap
, newsize
);
1204 linemap
[lineno
++] = lstart
;
1212 /* Tries to open MODNAME, and if successful adds a node to print_files
1213 linked list and returns that node. Returns NULL on failure. */
1215 static struct print_file_list
*
1216 try_print_file_open (const char *origname
, const char *modname
)
1218 struct print_file_list
*p
;
1220 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1222 p
->map
= slurp_file (modname
, &p
->mapsize
);
1229 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1231 p
->filename
= origname
;
1232 p
->modname
= modname
;
1233 p
->next
= print_files
;
1239 /* If the source file, as described in the symtab, is not found
1240 try to locate it in one of the paths specified with -I
1241 If found, add location to print_files linked list. */
1243 static struct print_file_list
*
1244 update_source_path (const char *filename
)
1246 struct print_file_list
*p
;
1250 p
= try_print_file_open (filename
, filename
);
1254 if (include_path_count
== 0)
1257 /* Get the name of the file. */
1258 fname
= lbasename (filename
);
1260 /* If file exists under a new path, we need to add it to the list
1261 so that show_line knows about it. */
1262 for (i
= 0; i
< include_path_count
; i
++)
1264 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1266 p
= try_print_file_open (filename
, modname
);
1276 /* Print a source file line. */
1279 print_line (struct print_file_list
*p
, unsigned int linenum
)
1285 if (linenum
>= p
->maxline
)
1287 l
= p
->linemap
[linenum
];
1288 /* Test fwrite return value to quiet glibc warning. */
1289 len
= strcspn (l
, "\n\r");
1290 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1294 /* Print a range of source code lines. */
1297 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1301 while (start
<= end
)
1303 print_line (p
, start
);
1308 /* Show the line number, or the source line, in a disassembly
1312 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1314 const char *filename
;
1315 const char *functionname
;
1316 unsigned int linenumber
;
1317 unsigned int discriminator
;
1320 if (! with_line_numbers
&& ! with_source_code
)
1323 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1324 &filename
, &functionname
,
1325 &linenumber
, &discriminator
))
1328 if (filename
!= NULL
&& *filename
== '\0')
1330 if (functionname
!= NULL
&& *functionname
== '\0')
1331 functionname
= NULL
;
1334 && IS_ABSOLUTE_PATH (filename
)
1338 const char *fname
= filename
;
1339 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1342 memcpy (path
, prefix
, prefix_length
);
1343 path_up
= path
+ prefix_length
;
1345 /* Build relocated filename, stripping off leading directories
1346 from the initial filename if requested. */
1347 if (prefix_strip
> 0)
1352 /* Skip selected directory levels. */
1353 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1354 if (IS_DIR_SEPARATOR(*s
))
1361 /* Update complete filename. */
1362 strncpy (path_up
, fname
, PATH_MAX
);
1363 path_up
[PATH_MAX
] = '\0';
1371 if (with_line_numbers
)
1373 if (functionname
!= NULL
1374 && (prev_functionname
== NULL
1375 || strcmp (functionname
, prev_functionname
) != 0))
1376 printf ("%s():\n", functionname
);
1377 if (linenumber
> 0 && (linenumber
!= prev_line
||
1378 (discriminator
!= prev_discriminator
)))
1380 if (discriminator
> 0)
1381 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1382 linenumber
, discriminator
);
1384 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1388 if (with_source_code
1392 struct print_file_list
**pp
, *p
;
1395 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1396 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1403 filename
= xstrdup (filename
);
1404 p
= update_source_path (filename
);
1407 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1409 if (file_start_context
&& p
->first
)
1413 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1414 if (l
>= linenumber
)
1416 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1417 l
= p
->last_line
+ 1;
1419 dump_lines (p
, l
, linenumber
);
1420 p
->last_line
= linenumber
;
1425 if (functionname
!= NULL
1426 && (prev_functionname
== NULL
1427 || strcmp (functionname
, prev_functionname
) != 0))
1429 if (prev_functionname
!= NULL
)
1430 free (prev_functionname
);
1431 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1432 strcpy (prev_functionname
, functionname
);
1435 if (linenumber
> 0 && linenumber
!= prev_line
)
1436 prev_line
= linenumber
;
1438 if (discriminator
!= prev_discriminator
)
1439 prev_discriminator
= discriminator
;
1442 /* Pseudo FILE object for strings. */
1450 /* sprintf to a "stream". */
1452 static int ATTRIBUTE_PRINTF_2
1453 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1460 size_t space
= f
->alloc
- f
->pos
;
1462 va_start (args
, format
);
1463 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1469 f
->alloc
= (f
->alloc
+ n
) * 2;
1470 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1477 /* The number of zeroes we want to see before we start skipping them.
1478 The number is arbitrarily chosen. */
1480 #define DEFAULT_SKIP_ZEROES 8
1482 /* The number of zeroes to skip at the end of a section. If the
1483 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1484 SKIP_ZEROES, they will be disassembled. If there are fewer than
1485 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1486 attempt to avoid disassembling zeroes inserted by section
1489 #define DEFAULT_SKIP_ZEROES_AT_END 3
1491 /* Disassemble some data in memory between given values. */
1494 disassemble_bytes (struct disassemble_info
* inf
,
1495 disassembler_ftype disassemble_fn
,
1498 bfd_vma start_offset
,
1499 bfd_vma stop_offset
,
1502 arelent
** relppend
)
1504 struct objdump_disasm_info
*aux
;
1506 int octets_per_line
;
1507 int skip_addr_chars
;
1508 bfd_vma addr_offset
;
1509 unsigned int opb
= inf
->octets_per_byte
;
1510 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1511 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1515 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1519 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1523 octets_per_line
= insn_width
;
1525 octets_per_line
= 4;
1527 octets_per_line
= 16;
1529 /* Figure out how many characters to skip at the start of an
1530 address, to make the disassembly look nicer. We discard leading
1531 zeroes in chunks of 4, ensuring that there is always a leading
1533 skip_addr_chars
= 0;
1534 if (! prefix_addresses
)
1538 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1540 while (buf
[skip_addr_chars
] == '0')
1543 /* Don't discard zeros on overflow. */
1544 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1545 skip_addr_chars
= 0;
1547 if (skip_addr_chars
!= 0)
1548 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1551 inf
->insn_info_valid
= 0;
1553 addr_offset
= start_offset
;
1554 while (addr_offset
< stop_offset
)
1557 bfd_boolean need_nl
= FALSE
;
1558 int previous_octets
;
1560 /* Remember the length of the previous instruction. */
1561 previous_octets
= octets
;
1564 /* Make sure we don't use relocs from previous instructions. */
1567 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1569 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1572 if (! disassemble_zeroes
1573 && (inf
->insn_info_valid
== 0
1574 || inf
->branch_delay_insns
== 0)
1575 && (z
- addr_offset
* opb
>= skip_zeroes
1576 || (z
== stop_offset
* opb
&&
1577 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1579 /* If there are more nonzero octets to follow, we only skip
1580 zeroes in multiples of 4, to try to avoid running over
1581 the start of an instruction which happens to start with
1583 if (z
!= stop_offset
* opb
)
1584 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1586 octets
= z
- addr_offset
* opb
;
1588 /* If we are going to display more data, and we are displaying
1589 file offsets, then tell the user how many zeroes we skip
1590 and the file offset from where we resume dumping. */
1591 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1592 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1594 (unsigned long) (section
->filepos
1595 + (addr_offset
+ (octets
/ opb
))));
1605 if (with_line_numbers
|| with_source_code
)
1606 show_line (aux
->abfd
, section
, addr_offset
);
1608 if (! prefix_addresses
)
1612 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1613 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1617 printf ("%s:\t", buf
+ skip_addr_chars
);
1621 aux
->require_sec
= TRUE
;
1622 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1623 aux
->require_sec
= FALSE
;
1630 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1631 inf
->stream
= &sfile
;
1632 inf
->bytes_per_line
= 0;
1633 inf
->bytes_per_chunk
= 0;
1634 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1636 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1638 if (inf
->disassembler_needs_relocs
1639 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1640 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1641 && *relppp
< relppend
)
1643 bfd_signed_vma distance_to_rel
;
1645 distance_to_rel
= (**relppp
)->address
1646 - (rel_offset
+ addr_offset
);
1648 /* Check to see if the current reloc is associated with
1649 the instruction that we are about to disassemble. */
1650 if (distance_to_rel
== 0
1651 /* FIXME: This is wrong. We are trying to catch
1652 relocs that are addressed part way through the
1653 current instruction, as might happen with a packed
1654 VLIW instruction. Unfortunately we do not know the
1655 length of the current instruction since we have not
1656 disassembled it yet. Instead we take a guess based
1657 upon the length of the previous instruction. The
1658 proper solution is to have a new target-specific
1659 disassembler function which just returns the length
1660 of an instruction at a given address without trying
1661 to display its disassembly. */
1662 || (distance_to_rel
> 0
1663 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1665 inf
->flags
|= INSN_HAS_RELOC
;
1666 aux
->reloc
= **relppp
;
1670 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1671 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1672 inf
->stream
= stdout
;
1673 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1674 octets_per_line
= inf
->bytes_per_line
;
1675 if (octets
< (int) opb
)
1678 printf ("%s\n", sfile
.buffer
);
1681 non_fatal (_("disassemble_fn returned length %d"),
1692 octets
= octets_per_line
;
1693 if (addr_offset
+ octets
/ opb
> stop_offset
)
1694 octets
= (stop_offset
- addr_offset
) * opb
;
1696 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1698 if (ISPRINT (data
[j
]))
1699 buf
[j
- addr_offset
* opb
] = data
[j
];
1701 buf
[j
- addr_offset
* opb
] = '.';
1703 buf
[j
- addr_offset
* opb
] = '\0';
1706 if (prefix_addresses
1708 : show_raw_insn
>= 0)
1712 /* If ! prefix_addresses and ! wide_output, we print
1713 octets_per_line octets per line. */
1715 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1716 pb
= octets_per_line
;
1718 if (inf
->bytes_per_chunk
)
1719 bpc
= inf
->bytes_per_chunk
;
1723 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1727 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1729 for (k
= bpc
- 1; k
>= 0; k
--)
1730 printf ("%02x", (unsigned) data
[j
+ k
]);
1735 for (k
= 0; k
< bpc
; k
++)
1736 printf ("%02x", (unsigned) data
[j
+ k
]);
1741 for (; pb
< octets_per_line
; pb
+= bpc
)
1745 for (k
= 0; k
< bpc
; k
++)
1750 /* Separate raw data from instruction by extra space. */
1760 printf ("%s", sfile
.buffer
);
1762 if (prefix_addresses
1764 : show_raw_insn
>= 0)
1772 j
= addr_offset
* opb
+ pb
;
1774 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1775 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1779 printf ("%s:\t", buf
+ skip_addr_chars
);
1781 pb
+= octets_per_line
;
1784 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1788 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1790 for (k
= bpc
- 1; k
>= 0; k
--)
1791 printf ("%02x", (unsigned) data
[j
+ k
]);
1796 for (k
= 0; k
< bpc
; k
++)
1797 printf ("%02x", (unsigned) data
[j
+ k
]);
1810 while ((*relppp
) < relppend
1811 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1813 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1824 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1827 if (q
->howto
== NULL
)
1828 printf (": *unknown*\t");
1829 else if (q
->howto
->name
)
1830 printf (": %s\t", q
->howto
->name
);
1832 printf (": %d\t", q
->howto
->type
);
1834 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1835 printf ("*unknown*");
1838 const char *sym_name
;
1840 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1841 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1842 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1847 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1848 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1849 if (sym_name
== NULL
|| *sym_name
== '\0')
1850 sym_name
= "*unknown*";
1851 printf ("%s", sym_name
);
1857 bfd_signed_vma addend
= q
->addend
;
1865 objdump_print_value (addend
, inf
, TRUE
);
1877 addr_offset
+= octets
/ opb
;
1880 free (sfile
.buffer
);
1884 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1886 const struct elf_backend_data
* bed
;
1887 bfd_vma sign_adjust
= 0;
1888 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1889 struct objdump_disasm_info
* paux
;
1890 unsigned int opb
= pinfo
->octets_per_byte
;
1891 bfd_byte
* data
= NULL
;
1892 bfd_size_type datasize
= 0;
1893 arelent
** rel_pp
= NULL
;
1894 arelent
** rel_ppstart
= NULL
;
1895 arelent
** rel_ppend
;
1896 unsigned long stop_offset
;
1897 asymbol
* sym
= NULL
;
1901 unsigned long addr_offset
;
1903 /* Sections that do not contain machine
1904 code are not normally disassembled. */
1905 if (! disassemble_all
1906 && only_list
== NULL
1907 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1908 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1911 if (! process_section_p (section
))
1914 datasize
= bfd_get_section_size (section
);
1918 /* Decide which set of relocs to use. Load them if necessary. */
1919 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1920 if (paux
->dynrelbuf
)
1922 rel_pp
= paux
->dynrelbuf
;
1923 rel_count
= paux
->dynrelcount
;
1924 /* Dynamic reloc addresses are absolute, non-dynamic are section
1925 relative. REL_OFFSET specifies the reloc address corresponding
1926 to the start of this section. */
1927 rel_offset
= section
->vma
;
1935 if ((section
->flags
& SEC_RELOC
) != 0
1936 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1940 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1942 bfd_fatal (bfd_get_filename (abfd
));
1946 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1947 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1949 bfd_fatal (bfd_get_filename (abfd
));
1951 /* Sort the relocs by address. */
1952 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1956 rel_ppend
= rel_pp
+ rel_count
;
1958 data
= (bfd_byte
*) xmalloc (datasize
);
1960 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1962 paux
->sec
= section
;
1963 pinfo
->buffer
= data
;
1964 pinfo
->buffer_vma
= section
->vma
;
1965 pinfo
->buffer_length
= datasize
;
1966 pinfo
->section
= section
;
1968 if (start_address
== (bfd_vma
) -1
1969 || start_address
< pinfo
->buffer_vma
)
1972 addr_offset
= start_address
- pinfo
->buffer_vma
;
1974 if (stop_address
== (bfd_vma
) -1)
1975 stop_offset
= datasize
/ opb
;
1978 if (stop_address
< pinfo
->buffer_vma
)
1981 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1982 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1983 stop_offset
= pinfo
->buffer_length
/ opb
;
1986 /* Skip over the relocs belonging to addresses below the
1988 while (rel_pp
< rel_ppend
1989 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1992 if (addr_offset
< stop_offset
)
1993 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1995 /* Find the nearest symbol forwards from our current position. */
1996 paux
->require_sec
= TRUE
;
1997 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1998 (struct disassemble_info
*) inf
,
2000 paux
->require_sec
= FALSE
;
2002 /* PR 9774: If the target used signed addresses then we must make
2003 sure that we sign extend the value that we calculate for 'addr'
2004 in the loop below. */
2005 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2006 && (bed
= get_elf_backend_data (abfd
)) != NULL
2007 && bed
->sign_extend_vma
)
2008 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2010 /* Disassemble a block of instructions up to the address associated with
2011 the symbol we have just found. Then print the symbol and find the
2012 next symbol on. Repeat until we have disassembled the entire section
2013 or we have reached the end of the address range we are interested in. */
2014 while (addr_offset
< stop_offset
)
2018 unsigned long nextstop_offset
;
2021 addr
= section
->vma
+ addr_offset
;
2022 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2024 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2029 (x
< sorted_symcount
2030 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2034 pinfo
->symbols
= sorted_syms
+ place
;
2035 pinfo
->num_symbols
= x
- place
;
2036 pinfo
->symtab_pos
= place
;
2040 pinfo
->symbols
= NULL
;
2041 pinfo
->num_symbols
= 0;
2042 pinfo
->symtab_pos
= -1;
2045 if (! prefix_addresses
)
2047 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2048 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2050 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2053 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2055 else if (sym
== NULL
)
2059 #define is_valid_next_sym(SYM) \
2060 ((SYM)->section == section \
2061 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2062 && pinfo->symbol_is_valid (SYM, pinfo))
2064 /* Search forward for the next appropriate symbol in
2065 SECTION. Note that all the symbols are sorted
2066 together into one big array, and that some sections
2067 may have overlapping addresses. */
2068 while (place
< sorted_symcount
2069 && ! is_valid_next_sym (sorted_syms
[place
]))
2072 if (place
>= sorted_symcount
)
2075 nextsym
= sorted_syms
[place
];
2078 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2079 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2080 else if (nextsym
== NULL
)
2081 nextstop_offset
= stop_offset
;
2083 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2085 if (nextstop_offset
> stop_offset
2086 || nextstop_offset
<= addr_offset
)
2087 nextstop_offset
= stop_offset
;
2089 /* If a symbol is explicitly marked as being an object
2090 rather than a function, just dump the bytes without
2091 disassembling them. */
2094 || sym
->section
!= section
2095 || bfd_asymbol_value (sym
) > addr
2096 || ((sym
->flags
& BSF_OBJECT
) == 0
2097 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2099 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2101 || (sym
->flags
& BSF_FUNCTION
) != 0)
2106 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2107 addr_offset
, nextstop_offset
,
2108 rel_offset
, &rel_pp
, rel_ppend
);
2110 addr_offset
= nextstop_offset
;
2116 if (rel_ppstart
!= NULL
)
2120 /* Disassemble the contents of an object file. */
2123 disassemble_data (bfd
*abfd
)
2125 struct disassemble_info disasm_info
;
2126 struct objdump_disasm_info aux
;
2130 prev_functionname
= NULL
;
2132 prev_discriminator
= 0;
2134 /* We make a copy of syms to sort. We don't want to sort syms
2135 because that will screw up the relocs. */
2136 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2137 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2138 * sizeof (asymbol
*));
2139 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2140 sorted_symcount
* sizeof (asymbol
*));
2142 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2144 for (i
= 0; i
< synthcount
; ++i
)
2146 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2150 /* Sort the symbols into section and symbol order. */
2151 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2153 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2155 disasm_info
.application_data
= (void *) &aux
;
2157 aux
.require_sec
= FALSE
;
2158 aux
.dynrelbuf
= NULL
;
2159 aux
.dynrelcount
= 0;
2162 disasm_info
.print_address_func
= objdump_print_address
;
2163 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2165 if (machine
!= NULL
)
2167 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2170 fatal (_("can't use supplied machine %s"), machine
);
2172 abfd
->arch_info
= inf
;
2175 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2177 struct bfd_target
*xvec
;
2179 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2180 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2181 xvec
->byteorder
= endian
;
2185 /* Use libopcodes to locate a suitable disassembler. */
2186 aux
.disassemble_fn
= disassembler (abfd
);
2187 if (!aux
.disassemble_fn
)
2189 non_fatal (_("can't disassemble for architecture %s\n"),
2190 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2195 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2196 disasm_info
.arch
= bfd_get_arch (abfd
);
2197 disasm_info
.mach
= bfd_get_mach (abfd
);
2198 disasm_info
.disassembler_options
= disassembler_options
;
2199 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2200 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2201 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2202 disasm_info
.disassembler_needs_relocs
= FALSE
;
2204 if (bfd_big_endian (abfd
))
2205 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2206 else if (bfd_little_endian (abfd
))
2207 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2209 /* ??? Aborting here seems too drastic. We could default to big or little
2211 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2213 /* Allow the target to customize the info structure. */
2214 disassemble_init_for_target (& disasm_info
);
2216 /* Pre-load the dynamic relocs if we are going
2217 to be dumping them along with the disassembly. */
2218 if (dump_dynamic_reloc_info
)
2220 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2223 bfd_fatal (bfd_get_filename (abfd
));
2227 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2228 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2231 if (aux
.dynrelcount
< 0)
2232 bfd_fatal (bfd_get_filename (abfd
));
2234 /* Sort the relocs by address. */
2235 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2239 disasm_info
.symtab
= sorted_syms
;
2240 disasm_info
.symtab_size
= sorted_symcount
;
2242 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2244 if (aux
.dynrelbuf
!= NULL
)
2245 free (aux
.dynrelbuf
);
2250 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2251 asection
*sec
, void *file
)
2253 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2254 bfd
*abfd
= (bfd
*) file
;
2257 /* If it is already loaded, do nothing. */
2258 if (section
->start
!= NULL
)
2261 section
->address
= 0;
2262 section
->size
= bfd_get_section_size (sec
);
2263 section
->start
= NULL
;
2264 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2268 free_debug_section (debug
);
2269 printf (_("\nCan't get contents for section '%s'.\n"),
2274 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2276 bfd_cache_section_contents (sec
, section
->start
);
2278 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2285 free_debug_section (debug
);
2286 printf (_("\nCan't get contents for section '%s'.\n"),
2296 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2298 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2299 bfd
*abfd
= (bfd
*) file
;
2302 /* If it is already loaded, do nothing. */
2303 if (section
->start
!= NULL
)
2306 /* Locate the debug section. */
2307 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2309 section
->name
= section
->uncompressed_name
;
2312 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2314 section
->name
= section
->compressed_name
;
2319 return load_specific_debug_section (debug
, sec
, file
);
2323 free_debug_section (enum dwarf_section_display_enum debug
)
2325 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2327 if (section
->start
== NULL
)
2330 free ((char *) section
->start
);
2331 section
->start
= NULL
;
2332 section
->address
= 0;
2337 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2338 void *arg ATTRIBUTE_UNUSED
)
2340 const char *name
= bfd_get_section_name (abfd
, section
);
2344 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2345 match
= ".debug_info";
2349 for (i
= 0; i
< max
; i
++)
2350 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2351 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2352 && debug_displays
[i
].enabled
!= NULL
2353 && *debug_displays
[i
].enabled
)
2355 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2357 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2358 sec
->name
= sec
->uncompressed_name
;
2360 sec
->name
= sec
->compressed_name
;
2361 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2364 debug_displays
[i
].display (sec
, abfd
);
2366 if (i
!= info
&& i
!= abbrev
)
2367 free_debug_section ((enum dwarf_section_display_enum
) i
);
2373 /* Dump the dwarf debugging information. */
2376 dump_dwarf (bfd
*abfd
)
2378 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2380 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2382 if (bfd_big_endian (abfd
))
2383 byte_get
= byte_get_big_endian
;
2384 else if (bfd_little_endian (abfd
))
2385 byte_get
= byte_get_little_endian
;
2389 switch (bfd_get_arch (abfd
))
2392 switch (bfd_get_mach (abfd
))
2394 case bfd_mach_x86_64
:
2395 case bfd_mach_x86_64_intel_syntax
:
2396 case bfd_mach_x64_32
:
2397 case bfd_mach_x64_32_intel_syntax
:
2398 init_dwarf_regnames_x86_64 ();
2402 init_dwarf_regnames_i386 ();
2411 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2413 free_debug_memory ();
2416 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2417 it. Return NULL on failure. */
2420 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2426 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2427 if (stabsect
== NULL
)
2429 printf (_("No %s section present\n\n"), sect_name
);
2433 size
= bfd_section_size (abfd
, stabsect
);
2434 contents
= (char *) xmalloc (size
);
2436 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2438 non_fatal (_("reading %s section of %s failed: %s"),
2439 sect_name
, bfd_get_filename (abfd
),
2440 bfd_errmsg (bfd_get_error ()));
2451 /* Stabs entries use a 12 byte format:
2452 4 byte string table index
2454 1 byte stab other field
2455 2 byte stab desc field
2457 FIXME: This will have to change for a 64 bit object format. */
2459 #define STRDXOFF (0)
2461 #define OTHEROFF (5)
2464 #define STABSIZE (12)
2466 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2467 using string table section STRSECT_NAME (in `strtab'). */
2470 print_section_stabs (bfd
*abfd
,
2471 const char *stabsect_name
,
2472 unsigned *string_offset_ptr
)
2475 unsigned file_string_table_offset
= 0;
2476 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2477 bfd_byte
*stabp
, *stabs_end
;
2480 stabs_end
= stabp
+ stab_size
;
2482 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2483 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2485 /* Loop through all symbols and print them.
2487 We start the index at -1 because there is a dummy symbol on
2488 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2489 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2493 unsigned char type
, other
;
2494 unsigned short desc
;
2497 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2498 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2499 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2500 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2501 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2503 printf ("\n%-6d ", i
);
2504 /* Either print the stab name, or, if unnamed, print its number
2505 again (makes consistent formatting for tools like awk). */
2506 name
= bfd_get_stab_name (type
);
2508 printf ("%-6s", name
);
2509 else if (type
== N_UNDF
)
2512 printf ("%-6d", type
);
2513 printf (" %-6d %-6d ", other
, desc
);
2514 bfd_printf_vma (abfd
, value
);
2515 printf (" %-6lu", strx
);
2517 /* Symbols with type == 0 (N_UNDF) specify the length of the
2518 string table associated with this file. We use that info
2519 to know how to relocate the *next* file's string table indices. */
2522 file_string_table_offset
= next_file_string_table_offset
;
2523 next_file_string_table_offset
+= value
;
2527 /* Using the (possibly updated) string table offset, print the
2528 string (if any) associated with this symbol. */
2529 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2530 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2536 *string_offset_ptr
= next_file_string_table_offset
;
2541 const char * section_name
;
2542 const char * string_section_name
;
2543 unsigned string_offset
;
2548 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2551 stab_section_names
* sought
= (stab_section_names
*) names
;
2553 /* Check for section names for which stabsect_name is a prefix, to
2554 handle .stab.N, etc. */
2555 len
= strlen (sought
->section_name
);
2557 /* If the prefix matches, and the files section name ends with a
2558 nul or a digit, then we match. I.e., we want either an exact
2559 match or a section followed by a number. */
2560 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2561 && (section
->name
[len
] == 0
2562 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2565 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2570 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2573 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2579 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2581 stab_section_names s
;
2583 s
.section_name
= stabsect_name
;
2584 s
.string_section_name
= strsect_name
;
2585 s
.string_offset
= 0;
2587 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2593 /* Dump the any sections containing stabs debugging information. */
2596 dump_stabs (bfd
*abfd
)
2598 dump_stabs_section (abfd
, ".stab", ".stabstr");
2599 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2600 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2603 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2605 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2609 dump_bfd_header (bfd
*abfd
)
2613 printf (_("architecture: %s, "),
2614 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2615 bfd_get_mach (abfd
)));
2616 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2618 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2619 PF (HAS_RELOC
, "HAS_RELOC");
2620 PF (EXEC_P
, "EXEC_P");
2621 PF (HAS_LINENO
, "HAS_LINENO");
2622 PF (HAS_DEBUG
, "HAS_DEBUG");
2623 PF (HAS_SYMS
, "HAS_SYMS");
2624 PF (HAS_LOCALS
, "HAS_LOCALS");
2625 PF (DYNAMIC
, "DYNAMIC");
2626 PF (WP_TEXT
, "WP_TEXT");
2627 PF (D_PAGED
, "D_PAGED");
2628 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2629 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2630 printf (_("\nstart address 0x"));
2631 bfd_printf_vma (abfd
, abfd
->start_address
);
2637 dump_bfd_private_header (bfd
*abfd
)
2639 bfd_print_private_bfd_data (abfd
, stdout
);
2643 dump_target_specific (bfd
*abfd
)
2645 const struct objdump_private_desc
* const *desc
;
2646 struct objdump_private_option
*opt
;
2649 /* Find the desc. */
2650 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2651 if ((*desc
)->filter (abfd
))
2656 non_fatal (_("option -P/--private not supported by this file"));
2660 /* Clear all options. */
2661 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2662 opt
->selected
= FALSE
;
2664 /* Decode options. */
2665 b
= dump_private_options
;
2668 e
= strchr (b
, ',');
2673 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2674 if (strcmp (opt
->name
, b
) == 0)
2676 opt
->selected
= TRUE
;
2679 if (opt
->name
== NULL
)
2680 non_fatal (_("target specific dump '%s' not supported"), b
);
2691 (*desc
)->dump (abfd
);
2694 /* Display a section in hexadecimal format with associated characters.
2695 Each line prefixed by the zero padded address. */
2698 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2701 bfd_size_type datasize
;
2702 bfd_size_type addr_offset
;
2703 bfd_size_type start_offset
;
2704 bfd_size_type stop_offset
;
2705 unsigned int opb
= bfd_octets_per_byte (abfd
);
2706 /* Bytes per line. */
2707 const int onaline
= 16;
2712 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2715 if (! process_section_p (section
))
2718 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2721 /* Compute the address range to display. */
2722 if (start_address
== (bfd_vma
) -1
2723 || start_address
< section
->vma
)
2726 start_offset
= start_address
- section
->vma
;
2728 if (stop_address
== (bfd_vma
) -1)
2729 stop_offset
= datasize
/ opb
;
2732 if (stop_address
< section
->vma
)
2735 stop_offset
= stop_address
- section
->vma
;
2737 if (stop_offset
> datasize
/ opb
)
2738 stop_offset
= datasize
/ opb
;
2741 if (start_offset
>= stop_offset
)
2744 printf (_("Contents of section %s:"), section
->name
);
2745 if (display_file_offsets
)
2746 printf (_(" (Starting at file offset: 0x%lx)"),
2747 (unsigned long) (section
->filepos
+ start_offset
));
2750 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2752 non_fatal (_("Reading section failed"));
2758 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2759 if (strlen (buf
) >= sizeof (buf
))
2763 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2765 count
= strlen (buf
) - count
;
2769 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2770 if (strlen (buf
) >= sizeof (buf
))
2774 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2776 count
= strlen (buf
) - count
;
2780 for (addr_offset
= start_offset
;
2781 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2785 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2786 count
= strlen (buf
);
2787 if ((size_t) count
>= sizeof (buf
))
2791 while (count
< width
)
2796 fputs (buf
+ count
- width
, stdout
);
2799 for (j
= addr_offset
* opb
;
2800 j
< addr_offset
* opb
+ onaline
; j
++)
2802 if (j
< stop_offset
* opb
)
2803 printf ("%02x", (unsigned) (data
[j
]));
2811 for (j
= addr_offset
* opb
;
2812 j
< addr_offset
* opb
+ onaline
; j
++)
2814 if (j
>= stop_offset
* opb
)
2817 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2824 /* Actually display the various requested regions. */
2827 dump_data (bfd
*abfd
)
2829 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2832 /* Should perhaps share code and display with nm? */
2835 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2844 max_count
= dynsymcount
;
2845 printf ("DYNAMIC SYMBOL TABLE:\n");
2850 max_count
= symcount
;
2851 printf ("SYMBOL TABLE:\n");
2855 printf (_("no symbols\n"));
2857 for (count
= 0; count
< max_count
; count
++)
2861 if (*current
== NULL
)
2862 printf (_("no information for symbol number %ld\n"), count
);
2864 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2865 printf (_("could not determine the type of symbol number %ld\n"),
2868 else if (process_section_p ((* current
)->section
)
2869 && (dump_special_syms
2870 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2872 const char *name
= (*current
)->name
;
2874 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2878 /* If we want to demangle the name, we demangle it
2879 here, and temporarily clobber it while calling
2880 bfd_print_symbol. FIXME: This is a gross hack. */
2881 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2883 (*current
)->name
= alloc
;
2884 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2885 bfd_print_symbol_all
);
2888 (*current
)->name
= name
;
2893 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2894 bfd_print_symbol_all
);
2904 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2907 char *last_filename
, *last_functionname
;
2908 unsigned int last_line
;
2909 unsigned int last_discriminator
;
2911 /* Get column headers lined up reasonably. */
2919 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2920 width
= strlen (buf
) - 7;
2922 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2925 last_filename
= NULL
;
2926 last_functionname
= NULL
;
2928 last_discriminator
= 0;
2930 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2933 const char *filename
, *functionname
;
2934 unsigned int linenumber
;
2935 unsigned int discriminator
;
2936 const char *sym_name
;
2937 const char *section_name
;
2938 bfd_vma addend2
= 0;
2940 if (start_address
!= (bfd_vma
) -1
2941 && q
->address
< start_address
)
2943 if (stop_address
!= (bfd_vma
) -1
2944 && q
->address
> stop_address
)
2947 if (with_line_numbers
2949 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
2950 &filename
, &functionname
,
2951 &linenumber
, &discriminator
))
2953 if (functionname
!= NULL
2954 && (last_functionname
== NULL
2955 || strcmp (functionname
, last_functionname
) != 0))
2957 printf ("%s():\n", functionname
);
2958 if (last_functionname
!= NULL
)
2959 free (last_functionname
);
2960 last_functionname
= xstrdup (functionname
);
2964 && (linenumber
!= last_line
2965 || (filename
!= NULL
2966 && last_filename
!= NULL
2967 && filename_cmp (filename
, last_filename
) != 0)
2968 || (discriminator
!= last_discriminator
)))
2970 if (discriminator
> 0)
2971 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2973 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
2974 linenumber
, discriminator
);
2975 last_line
= linenumber
;
2976 last_discriminator
= discriminator
;
2977 if (last_filename
!= NULL
)
2978 free (last_filename
);
2979 if (filename
== NULL
)
2980 last_filename
= NULL
;
2982 last_filename
= xstrdup (filename
);
2986 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2988 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2989 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2994 section_name
= NULL
;
2997 bfd_printf_vma (abfd
, q
->address
);
2998 if (q
->howto
== NULL
)
2999 printf (" *unknown* ");
3000 else if (q
->howto
->name
)
3002 const char *name
= q
->howto
->name
;
3004 /* R_SPARC_OLO10 relocations contain two addends.
3005 But because 'arelent' lacks enough storage to
3006 store them both, the 64-bit ELF Sparc backend
3007 records this as two relocations. One R_SPARC_LO10
3008 and one R_SPARC_13, both pointing to the same
3009 address. This is merely so that we have some
3010 place to store both addend fields.
3012 Undo this transformation, otherwise the output
3013 will be confusing. */
3014 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3015 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3017 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3019 arelent
*q2
= *(p
+ 1);
3022 && q
->address
== q2
->address
3023 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3025 name
= "R_SPARC_OLO10";
3026 addend2
= q2
->addend
;
3030 printf (" %-16s ", name
);
3033 printf (" %-16d ", q
->howto
->type
);
3037 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3041 if (section_name
== NULL
)
3042 section_name
= "*unknown*";
3043 printf ("[%s]", section_name
);
3048 bfd_signed_vma addend
= q
->addend
;
3056 bfd_printf_vma (abfd
, addend
);
3061 bfd_printf_vma (abfd
, addend2
);
3067 if (last_filename
!= NULL
)
3068 free (last_filename
);
3069 if (last_functionname
!= NULL
)
3070 free (last_functionname
);
3074 dump_relocs_in_section (bfd
*abfd
,
3076 void *dummy ATTRIBUTE_UNUSED
)
3082 if ( bfd_is_abs_section (section
)
3083 || bfd_is_und_section (section
)
3084 || bfd_is_com_section (section
)
3085 || (! process_section_p (section
))
3086 || ((section
->flags
& SEC_RELOC
) == 0))
3089 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3091 bfd_fatal (bfd_get_filename (abfd
));
3093 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3097 printf (" (none)\n\n");
3101 relpp
= (arelent
**) xmalloc (relsize
);
3102 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3105 bfd_fatal (bfd_get_filename (abfd
));
3106 else if (relcount
== 0)
3107 printf (" (none)\n\n");
3111 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3118 dump_relocs (bfd
*abfd
)
3120 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3124 dump_dynamic_relocs (bfd
*abfd
)
3130 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3132 bfd_fatal (bfd_get_filename (abfd
));
3134 printf ("DYNAMIC RELOCATION RECORDS");
3137 printf (" (none)\n\n");
3140 relpp
= (arelent
**) xmalloc (relsize
);
3141 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3144 bfd_fatal (bfd_get_filename (abfd
));
3145 else if (relcount
== 0)
3146 printf (" (none)\n\n");
3150 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3157 /* Creates a table of paths, to search for source files. */
3160 add_include_path (const char *path
)
3164 include_path_count
++;
3165 include_paths
= (const char **)
3166 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3167 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3168 if (path
[1] == ':' && path
[2] == 0)
3169 path
= concat (path
, ".", (const char *) 0);
3171 include_paths
[include_path_count
- 1] = path
;
3175 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3179 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3181 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3182 section
->vma
+= adjust_section_vma
;
3184 section
->lma
+= adjust_section_vma
;
3188 /* Dump selected contents of ABFD. */
3191 dump_bfd (bfd
*abfd
)
3193 /* If we are adjusting section VMA's, change them all now. Changing
3194 the BFD information is a hack. However, we must do it, or
3195 bfd_find_nearest_line will not do the right thing. */
3196 if (adjust_section_vma
!= 0)
3198 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3199 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3202 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3203 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3206 print_arelt_descr (stdout
, abfd
, TRUE
);
3207 if (dump_file_header
)
3208 dump_bfd_header (abfd
);
3209 if (dump_private_headers
)
3210 dump_bfd_private_header (abfd
);
3211 if (dump_private_options
!= NULL
)
3212 dump_target_specific (abfd
);
3213 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3220 || dump_dwarf_section_info
)
3221 syms
= slurp_symtab (abfd
);
3223 if (dump_section_headers
)
3224 dump_headers (abfd
);
3226 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3227 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3228 dynsyms
= slurp_dynamic_symtab (abfd
);
3231 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3232 dynsymcount
, dynsyms
, &synthsyms
);
3238 dump_symbols (abfd
, FALSE
);
3239 if (dump_dynamic_symtab
)
3240 dump_symbols (abfd
, TRUE
);
3241 if (dump_dwarf_section_info
)
3243 if (dump_stab_section_info
)
3245 if (dump_reloc_info
&& ! disassemble
)
3247 if (dump_dynamic_reloc_info
&& ! disassemble
)
3248 dump_dynamic_relocs (abfd
);
3249 if (dump_section_contents
)
3252 disassemble_data (abfd
);
3258 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3259 if (dhandle
!= NULL
)
3261 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3263 dump_debugging_tags
? TRUE
: FALSE
))
3265 non_fatal (_("%s: printing debugging information failed"),
3266 bfd_get_filename (abfd
));
3270 /* PR 6483: If there was no STABS or IEEE debug
3271 info in the file, try DWARF instead. */
3272 else if (! dump_dwarf_section_info
)
3274 dwarf_select_sections_all ();
3303 display_object_bfd (bfd
*abfd
)
3307 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3313 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3315 nonfatal (bfd_get_filename (abfd
));
3316 list_matching_formats (matching
);
3321 if (bfd_get_error () != bfd_error_file_not_recognized
)
3323 nonfatal (bfd_get_filename (abfd
));
3327 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3333 nonfatal (bfd_get_filename (abfd
));
3335 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3337 list_matching_formats (matching
);
3343 display_any_bfd (bfd
*file
, int level
)
3345 /* Decompress sections unless dumping the section contents. */
3346 if (!dump_section_contents
)
3347 file
->flags
|= BFD_DECOMPRESS
;
3349 /* If the file is an archive, process all of its elements. */
3350 if (bfd_check_format (file
, bfd_archive
))
3353 bfd
*last_arfile
= NULL
;
3356 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3358 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3362 bfd_set_error (bfd_error_no_error
);
3364 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3367 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3368 nonfatal (bfd_get_filename (file
));
3372 display_any_bfd (arfile
, level
+ 1);
3374 if (last_arfile
!= NULL
)
3375 bfd_close (last_arfile
);
3376 last_arfile
= arfile
;
3379 if (last_arfile
!= NULL
)
3380 bfd_close (last_arfile
);
3383 display_object_bfd (file
);
3387 display_file (char *filename
, char *target
)
3391 if (get_file_size (filename
) < 1)
3397 file
= bfd_openr (filename
, target
);
3400 nonfatal (filename
);
3404 display_any_bfd (file
, 0);
3410 main (int argc
, char **argv
)
3413 char *target
= default_target
;
3414 bfd_boolean seenflag
= FALSE
;
3416 #if defined (HAVE_SETLOCALE)
3417 #if defined (HAVE_LC_MESSAGES)
3418 setlocale (LC_MESSAGES
, "");
3420 setlocale (LC_CTYPE
, "");
3423 bindtextdomain (PACKAGE
, LOCALEDIR
);
3424 textdomain (PACKAGE
);
3426 program_name
= *argv
;
3427 xmalloc_set_program_name (program_name
);
3429 START_PROGRESS (program_name
, 0);
3431 expandargv (&argc
, &argv
);
3434 set_default_bfd_target ();
3436 while ((c
= getopt_long (argc
, argv
,
3437 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3438 long_options
, (int *) 0))
3444 break; /* We've been given a long option. */
3449 if (disassembler_options
)
3450 /* Ignore potential memory leak for now. */
3451 disassembler_options
= concat (disassembler_options
, ",",
3452 optarg
, (const char *) NULL
);
3454 disassembler_options
= optarg
;
3460 display_file_offsets
= TRUE
;
3463 with_line_numbers
= TRUE
;
3472 enum demangling_styles style
;
3474 style
= cplus_demangle_name_to_style (optarg
);
3475 if (style
== unknown_demangling
)
3476 fatal (_("unknown demangling style `%s'"),
3479 cplus_demangle_set_style (style
);
3485 case OPTION_ADJUST_VMA
:
3486 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3488 case OPTION_START_ADDRESS
:
3489 start_address
= parse_vma (optarg
, "--start-address");
3490 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3491 fatal (_("error: the start address should be before the end address"));
3493 case OPTION_STOP_ADDRESS
:
3494 stop_address
= parse_vma (optarg
, "--stop-address");
3495 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3496 fatal (_("error: the stop address should be after the start address"));
3500 prefix_length
= strlen (prefix
);
3501 /* Remove an unnecessary trailing '/' */
3502 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3505 case OPTION_PREFIX_STRIP
:
3506 prefix_strip
= atoi (optarg
);
3507 if (prefix_strip
< 0)
3508 fatal (_("error: prefix strip must be non-negative"));
3510 case OPTION_INSN_WIDTH
:
3511 insn_width
= strtoul (optarg
, NULL
, 0);
3512 if (insn_width
<= 0)
3513 fatal (_("error: instruction width must be positive"));
3516 if (strcmp (optarg
, "B") == 0)
3517 endian
= BFD_ENDIAN_BIG
;
3518 else if (strcmp (optarg
, "L") == 0)
3519 endian
= BFD_ENDIAN_LITTLE
;
3522 nonfatal (_("unrecognized -E option"));
3527 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3528 endian
= BFD_ENDIAN_BIG
;
3529 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3530 endian
= BFD_ENDIAN_LITTLE
;
3533 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3540 dump_file_header
= TRUE
;
3544 formats_info
= TRUE
;
3548 add_include_path (optarg
);
3551 dump_private_headers
= TRUE
;
3555 dump_private_options
= optarg
;
3559 dump_private_headers
= TRUE
;
3561 dump_reloc_info
= TRUE
;
3562 dump_file_header
= TRUE
;
3563 dump_ar_hdrs
= TRUE
;
3564 dump_section_headers
= TRUE
;
3572 dump_dynamic_symtab
= TRUE
;
3580 disassemble_zeroes
= TRUE
;
3584 disassemble_all
= TRUE
;
3589 with_source_code
= TRUE
;
3598 dump_debugging_tags
= 1;
3603 dump_dwarf_section_info
= TRUE
;
3606 dwarf_select_sections_by_letters (optarg
);
3608 dwarf_select_sections_all ();
3611 dump_dwarf_section_info
= TRUE
;
3614 dwarf_select_sections_by_names (optarg
);
3616 dwarf_select_sections_all ();
3618 case OPTION_DWARF_DEPTH
:
3621 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3624 case OPTION_DWARF_START
:
3627 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3628 suppress_bfd_header
= 1;
3631 case OPTION_DWARF_CHECK
:
3635 dump_stab_section_info
= TRUE
;
3639 dump_section_contents
= TRUE
;
3643 dump_reloc_info
= TRUE
;
3647 dump_dynamic_reloc_info
= TRUE
;
3651 dump_ar_hdrs
= TRUE
;
3655 dump_section_headers
= TRUE
;
3663 show_version
= TRUE
;
3673 print_version ("objdump");
3679 exit_status
= display_info ();
3683 display_file ("a.out", target
);
3685 for (; optind
< argc
;)
3686 display_file (argv
[optind
++], target
);
3691 END_PROGRESS (program_name
);