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\
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
);
565 bfd_fatal (bfd_get_filename (abfd
));
567 sy
= (asymbol
**) xmalloc (storage
);
569 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
571 bfd_fatal (bfd_get_filename (abfd
));
575 /* Read in the dynamic symbols. */
578 slurp_dynamic_symtab (bfd
*abfd
)
583 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
586 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
588 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
594 bfd_fatal (bfd_get_filename (abfd
));
597 sy
= (asymbol
**) xmalloc (storage
);
599 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
601 bfd_fatal (bfd_get_filename (abfd
));
605 /* Filter out (in place) symbols that are useless for disassembly.
606 COUNT is the number of elements in SYMBOLS.
607 Return the number of useful symbols. */
610 remove_useless_symbols (asymbol
**symbols
, long count
)
612 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
616 asymbol
*sym
= *in_ptr
++;
618 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
620 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
622 if (bfd_is_und_section (sym
->section
)
623 || bfd_is_com_section (sym
->section
))
628 return out_ptr
- symbols
;
631 /* Sort symbols into value order. */
634 compare_symbols (const void *ap
, const void *bp
)
636 const asymbol
*a
= * (const asymbol
**) ap
;
637 const asymbol
*b
= * (const asymbol
**) bp
;
647 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
649 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
652 if (a
->section
> b
->section
)
654 else if (a
->section
< b
->section
)
657 an
= bfd_asymbol_name (a
);
658 bn
= bfd_asymbol_name (b
);
662 /* The symbols gnu_compiled and gcc2_compiled convey no real
663 information, so put them after other symbols with the same value. */
664 af
= (strstr (an
, "gnu_compiled") != NULL
665 || strstr (an
, "gcc2_compiled") != NULL
);
666 bf
= (strstr (bn
, "gnu_compiled") != NULL
667 || strstr (bn
, "gcc2_compiled") != NULL
);
674 /* We use a heuristic for the file name, to try to sort it after
675 more useful symbols. It may not work on non Unix systems, but it
676 doesn't really matter; the only difference is precisely which
677 symbol names get printed. */
679 #define file_symbol(s, sn, snl) \
680 (((s)->flags & BSF_FILE) != 0 \
681 || ((sn)[(snl) - 2] == '.' \
682 && ((sn)[(snl) - 1] == 'o' \
683 || (sn)[(snl) - 1] == 'a')))
685 af
= file_symbol (a
, an
, anl
);
686 bf
= file_symbol (b
, bn
, bnl
);
693 /* Try to sort global symbols before local symbols before function
694 symbols before debugging symbols. */
699 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
701 if ((aflags
& BSF_DEBUGGING
) != 0)
706 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
708 if ((aflags
& BSF_FUNCTION
) != 0)
713 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
715 if ((aflags
& BSF_LOCAL
) != 0)
720 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
722 if ((aflags
& BSF_GLOBAL
) != 0)
728 /* Symbols that start with '.' might be section names, so sort them
729 after symbols that don't start with '.'. */
730 if (an
[0] == '.' && bn
[0] != '.')
732 if (an
[0] != '.' && bn
[0] == '.')
735 /* Finally, if we can't distinguish them in any other way, try to
736 get consistent results by sorting the symbols by name. */
737 return strcmp (an
, bn
);
740 /* Sort relocs into address order. */
743 compare_relocs (const void *ap
, const void *bp
)
745 const arelent
*a
= * (const arelent
**) ap
;
746 const arelent
*b
= * (const arelent
**) bp
;
748 if (a
->address
> b
->address
)
750 else if (a
->address
< b
->address
)
753 /* So that associated relocations tied to the same address show up
754 in the correct order, we don't do any further sorting. */
763 /* Print an address (VMA) to the output stream in INFO.
764 If SKIP_ZEROES is TRUE, omit leading zeroes. */
767 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
768 bfd_boolean skip_zeroes
)
772 struct objdump_disasm_info
*aux
;
774 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
775 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
780 for (p
= buf
; *p
== '0'; ++p
)
785 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
788 /* Print the name of a symbol. */
791 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
798 name
= bfd_asymbol_name (sym
);
799 if (do_demangle
&& name
[0] != '\0')
801 /* Demangle the name. */
802 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
808 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
816 /* Locate a symbol given a bfd and a section (from INFO->application_data),
817 and a VMA. If INFO->application_data->require_sec is TRUE, then always
818 require the symbol to be in the section. Returns NULL if there is no
819 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
820 of the symbol in sorted_syms. */
823 find_symbol_for_address (bfd_vma vma
,
824 struct disassemble_info
*inf
,
827 /* @@ Would it speed things up to cache the last two symbols returned,
828 and maybe their address ranges? For many processors, only one memory
829 operand can be present at a time, so the 2-entry cache wouldn't be
830 constantly churned by code doing heavy memory accesses. */
832 /* Indices in `sorted_syms'. */
834 long max_count
= sorted_symcount
;
836 struct objdump_disasm_info
*aux
;
840 bfd_boolean want_section
;
842 if (sorted_symcount
< 1)
845 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
848 opb
= inf
->octets_per_byte
;
850 /* Perform a binary search looking for the closest symbol to the
851 required value. We are searching the range (min, max_count]. */
852 while (min
+ 1 < max_count
)
856 thisplace
= (max_count
+ min
) / 2;
857 sym
= sorted_syms
[thisplace
];
859 if (bfd_asymbol_value (sym
) > vma
)
860 max_count
= thisplace
;
861 else if (bfd_asymbol_value (sym
) < vma
)
870 /* The symbol we want is now in min, the low end of the range we
871 were searching. If there are several symbols with the same
872 value, we want the first one. */
875 && (bfd_asymbol_value (sorted_syms
[thisplace
])
876 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
879 /* Prefer a symbol in the current section if we have multple symbols
880 with the same value, as can occur with overlays or zero size
883 while (min
< max_count
884 && (bfd_asymbol_value (sorted_syms
[min
])
885 == bfd_asymbol_value (sorted_syms
[thisplace
])))
887 if (sorted_syms
[min
]->section
== sec
888 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
895 return sorted_syms
[thisplace
];
900 /* If the file is relocatable, and the symbol could be from this
901 section, prefer a symbol from this section over symbols from
902 others, even if the other symbol's value might be closer.
904 Note that this may be wrong for some symbol references if the
905 sections have overlapping memory ranges, but in that case there's
906 no way to tell what's desired without looking at the relocation
909 Also give the target a chance to reject symbols. */
910 want_section
= (aux
->require_sec
911 || ((abfd
->flags
& HAS_RELOC
) != 0
912 && vma
>= bfd_get_section_vma (abfd
, sec
)
913 && vma
< (bfd_get_section_vma (abfd
, sec
)
914 + bfd_section_size (abfd
, sec
) / opb
)));
915 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
916 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
919 long newplace
= sorted_symcount
;
921 for (i
= min
- 1; i
>= 0; i
--)
923 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
924 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
926 if (newplace
== sorted_symcount
)
929 if (bfd_asymbol_value (sorted_syms
[i
])
930 != bfd_asymbol_value (sorted_syms
[newplace
]))
933 /* Remember this symbol and keep searching until we reach
934 an earlier address. */
939 if (newplace
!= sorted_symcount
)
940 thisplace
= newplace
;
943 /* We didn't find a good symbol with a smaller value.
944 Look for one with a larger value. */
945 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
947 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
948 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
956 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
957 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
958 /* There is no suitable symbol. */
965 return sorted_syms
[thisplace
];
968 /* Print an address and the offset to the nearest symbol. */
971 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
972 bfd_vma vma
, struct disassemble_info
*inf
,
973 bfd_boolean skip_zeroes
)
975 objdump_print_value (vma
, inf
, skip_zeroes
);
981 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
982 bfd_get_section_name (abfd
, sec
));
983 secaddr
= bfd_get_section_vma (abfd
, sec
);
986 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
987 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
989 else if (vma
> secaddr
)
991 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
992 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
994 (*inf
->fprintf_func
) (inf
->stream
, ">");
998 (*inf
->fprintf_func
) (inf
->stream
, " <");
999 objdump_print_symname (abfd
, inf
, sym
);
1000 if (bfd_asymbol_value (sym
) > vma
)
1002 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1003 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1005 else if (vma
> bfd_asymbol_value (sym
))
1007 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1008 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1010 (*inf
->fprintf_func
) (inf
->stream
, ">");
1013 if (display_file_offsets
)
1014 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1015 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1018 /* Print an address (VMA), symbolically if possible.
1019 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1022 objdump_print_addr (bfd_vma vma
,
1023 struct disassemble_info
*inf
,
1024 bfd_boolean skip_zeroes
)
1026 struct objdump_disasm_info
*aux
;
1027 asymbol
*sym
= NULL
;
1028 bfd_boolean skip_find
= FALSE
;
1030 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1032 if (sorted_symcount
< 1)
1034 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1035 objdump_print_value (vma
, inf
, skip_zeroes
);
1037 if (display_file_offsets
)
1038 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1039 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1043 if (aux
->reloc
!= NULL
1044 && aux
->reloc
->sym_ptr_ptr
!= NULL
1045 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1047 sym
= * aux
->reloc
->sym_ptr_ptr
;
1049 /* Adjust the vma to the reloc. */
1050 vma
+= bfd_asymbol_value (sym
);
1052 if (bfd_is_und_section (bfd_get_section (sym
)))
1057 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1059 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1063 /* Print VMA to INFO. This function is passed to the disassembler
1067 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1069 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1072 /* Determine if the given address has a symbol associated with it. */
1075 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1079 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1081 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1084 /* Hold the last function name and the last line number we displayed
1085 in a disassembly. */
1087 static char *prev_functionname
;
1088 static unsigned int prev_line
;
1089 static unsigned int prev_discriminator
;
1091 /* We keep a list of all files that we have seen when doing a
1092 disassembly with source, so that we know how much of the file to
1093 display. This can be important for inlined functions. */
1095 struct print_file_list
1097 struct print_file_list
*next
;
1098 const char *filename
;
1099 const char *modname
;
1102 const char **linemap
;
1108 static struct print_file_list
*print_files
;
1110 /* The number of preceding context lines to show when we start
1111 displaying a file for the first time. */
1113 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1115 /* Read a complete file into memory. */
1118 slurp_file (const char *fn
, size_t *size
)
1121 int ps
= getpagesize ();
1126 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1130 if (fstat (fd
, &st
) < 0)
1137 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1138 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1139 if (map
!= (char *) -1L)
1145 map
= (const char *) malloc (*size
);
1146 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1148 free ((void *) map
);
1155 #define line_map_decrease 5
1157 /* Precompute array of lines for a mapped file. */
1159 static const char **
1160 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1162 const char *p
, *lstart
, *end
;
1163 int chars_per_line
= 45; /* First iteration will use 40. */
1164 unsigned int lineno
;
1165 const char **linemap
= NULL
;
1166 unsigned long line_map_size
= 0;
1172 for (p
= map
; p
< end
; p
++)
1176 if (p
+ 1 < end
&& p
[1] == '\r')
1179 else if (*p
== '\r')
1181 if (p
+ 1 < end
&& p
[1] == '\n')
1187 /* End of line found. */
1189 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1191 unsigned long newsize
;
1193 chars_per_line
-= line_map_decrease
;
1194 if (chars_per_line
<= 1)
1196 line_map_size
= size
/ chars_per_line
+ 1;
1197 if (line_map_size
< lineno
+ 1)
1198 line_map_size
= lineno
+ 1;
1199 newsize
= line_map_size
* sizeof (char *);
1200 linemap
= (const char **) xrealloc (linemap
, newsize
);
1203 linemap
[lineno
++] = lstart
;
1211 /* Tries to open MODNAME, and if successful adds a node to print_files
1212 linked list and returns that node. Returns NULL on failure. */
1214 static struct print_file_list
*
1215 try_print_file_open (const char *origname
, const char *modname
)
1217 struct print_file_list
*p
;
1219 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1221 p
->map
= slurp_file (modname
, &p
->mapsize
);
1228 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1230 p
->filename
= origname
;
1231 p
->modname
= modname
;
1232 p
->next
= print_files
;
1238 /* If the the source file, as described in the symtab, is not found
1239 try to locate it in one of the paths specified with -I
1240 If found, add location to print_files linked list. */
1242 static struct print_file_list
*
1243 update_source_path (const char *filename
)
1245 struct print_file_list
*p
;
1249 p
= try_print_file_open (filename
, filename
);
1253 if (include_path_count
== 0)
1256 /* Get the name of the file. */
1257 fname
= lbasename (filename
);
1259 /* If file exists under a new path, we need to add it to the list
1260 so that show_line knows about it. */
1261 for (i
= 0; i
< include_path_count
; i
++)
1263 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1265 p
= try_print_file_open (filename
, modname
);
1275 /* Print a source file line. */
1278 print_line (struct print_file_list
*p
, unsigned int linenum
)
1284 if (linenum
>= p
->maxline
)
1286 l
= p
->linemap
[linenum
];
1287 /* Test fwrite return value to quiet glibc warning. */
1288 len
= strcspn (l
, "\n\r");
1289 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1293 /* Print a range of source code lines. */
1296 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1300 while (start
<= end
)
1302 print_line (p
, start
);
1307 /* Show the line number, or the source line, in a disassembly
1311 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1313 const char *filename
;
1314 const char *functionname
;
1315 unsigned int linenumber
;
1316 unsigned int discriminator
;
1319 if (! with_line_numbers
&& ! with_source_code
)
1322 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1323 &filename
, &functionname
,
1324 &linenumber
, &discriminator
))
1327 if (filename
!= NULL
&& *filename
== '\0')
1329 if (functionname
!= NULL
&& *functionname
== '\0')
1330 functionname
= NULL
;
1333 && IS_ABSOLUTE_PATH (filename
)
1337 const char *fname
= filename
;
1338 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1341 memcpy (path
, prefix
, prefix_length
);
1342 path_up
= path
+ prefix_length
;
1344 /* Build relocated filename, stripping off leading directories
1345 from the initial filename if requested. */
1346 if (prefix_strip
> 0)
1351 /* Skip selected directory levels. */
1352 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1353 if (IS_DIR_SEPARATOR(*s
))
1360 /* Update complete filename. */
1361 strncpy (path_up
, fname
, PATH_MAX
);
1362 path_up
[PATH_MAX
] = '\0';
1370 if (with_line_numbers
)
1372 if (functionname
!= NULL
1373 && (prev_functionname
== NULL
1374 || strcmp (functionname
, prev_functionname
) != 0))
1375 printf ("%s():\n", functionname
);
1376 if (linenumber
> 0 && (linenumber
!= prev_line
||
1377 (discriminator
!= prev_discriminator
)))
1379 if (discriminator
> 0)
1380 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1381 linenumber
, discriminator
);
1383 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1387 if (with_source_code
1391 struct print_file_list
**pp
, *p
;
1394 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1395 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1402 filename
= xstrdup (filename
);
1403 p
= update_source_path (filename
);
1406 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1408 if (file_start_context
&& p
->first
)
1412 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1413 if (l
>= linenumber
)
1415 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1416 l
= p
->last_line
+ 1;
1418 dump_lines (p
, l
, linenumber
);
1419 p
->last_line
= linenumber
;
1424 if (functionname
!= NULL
1425 && (prev_functionname
== NULL
1426 || strcmp (functionname
, prev_functionname
) != 0))
1428 if (prev_functionname
!= NULL
)
1429 free (prev_functionname
);
1430 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1431 strcpy (prev_functionname
, functionname
);
1434 if (linenumber
> 0 && linenumber
!= prev_line
)
1435 prev_line
= linenumber
;
1437 if (discriminator
!= prev_discriminator
)
1438 prev_discriminator
= discriminator
;
1441 /* Pseudo FILE object for strings. */
1449 /* sprintf to a "stream". */
1451 static int ATTRIBUTE_PRINTF_2
1452 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1459 size_t space
= f
->alloc
- f
->pos
;
1461 va_start (args
, format
);
1462 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1468 f
->alloc
= (f
->alloc
+ n
) * 2;
1469 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1476 /* The number of zeroes we want to see before we start skipping them.
1477 The number is arbitrarily chosen. */
1479 #define DEFAULT_SKIP_ZEROES 8
1481 /* The number of zeroes to skip at the end of a section. If the
1482 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1483 SKIP_ZEROES, they will be disassembled. If there are fewer than
1484 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1485 attempt to avoid disassembling zeroes inserted by section
1488 #define DEFAULT_SKIP_ZEROES_AT_END 3
1490 /* Disassemble some data in memory between given values. */
1493 disassemble_bytes (struct disassemble_info
* inf
,
1494 disassembler_ftype disassemble_fn
,
1497 bfd_vma start_offset
,
1498 bfd_vma stop_offset
,
1501 arelent
** relppend
)
1503 struct objdump_disasm_info
*aux
;
1505 int octets_per_line
;
1506 int skip_addr_chars
;
1507 bfd_vma addr_offset
;
1508 unsigned int opb
= inf
->octets_per_byte
;
1509 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1510 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1514 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1518 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1522 octets_per_line
= insn_width
;
1524 octets_per_line
= 4;
1526 octets_per_line
= 16;
1528 /* Figure out how many characters to skip at the start of an
1529 address, to make the disassembly look nicer. We discard leading
1530 zeroes in chunks of 4, ensuring that there is always a leading
1532 skip_addr_chars
= 0;
1533 if (! prefix_addresses
)
1537 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1539 while (buf
[skip_addr_chars
] == '0')
1542 /* Don't discard zeros on overflow. */
1543 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1544 skip_addr_chars
= 0;
1546 if (skip_addr_chars
!= 0)
1547 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1550 inf
->insn_info_valid
= 0;
1552 addr_offset
= start_offset
;
1553 while (addr_offset
< stop_offset
)
1556 bfd_boolean need_nl
= FALSE
;
1557 int previous_octets
;
1559 /* Remember the length of the previous instruction. */
1560 previous_octets
= octets
;
1563 /* Make sure we don't use relocs from previous instructions. */
1566 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1568 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1571 if (! disassemble_zeroes
1572 && (inf
->insn_info_valid
== 0
1573 || inf
->branch_delay_insns
== 0)
1574 && (z
- addr_offset
* opb
>= skip_zeroes
1575 || (z
== stop_offset
* opb
&&
1576 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1578 /* If there are more nonzero octets to follow, we only skip
1579 zeroes in multiples of 4, to try to avoid running over
1580 the start of an instruction which happens to start with
1582 if (z
!= stop_offset
* opb
)
1583 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1585 octets
= z
- addr_offset
* opb
;
1587 /* If we are going to display more data, and we are displaying
1588 file offsets, then tell the user how many zeroes we skip
1589 and the file offset from where we resume dumping. */
1590 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1591 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1593 (unsigned long) (section
->filepos
1594 + (addr_offset
+ (octets
/ opb
))));
1604 if (with_line_numbers
|| with_source_code
)
1605 show_line (aux
->abfd
, section
, addr_offset
);
1607 if (! prefix_addresses
)
1611 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1612 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1616 printf ("%s:\t", buf
+ skip_addr_chars
);
1620 aux
->require_sec
= TRUE
;
1621 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1622 aux
->require_sec
= FALSE
;
1629 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1630 inf
->stream
= &sfile
;
1631 inf
->bytes_per_line
= 0;
1632 inf
->bytes_per_chunk
= 0;
1633 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1635 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1637 if (inf
->disassembler_needs_relocs
1638 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1639 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1640 && *relppp
< relppend
)
1642 bfd_signed_vma distance_to_rel
;
1644 distance_to_rel
= (**relppp
)->address
1645 - (rel_offset
+ addr_offset
);
1647 /* Check to see if the current reloc is associated with
1648 the instruction that we are about to disassemble. */
1649 if (distance_to_rel
== 0
1650 /* FIXME: This is wrong. We are trying to catch
1651 relocs that are addressed part way through the
1652 current instruction, as might happen with a packed
1653 VLIW instruction. Unfortunately we do not know the
1654 length of the current instruction since we have not
1655 disassembled it yet. Instead we take a guess based
1656 upon the length of the previous instruction. The
1657 proper solution is to have a new target-specific
1658 disassembler function which just returns the length
1659 of an instruction at a given address without trying
1660 to display its disassembly. */
1661 || (distance_to_rel
> 0
1662 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1664 inf
->flags
|= INSN_HAS_RELOC
;
1665 aux
->reloc
= **relppp
;
1669 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1670 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1671 inf
->stream
= stdout
;
1672 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1673 octets_per_line
= inf
->bytes_per_line
;
1674 if (octets
< (int) opb
)
1677 printf ("%s\n", sfile
.buffer
);
1680 non_fatal (_("disassemble_fn returned length %d"),
1691 octets
= octets_per_line
;
1692 if (addr_offset
+ octets
/ opb
> stop_offset
)
1693 octets
= (stop_offset
- addr_offset
) * opb
;
1695 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1697 if (ISPRINT (data
[j
]))
1698 buf
[j
- addr_offset
* opb
] = data
[j
];
1700 buf
[j
- addr_offset
* opb
] = '.';
1702 buf
[j
- addr_offset
* opb
] = '\0';
1705 if (prefix_addresses
1707 : show_raw_insn
>= 0)
1711 /* If ! prefix_addresses and ! wide_output, we print
1712 octets_per_line octets per line. */
1714 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1715 pb
= octets_per_line
;
1717 if (inf
->bytes_per_chunk
)
1718 bpc
= inf
->bytes_per_chunk
;
1722 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1726 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1728 for (k
= bpc
- 1; k
>= 0; k
--)
1729 printf ("%02x", (unsigned) data
[j
+ k
]);
1734 for (k
= 0; k
< bpc
; k
++)
1735 printf ("%02x", (unsigned) data
[j
+ k
]);
1740 for (; pb
< octets_per_line
; pb
+= bpc
)
1744 for (k
= 0; k
< bpc
; k
++)
1749 /* Separate raw data from instruction by extra space. */
1759 printf ("%s", sfile
.buffer
);
1761 if (prefix_addresses
1763 : show_raw_insn
>= 0)
1771 j
= addr_offset
* opb
+ pb
;
1773 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1774 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1778 printf ("%s:\t", buf
+ skip_addr_chars
);
1780 pb
+= octets_per_line
;
1783 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1787 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1789 for (k
= bpc
- 1; k
>= 0; k
--)
1790 printf ("%02x", (unsigned) data
[j
+ k
]);
1795 for (k
= 0; k
< bpc
; k
++)
1796 printf ("%02x", (unsigned) data
[j
+ k
]);
1809 while ((*relppp
) < relppend
1810 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1812 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1823 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1826 if (q
->howto
== NULL
)
1827 printf (": *unknown*\t");
1828 else if (q
->howto
->name
)
1829 printf (": %s\t", q
->howto
->name
);
1831 printf (": %d\t", q
->howto
->type
);
1833 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1834 printf ("*unknown*");
1837 const char *sym_name
;
1839 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1840 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1841 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1846 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1847 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1848 if (sym_name
== NULL
|| *sym_name
== '\0')
1849 sym_name
= "*unknown*";
1850 printf ("%s", sym_name
);
1856 bfd_signed_vma addend
= q
->addend
;
1864 objdump_print_value (addend
, inf
, TRUE
);
1876 addr_offset
+= octets
/ opb
;
1879 free (sfile
.buffer
);
1883 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1885 const struct elf_backend_data
* bed
;
1886 bfd_vma sign_adjust
= 0;
1887 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1888 struct objdump_disasm_info
* paux
;
1889 unsigned int opb
= pinfo
->octets_per_byte
;
1890 bfd_byte
* data
= NULL
;
1891 bfd_size_type datasize
= 0;
1892 arelent
** rel_pp
= NULL
;
1893 arelent
** rel_ppstart
= NULL
;
1894 arelent
** rel_ppend
;
1895 unsigned long stop_offset
;
1896 asymbol
* sym
= NULL
;
1900 unsigned long addr_offset
;
1902 /* Sections that do not contain machine
1903 code are not normally disassembled. */
1904 if (! disassemble_all
1905 && only_list
== NULL
1906 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1907 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1910 if (! process_section_p (section
))
1913 datasize
= bfd_get_section_size (section
);
1917 /* Decide which set of relocs to use. Load them if necessary. */
1918 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1919 if (paux
->dynrelbuf
)
1921 rel_pp
= paux
->dynrelbuf
;
1922 rel_count
= paux
->dynrelcount
;
1923 /* Dynamic reloc addresses are absolute, non-dynamic are section
1924 relative. REL_OFFSET specifies the reloc address corresponding
1925 to the start of this section. */
1926 rel_offset
= section
->vma
;
1934 if ((section
->flags
& SEC_RELOC
) != 0
1935 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1939 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1941 bfd_fatal (bfd_get_filename (abfd
));
1945 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1946 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1948 bfd_fatal (bfd_get_filename (abfd
));
1950 /* Sort the relocs by address. */
1951 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1955 rel_ppend
= rel_pp
+ rel_count
;
1957 data
= (bfd_byte
*) xmalloc (datasize
);
1959 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1961 paux
->sec
= section
;
1962 pinfo
->buffer
= data
;
1963 pinfo
->buffer_vma
= section
->vma
;
1964 pinfo
->buffer_length
= datasize
;
1965 pinfo
->section
= section
;
1967 if (start_address
== (bfd_vma
) -1
1968 || start_address
< pinfo
->buffer_vma
)
1971 addr_offset
= start_address
- pinfo
->buffer_vma
;
1973 if (stop_address
== (bfd_vma
) -1)
1974 stop_offset
= datasize
/ opb
;
1977 if (stop_address
< pinfo
->buffer_vma
)
1980 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1981 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1982 stop_offset
= pinfo
->buffer_length
/ opb
;
1985 /* Skip over the relocs belonging to addresses below the
1987 while (rel_pp
< rel_ppend
1988 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1991 if (addr_offset
< stop_offset
)
1992 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1994 /* Find the nearest symbol forwards from our current position. */
1995 paux
->require_sec
= TRUE
;
1996 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1997 (struct disassemble_info
*) inf
,
1999 paux
->require_sec
= FALSE
;
2001 /* PR 9774: If the target used signed addresses then we must make
2002 sure that we sign extend the value that we calculate for 'addr'
2003 in the loop below. */
2004 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2005 && (bed
= get_elf_backend_data (abfd
)) != NULL
2006 && bed
->sign_extend_vma
)
2007 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2009 /* Disassemble a block of instructions up to the address associated with
2010 the symbol we have just found. Then print the symbol and find the
2011 next symbol on. Repeat until we have disassembled the entire section
2012 or we have reached the end of the address range we are interested in. */
2013 while (addr_offset
< stop_offset
)
2017 unsigned long nextstop_offset
;
2020 addr
= section
->vma
+ addr_offset
;
2021 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2023 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2028 (x
< sorted_symcount
2029 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2033 pinfo
->symbols
= sorted_syms
+ place
;
2034 pinfo
->num_symbols
= x
- place
;
2035 pinfo
->symtab_pos
= place
;
2039 pinfo
->symbols
= NULL
;
2040 pinfo
->num_symbols
= 0;
2041 pinfo
->symtab_pos
= -1;
2044 if (! prefix_addresses
)
2046 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2047 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2049 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2052 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2054 else if (sym
== NULL
)
2058 #define is_valid_next_sym(SYM) \
2059 ((SYM)->section == section \
2060 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2061 && pinfo->symbol_is_valid (SYM, pinfo))
2063 /* Search forward for the next appropriate symbol in
2064 SECTION. Note that all the symbols are sorted
2065 together into one big array, and that some sections
2066 may have overlapping addresses. */
2067 while (place
< sorted_symcount
2068 && ! is_valid_next_sym (sorted_syms
[place
]))
2071 if (place
>= sorted_symcount
)
2074 nextsym
= sorted_syms
[place
];
2077 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2078 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2079 else if (nextsym
== NULL
)
2080 nextstop_offset
= stop_offset
;
2082 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2084 if (nextstop_offset
> stop_offset
2085 || nextstop_offset
<= addr_offset
)
2086 nextstop_offset
= stop_offset
;
2088 /* If a symbol is explicitly marked as being an object
2089 rather than a function, just dump the bytes without
2090 disassembling them. */
2093 || sym
->section
!= section
2094 || bfd_asymbol_value (sym
) > addr
2095 || ((sym
->flags
& BSF_OBJECT
) == 0
2096 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2098 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2100 || (sym
->flags
& BSF_FUNCTION
) != 0)
2105 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2106 addr_offset
, nextstop_offset
,
2107 rel_offset
, &rel_pp
, rel_ppend
);
2109 addr_offset
= nextstop_offset
;
2115 if (rel_ppstart
!= NULL
)
2119 /* Disassemble the contents of an object file. */
2122 disassemble_data (bfd
*abfd
)
2124 struct disassemble_info disasm_info
;
2125 struct objdump_disasm_info aux
;
2129 prev_functionname
= NULL
;
2131 prev_discriminator
= 0;
2133 /* We make a copy of syms to sort. We don't want to sort syms
2134 because that will screw up the relocs. */
2135 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2136 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2137 * sizeof (asymbol
*));
2138 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2139 sorted_symcount
* sizeof (asymbol
*));
2141 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2143 for (i
= 0; i
< synthcount
; ++i
)
2145 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2149 /* Sort the symbols into section and symbol order. */
2150 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2152 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2154 disasm_info
.application_data
= (void *) &aux
;
2156 aux
.require_sec
= FALSE
;
2157 aux
.dynrelbuf
= NULL
;
2158 aux
.dynrelcount
= 0;
2161 disasm_info
.print_address_func
= objdump_print_address
;
2162 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2164 if (machine
!= NULL
)
2166 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2169 fatal (_("can't use supplied machine %s"), machine
);
2171 abfd
->arch_info
= inf
;
2174 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2176 struct bfd_target
*xvec
;
2178 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2179 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2180 xvec
->byteorder
= endian
;
2184 /* Use libopcodes to locate a suitable disassembler. */
2185 aux
.disassemble_fn
= disassembler (abfd
);
2186 if (!aux
.disassemble_fn
)
2188 non_fatal (_("can't disassemble for architecture %s\n"),
2189 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2194 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2195 disasm_info
.arch
= bfd_get_arch (abfd
);
2196 disasm_info
.mach
= bfd_get_mach (abfd
);
2197 disasm_info
.disassembler_options
= disassembler_options
;
2198 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2199 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2200 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2201 disasm_info
.disassembler_needs_relocs
= FALSE
;
2203 if (bfd_big_endian (abfd
))
2204 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2205 else if (bfd_little_endian (abfd
))
2206 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2208 /* ??? Aborting here seems too drastic. We could default to big or little
2210 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2212 /* Allow the target to customize the info structure. */
2213 disassemble_init_for_target (& disasm_info
);
2215 /* Pre-load the dynamic relocs if we are going
2216 to be dumping them along with the disassembly. */
2217 if (dump_dynamic_reloc_info
)
2219 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2222 bfd_fatal (bfd_get_filename (abfd
));
2226 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2227 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2230 if (aux
.dynrelcount
< 0)
2231 bfd_fatal (bfd_get_filename (abfd
));
2233 /* Sort the relocs by address. */
2234 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2238 disasm_info
.symtab
= sorted_syms
;
2239 disasm_info
.symtab_size
= sorted_symcount
;
2241 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2243 if (aux
.dynrelbuf
!= NULL
)
2244 free (aux
.dynrelbuf
);
2249 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2250 asection
*sec
, void *file
)
2252 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2253 bfd
*abfd
= (bfd
*) file
;
2256 /* If it is already loaded, do nothing. */
2257 if (section
->start
!= NULL
)
2260 section
->address
= 0;
2261 section
->size
= bfd_get_section_size (sec
);
2262 section
->start
= NULL
;
2263 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2267 free_debug_section (debug
);
2268 printf (_("\nCan't get contents for section '%s'.\n"),
2273 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2275 /* We want to relocate the data we've already read (and
2276 decompressed), so we store a pointer to the data in
2277 the bfd_section, and tell it that the contents are
2278 already in memory. */
2279 sec
->contents
= section
->start
;
2280 sec
->flags
|= SEC_IN_MEMORY
;
2281 sec
->size
= section
->size
;
2283 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2290 free_debug_section (debug
);
2291 printf (_("\nCan't get contents for section '%s'.\n"),
2301 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2303 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2304 bfd
*abfd
= (bfd
*) file
;
2307 /* If it is already loaded, do nothing. */
2308 if (section
->start
!= NULL
)
2311 /* Locate the debug section. */
2312 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2314 section
->name
= section
->uncompressed_name
;
2317 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2319 section
->name
= section
->compressed_name
;
2324 return load_specific_debug_section (debug
, sec
, file
);
2328 free_debug_section (enum dwarf_section_display_enum debug
)
2330 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2332 if (section
->start
== NULL
)
2335 free ((char *) section
->start
);
2336 section
->start
= NULL
;
2337 section
->address
= 0;
2342 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2343 void *arg ATTRIBUTE_UNUSED
)
2345 const char *name
= bfd_get_section_name (abfd
, section
);
2349 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2350 match
= ".debug_info";
2354 for (i
= 0; i
< max
; i
++)
2355 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2356 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2357 && debug_displays
[i
].enabled
!= NULL
2358 && *debug_displays
[i
].enabled
)
2360 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2362 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2363 sec
->name
= sec
->uncompressed_name
;
2365 sec
->name
= sec
->compressed_name
;
2366 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2369 debug_displays
[i
].display (sec
, abfd
);
2371 if (i
!= info
&& i
!= abbrev
)
2372 free_debug_section ((enum dwarf_section_display_enum
) i
);
2378 /* Dump the dwarf debugging information. */
2381 dump_dwarf (bfd
*abfd
)
2383 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2385 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2387 if (bfd_big_endian (abfd
))
2388 byte_get
= byte_get_big_endian
;
2389 else if (bfd_little_endian (abfd
))
2390 byte_get
= byte_get_little_endian
;
2394 switch (bfd_get_arch (abfd
))
2397 switch (bfd_get_mach (abfd
))
2399 case bfd_mach_x86_64
:
2400 case bfd_mach_x86_64_intel_syntax
:
2401 init_dwarf_regnames_x86_64 ();
2405 init_dwarf_regnames_i386 ();
2414 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2416 free_debug_memory ();
2419 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2420 it. Return NULL on failure. */
2423 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2429 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2430 if (stabsect
== NULL
)
2432 printf (_("No %s section present\n\n"), sect_name
);
2436 size
= bfd_section_size (abfd
, stabsect
);
2437 contents
= (char *) xmalloc (size
);
2439 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2441 non_fatal (_("reading %s section of %s failed: %s"),
2442 sect_name
, bfd_get_filename (abfd
),
2443 bfd_errmsg (bfd_get_error ()));
2454 /* Stabs entries use a 12 byte format:
2455 4 byte string table index
2457 1 byte stab other field
2458 2 byte stab desc field
2460 FIXME: This will have to change for a 64 bit object format. */
2462 #define STRDXOFF (0)
2464 #define OTHEROFF (5)
2467 #define STABSIZE (12)
2469 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2470 using string table section STRSECT_NAME (in `strtab'). */
2473 print_section_stabs (bfd
*abfd
,
2474 const char *stabsect_name
,
2475 unsigned *string_offset_ptr
)
2478 unsigned file_string_table_offset
= 0;
2479 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2480 bfd_byte
*stabp
, *stabs_end
;
2483 stabs_end
= stabp
+ stab_size
;
2485 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2486 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2488 /* Loop through all symbols and print them.
2490 We start the index at -1 because there is a dummy symbol on
2491 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2492 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2496 unsigned char type
, other
;
2497 unsigned short desc
;
2500 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2501 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2502 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2503 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2504 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2506 printf ("\n%-6d ", i
);
2507 /* Either print the stab name, or, if unnamed, print its number
2508 again (makes consistent formatting for tools like awk). */
2509 name
= bfd_get_stab_name (type
);
2511 printf ("%-6s", name
);
2512 else if (type
== N_UNDF
)
2515 printf ("%-6d", type
);
2516 printf (" %-6d %-6d ", other
, desc
);
2517 bfd_printf_vma (abfd
, value
);
2518 printf (" %-6lu", strx
);
2520 /* Symbols with type == 0 (N_UNDF) specify the length of the
2521 string table associated with this file. We use that info
2522 to know how to relocate the *next* file's string table indices. */
2525 file_string_table_offset
= next_file_string_table_offset
;
2526 next_file_string_table_offset
+= value
;
2530 /* Using the (possibly updated) string table offset, print the
2531 string (if any) associated with this symbol. */
2532 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2533 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2539 *string_offset_ptr
= next_file_string_table_offset
;
2544 const char * section_name
;
2545 const char * string_section_name
;
2546 unsigned string_offset
;
2551 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2554 stab_section_names
* sought
= (stab_section_names
*) names
;
2556 /* Check for section names for which stabsect_name is a prefix, to
2557 handle .stab.N, etc. */
2558 len
= strlen (sought
->section_name
);
2560 /* If the prefix matches, and the files section name ends with a
2561 nul or a digit, then we match. I.e., we want either an exact
2562 match or a section followed by a number. */
2563 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2564 && (section
->name
[len
] == 0
2565 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2568 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2573 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2576 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2582 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2584 stab_section_names s
;
2586 s
.section_name
= stabsect_name
;
2587 s
.string_section_name
= strsect_name
;
2588 s
.string_offset
= 0;
2590 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2596 /* Dump the any sections containing stabs debugging information. */
2599 dump_stabs (bfd
*abfd
)
2601 dump_stabs_section (abfd
, ".stab", ".stabstr");
2602 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2603 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2606 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2608 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2612 dump_bfd_header (bfd
*abfd
)
2616 printf (_("architecture: %s, "),
2617 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2618 bfd_get_mach (abfd
)));
2619 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2621 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2622 PF (HAS_RELOC
, "HAS_RELOC");
2623 PF (EXEC_P
, "EXEC_P");
2624 PF (HAS_LINENO
, "HAS_LINENO");
2625 PF (HAS_DEBUG
, "HAS_DEBUG");
2626 PF (HAS_SYMS
, "HAS_SYMS");
2627 PF (HAS_LOCALS
, "HAS_LOCALS");
2628 PF (DYNAMIC
, "DYNAMIC");
2629 PF (WP_TEXT
, "WP_TEXT");
2630 PF (D_PAGED
, "D_PAGED");
2631 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2632 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2633 printf (_("\nstart address 0x"));
2634 bfd_printf_vma (abfd
, abfd
->start_address
);
2640 dump_bfd_private_header (bfd
*abfd
)
2642 bfd_print_private_bfd_data (abfd
, stdout
);
2646 dump_target_specific (bfd
*abfd
)
2648 const struct objdump_private_desc
* const *desc
;
2649 struct objdump_private_option
*opt
;
2652 /* Find the desc. */
2653 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2654 if ((*desc
)->filter (abfd
))
2659 non_fatal (_("option -P/--private not supported by this file"));
2663 /* Clear all options. */
2664 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2665 opt
->selected
= FALSE
;
2667 /* Decode options. */
2668 b
= dump_private_options
;
2671 e
= strchr (b
, ',');
2676 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2677 if (strcmp (opt
->name
, b
) == 0)
2679 opt
->selected
= TRUE
;
2682 if (opt
->name
== NULL
)
2683 non_fatal (_("target specific dump '%s' not supported"), b
);
2694 (*desc
)->dump (abfd
);
2697 /* Display a section in hexadecimal format with associated characters.
2698 Each line prefixed by the zero padded address. */
2701 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2704 bfd_size_type datasize
;
2705 bfd_size_type addr_offset
;
2706 bfd_size_type start_offset
;
2707 bfd_size_type stop_offset
;
2708 unsigned int opb
= bfd_octets_per_byte (abfd
);
2709 /* Bytes per line. */
2710 const int onaline
= 16;
2715 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2718 if (! process_section_p (section
))
2721 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2724 /* Compute the address range to display. */
2725 if (start_address
== (bfd_vma
) -1
2726 || start_address
< section
->vma
)
2729 start_offset
= start_address
- section
->vma
;
2731 if (stop_address
== (bfd_vma
) -1)
2732 stop_offset
= datasize
/ opb
;
2735 if (stop_address
< section
->vma
)
2738 stop_offset
= stop_address
- section
->vma
;
2740 if (stop_offset
> datasize
/ opb
)
2741 stop_offset
= datasize
/ opb
;
2744 if (start_offset
>= stop_offset
)
2747 printf (_("Contents of section %s:"), section
->name
);
2748 if (display_file_offsets
)
2749 printf (_(" (Starting at file offset: 0x%lx)"),
2750 (unsigned long) (section
->filepos
+ start_offset
));
2753 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2755 non_fatal (_("Reading section failed"));
2761 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2762 if (strlen (buf
) >= sizeof (buf
))
2766 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2768 count
= strlen (buf
) - count
;
2772 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2773 if (strlen (buf
) >= sizeof (buf
))
2777 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2779 count
= strlen (buf
) - count
;
2783 for (addr_offset
= start_offset
;
2784 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2788 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2789 count
= strlen (buf
);
2790 if ((size_t) count
>= sizeof (buf
))
2794 while (count
< width
)
2799 fputs (buf
+ count
- width
, stdout
);
2802 for (j
= addr_offset
* opb
;
2803 j
< addr_offset
* opb
+ onaline
; j
++)
2805 if (j
< stop_offset
* opb
)
2806 printf ("%02x", (unsigned) (data
[j
]));
2814 for (j
= addr_offset
* opb
;
2815 j
< addr_offset
* opb
+ onaline
; j
++)
2817 if (j
>= stop_offset
* opb
)
2820 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2827 /* Actually display the various requested regions. */
2830 dump_data (bfd
*abfd
)
2832 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2835 /* Should perhaps share code and display with nm? */
2838 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2847 max_count
= dynsymcount
;
2848 printf ("DYNAMIC SYMBOL TABLE:\n");
2853 max_count
= symcount
;
2854 printf ("SYMBOL TABLE:\n");
2858 printf (_("no symbols\n"));
2860 for (count
= 0; count
< max_count
; count
++)
2864 if (*current
== NULL
)
2865 printf (_("no information for symbol number %ld\n"), count
);
2867 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2868 printf (_("could not determine the type of symbol number %ld\n"),
2871 else if (process_section_p ((* current
)->section
)
2872 && (dump_special_syms
2873 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2875 const char *name
= (*current
)->name
;
2877 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2881 /* If we want to demangle the name, we demangle it
2882 here, and temporarily clobber it while calling
2883 bfd_print_symbol. FIXME: This is a gross hack. */
2884 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2886 (*current
)->name
= alloc
;
2887 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2888 bfd_print_symbol_all
);
2891 (*current
)->name
= name
;
2896 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2897 bfd_print_symbol_all
);
2907 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2910 char *last_filename
, *last_functionname
;
2911 unsigned int last_line
;
2912 unsigned int last_discriminator
;
2914 /* Get column headers lined up reasonably. */
2922 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2923 width
= strlen (buf
) - 7;
2925 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2928 last_filename
= NULL
;
2929 last_functionname
= NULL
;
2931 last_discriminator
= 0;
2933 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2936 const char *filename
, *functionname
;
2937 unsigned int linenumber
;
2938 unsigned int discriminator
;
2939 const char *sym_name
;
2940 const char *section_name
;
2941 bfd_vma addend2
= 0;
2943 if (start_address
!= (bfd_vma
) -1
2944 && q
->address
< start_address
)
2946 if (stop_address
!= (bfd_vma
) -1
2947 && q
->address
> stop_address
)
2950 if (with_line_numbers
2952 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
2953 &filename
, &functionname
,
2954 &linenumber
, &discriminator
))
2956 if (functionname
!= NULL
2957 && (last_functionname
== NULL
2958 || strcmp (functionname
, last_functionname
) != 0))
2960 printf ("%s():\n", functionname
);
2961 if (last_functionname
!= NULL
)
2962 free (last_functionname
);
2963 last_functionname
= xstrdup (functionname
);
2967 && (linenumber
!= last_line
2968 || (filename
!= NULL
2969 && last_filename
!= NULL
2970 && filename_cmp (filename
, last_filename
) != 0)
2971 || (discriminator
!= last_discriminator
)))
2973 if (discriminator
> 0)
2974 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2976 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
2977 linenumber
, discriminator
);
2978 last_line
= linenumber
;
2979 last_discriminator
= discriminator
;
2980 if (last_filename
!= NULL
)
2981 free (last_filename
);
2982 if (filename
== NULL
)
2983 last_filename
= NULL
;
2985 last_filename
= xstrdup (filename
);
2989 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2991 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2992 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2997 section_name
= NULL
;
3000 bfd_printf_vma (abfd
, q
->address
);
3001 if (q
->howto
== NULL
)
3002 printf (" *unknown* ");
3003 else if (q
->howto
->name
)
3005 const char *name
= q
->howto
->name
;
3007 /* R_SPARC_OLO10 relocations contain two addends.
3008 But because 'arelent' lacks enough storage to
3009 store them both, the 64-bit ELF Sparc backend
3010 records this as two relocations. One R_SPARC_LO10
3011 and one R_SPARC_13, both pointing to the same
3012 address. This is merely so that we have some
3013 place to store both addend fields.
3015 Undo this transformation, otherwise the output
3016 will be confusing. */
3017 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3018 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3020 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3022 arelent
*q2
= *(p
+ 1);
3025 && q
->address
== q2
->address
3026 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3028 name
= "R_SPARC_OLO10";
3029 addend2
= q2
->addend
;
3033 printf (" %-16s ", name
);
3036 printf (" %-16d ", q
->howto
->type
);
3040 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3044 if (section_name
== NULL
)
3045 section_name
= "*unknown*";
3046 printf ("[%s]", section_name
);
3051 bfd_signed_vma addend
= q
->addend
;
3059 bfd_printf_vma (abfd
, addend
);
3064 bfd_printf_vma (abfd
, addend2
);
3070 if (last_filename
!= NULL
)
3071 free (last_filename
);
3072 if (last_functionname
!= NULL
)
3073 free (last_functionname
);
3077 dump_relocs_in_section (bfd
*abfd
,
3079 void *dummy ATTRIBUTE_UNUSED
)
3085 if ( bfd_is_abs_section (section
)
3086 || bfd_is_und_section (section
)
3087 || bfd_is_com_section (section
)
3088 || (! process_section_p (section
))
3089 || ((section
->flags
& SEC_RELOC
) == 0))
3092 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3094 bfd_fatal (bfd_get_filename (abfd
));
3096 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3100 printf (" (none)\n\n");
3104 relpp
= (arelent
**) xmalloc (relsize
);
3105 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3108 bfd_fatal (bfd_get_filename (abfd
));
3109 else if (relcount
== 0)
3110 printf (" (none)\n\n");
3114 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3121 dump_relocs (bfd
*abfd
)
3123 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3127 dump_dynamic_relocs (bfd
*abfd
)
3133 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3135 bfd_fatal (bfd_get_filename (abfd
));
3137 printf ("DYNAMIC RELOCATION RECORDS");
3140 printf (" (none)\n\n");
3143 relpp
= (arelent
**) xmalloc (relsize
);
3144 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3147 bfd_fatal (bfd_get_filename (abfd
));
3148 else if (relcount
== 0)
3149 printf (" (none)\n\n");
3153 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3160 /* Creates a table of paths, to search for source files. */
3163 add_include_path (const char *path
)
3167 include_path_count
++;
3168 include_paths
= (const char **)
3169 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3170 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3171 if (path
[1] == ':' && path
[2] == 0)
3172 path
= concat (path
, ".", (const char *) 0);
3174 include_paths
[include_path_count
- 1] = path
;
3178 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3182 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3184 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3185 section
->vma
+= adjust_section_vma
;
3187 section
->lma
+= adjust_section_vma
;
3191 /* Dump selected contents of ABFD. */
3194 dump_bfd (bfd
*abfd
)
3196 /* If we are adjusting section VMA's, change them all now. Changing
3197 the BFD information is a hack. However, we must do it, or
3198 bfd_find_nearest_line will not do the right thing. */
3199 if (adjust_section_vma
!= 0)
3201 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3202 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3205 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3206 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3209 print_arelt_descr (stdout
, abfd
, TRUE
);
3210 if (dump_file_header
)
3211 dump_bfd_header (abfd
);
3212 if (dump_private_headers
)
3213 dump_bfd_private_header (abfd
);
3214 if (dump_private_options
!= NULL
)
3215 dump_target_specific (abfd
);
3216 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3218 if (dump_section_headers
)
3219 dump_headers (abfd
);
3225 || dump_dwarf_section_info
)
3226 syms
= slurp_symtab (abfd
);
3227 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3228 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3229 dynsyms
= slurp_dynamic_symtab (abfd
);
3232 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3233 dynsymcount
, dynsyms
, &synthsyms
);
3239 dump_symbols (abfd
, FALSE
);
3240 if (dump_dynamic_symtab
)
3241 dump_symbols (abfd
, TRUE
);
3242 if (dump_dwarf_section_info
)
3244 if (dump_stab_section_info
)
3246 if (dump_reloc_info
&& ! disassemble
)
3248 if (dump_dynamic_reloc_info
&& ! disassemble
)
3249 dump_dynamic_relocs (abfd
);
3250 if (dump_section_contents
)
3253 disassemble_data (abfd
);
3259 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3260 if (dhandle
!= NULL
)
3262 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3264 dump_debugging_tags
? TRUE
: FALSE
))
3266 non_fatal (_("%s: printing debugging information failed"),
3267 bfd_get_filename (abfd
));
3271 /* PR 6483: If there was no STABS or IEEE debug
3272 info in the file, try DWARF instead. */
3273 else if (! dump_dwarf_section_info
)
3275 dwarf_select_sections_all ();
3304 display_object_bfd (bfd
*abfd
)
3308 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3314 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3316 nonfatal (bfd_get_filename (abfd
));
3317 list_matching_formats (matching
);
3322 if (bfd_get_error () != bfd_error_file_not_recognized
)
3324 nonfatal (bfd_get_filename (abfd
));
3328 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3334 nonfatal (bfd_get_filename (abfd
));
3336 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3338 list_matching_formats (matching
);
3344 display_any_bfd (bfd
*file
, int level
)
3346 /* Decompress sections unless dumping the section contents. */
3347 if (!dump_section_contents
)
3348 file
->flags
|= BFD_DECOMPRESS
;
3350 /* If the file is an archive, process all of its elements. */
3351 if (bfd_check_format (file
, bfd_archive
))
3354 bfd
*last_arfile
= NULL
;
3357 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3359 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3363 bfd_set_error (bfd_error_no_error
);
3365 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3368 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3369 nonfatal (bfd_get_filename (file
));
3373 display_any_bfd (arfile
, level
+ 1);
3375 if (last_arfile
!= NULL
)
3376 bfd_close (last_arfile
);
3377 last_arfile
= arfile
;
3380 if (last_arfile
!= NULL
)
3381 bfd_close (last_arfile
);
3384 display_object_bfd (file
);
3388 display_file (char *filename
, char *target
)
3392 if (get_file_size (filename
) < 1)
3398 file
= bfd_openr (filename
, target
);
3401 nonfatal (filename
);
3405 display_any_bfd (file
, 0);
3411 main (int argc
, char **argv
)
3414 char *target
= default_target
;
3415 bfd_boolean seenflag
= FALSE
;
3417 #if defined (HAVE_SETLOCALE)
3418 #if defined (HAVE_LC_MESSAGES)
3419 setlocale (LC_MESSAGES
, "");
3421 setlocale (LC_CTYPE
, "");
3424 bindtextdomain (PACKAGE
, LOCALEDIR
);
3425 textdomain (PACKAGE
);
3427 program_name
= *argv
;
3428 xmalloc_set_program_name (program_name
);
3430 START_PROGRESS (program_name
, 0);
3432 expandargv (&argc
, &argv
);
3435 set_default_bfd_target ();
3437 while ((c
= getopt_long (argc
, argv
,
3438 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3439 long_options
, (int *) 0))
3445 break; /* We've been given a long option. */
3450 if (disassembler_options
)
3451 /* Ignore potential memory leak for now. */
3452 disassembler_options
= concat (disassembler_options
, ",",
3453 optarg
, (const char *) NULL
);
3455 disassembler_options
= optarg
;
3461 display_file_offsets
= TRUE
;
3464 with_line_numbers
= TRUE
;
3473 enum demangling_styles style
;
3475 style
= cplus_demangle_name_to_style (optarg
);
3476 if (style
== unknown_demangling
)
3477 fatal (_("unknown demangling style `%s'"),
3480 cplus_demangle_set_style (style
);
3486 case OPTION_ADJUST_VMA
:
3487 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3489 case OPTION_START_ADDRESS
:
3490 start_address
= parse_vma (optarg
, "--start-address");
3491 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3492 fatal (_("error: the start address should be before the end address"));
3494 case OPTION_STOP_ADDRESS
:
3495 stop_address
= parse_vma (optarg
, "--stop-address");
3496 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3497 fatal (_("error: the stop address should be after the start address"));
3501 prefix_length
= strlen (prefix
);
3502 /* Remove an unnecessary trailing '/' */
3503 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3506 case OPTION_PREFIX_STRIP
:
3507 prefix_strip
= atoi (optarg
);
3508 if (prefix_strip
< 0)
3509 fatal (_("error: prefix strip must be non-negative"));
3511 case OPTION_INSN_WIDTH
:
3512 insn_width
= strtoul (optarg
, NULL
, 0);
3513 if (insn_width
<= 0)
3514 fatal (_("error: instruction width must be positive"));
3517 if (strcmp (optarg
, "B") == 0)
3518 endian
= BFD_ENDIAN_BIG
;
3519 else if (strcmp (optarg
, "L") == 0)
3520 endian
= BFD_ENDIAN_LITTLE
;
3523 nonfatal (_("unrecognized -E option"));
3528 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3529 endian
= BFD_ENDIAN_BIG
;
3530 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3531 endian
= BFD_ENDIAN_LITTLE
;
3534 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3541 dump_file_header
= TRUE
;
3545 formats_info
= TRUE
;
3549 add_include_path (optarg
);
3552 dump_private_headers
= TRUE
;
3556 dump_private_options
= optarg
;
3560 dump_private_headers
= TRUE
;
3562 dump_reloc_info
= TRUE
;
3563 dump_file_header
= TRUE
;
3564 dump_ar_hdrs
= TRUE
;
3565 dump_section_headers
= TRUE
;
3573 dump_dynamic_symtab
= TRUE
;
3581 disassemble_zeroes
= TRUE
;
3585 disassemble_all
= TRUE
;
3590 with_source_code
= TRUE
;
3599 dump_debugging_tags
= 1;
3604 dump_dwarf_section_info
= TRUE
;
3607 dwarf_select_sections_by_letters (optarg
);
3609 dwarf_select_sections_all ();
3612 dump_dwarf_section_info
= TRUE
;
3615 dwarf_select_sections_by_names (optarg
);
3617 dwarf_select_sections_all ();
3619 case OPTION_DWARF_DEPTH
:
3622 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3625 case OPTION_DWARF_START
:
3628 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3629 suppress_bfd_header
= 1;
3632 case OPTION_DWARF_CHECK
:
3636 dump_stab_section_info
= TRUE
;
3640 dump_section_contents
= TRUE
;
3644 dump_reloc_info
= TRUE
;
3648 dump_dynamic_reloc_info
= TRUE
;
3652 dump_ar_hdrs
= TRUE
;
3656 dump_section_headers
= TRUE
;
3664 show_version
= TRUE
;
3674 print_version ("objdump");
3680 exit_status
= display_info ();
3684 display_file ("a.out", target
);
3686 for (; optind
< argc
;)
3687 display_file (argv
[optind
++], target
);
3692 END_PROGRESS (program_name
);