1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
59 #include "safe-ctype.h"
61 #include "libiberty.h"
63 #include "filenames.h"
72 /* Internal headers for the ELF .stab-dump code - sorry. */
73 #define BYTES_IN_WORD 32
74 #include "aout/aout64.h"
77 static int exit_status
= 0;
79 static char *default_target
= NULL
; /* Default at runtime. */
81 /* The following variables are set based on arguments passed on the
83 static int show_version
= 0; /* Show the version number. */
84 static int dump_section_contents
; /* -s */
85 static int dump_section_headers
; /* -h */
86 static bfd_boolean dump_file_header
; /* -f */
87 static int dump_symtab
; /* -t */
88 static int dump_dynamic_symtab
; /* -T */
89 static int dump_reloc_info
; /* -r */
90 static int dump_dynamic_reloc_info
; /* -R */
91 static int dump_ar_hdrs
; /* -a */
92 static int dump_private_headers
; /* -p */
93 static char *dump_private_options
; /* -P */
94 static int prefix_addresses
; /* --prefix-addresses */
95 static int with_line_numbers
; /* -l */
96 static bfd_boolean with_source_code
; /* -S */
97 static int show_raw_insn
; /* --show-raw-insn */
98 static int dump_dwarf_section_info
; /* --dwarf */
99 static int dump_stab_section_info
; /* --stabs */
100 static int do_demangle
; /* -C, --demangle */
101 static bfd_boolean disassemble
; /* -d */
102 static bfd_boolean disassemble_all
; /* -D */
103 static int disassemble_zeroes
; /* --disassemble-zeroes */
104 static bfd_boolean formats_info
; /* -i */
105 static int wide_output
; /* -w */
106 static int insn_width
; /* --insn-width */
107 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
108 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
109 static int dump_debugging
; /* --debugging */
110 static int dump_debugging_tags
; /* --debugging-tags */
111 static int suppress_bfd_header
;
112 static int dump_special_syms
= 0; /* --special-syms */
113 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
114 static int file_start_context
= 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets
;/* -F */
116 static const char *prefix
; /* --prefix */
117 static int prefix_strip
; /* --prefix-strip */
118 static size_t prefix_length
;
120 /* A structure to record the sections mentioned in -j switches. */
123 const char * name
; /* The name of the section. */
124 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
125 struct only
* next
; /* Pointer to the next structure in the list. */
127 /* Pointer to an array of 'only' structures.
128 This pointer is NULL if the -j switch has not been used. */
129 static struct only
* only_list
= NULL
;
131 /* Variables for handling include file path table. */
132 static const char **include_paths
;
133 static int include_path_count
;
135 /* Extra info to pass to the section disassembler and address printing
137 struct objdump_disasm_info
141 bfd_boolean require_sec
;
142 arelent
** dynrelbuf
;
144 disassembler_ftype disassemble_fn
;
148 /* Architecture to disassemble for, or default if NULL. */
149 static char *machine
= NULL
;
151 /* Target specific options to the disassembler. */
152 static char *disassembler_options
= NULL
;
154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
155 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
157 /* The symbol table. */
158 static asymbol
**syms
;
160 /* Number of symbols in `syms'. */
161 static long symcount
= 0;
163 /* The sorted symbol table. */
164 static asymbol
**sorted_syms
;
166 /* Number of symbols in `sorted_syms'. */
167 static long sorted_symcount
= 0;
169 /* The dynamic symbol table. */
170 static asymbol
**dynsyms
;
172 /* The synthetic symbol table. */
173 static asymbol
*synthsyms
;
174 static long synthcount
= 0;
176 /* Number of symbols in `dynsyms'. */
177 static long dynsymcount
= 0;
179 static bfd_byte
*stabs
;
180 static bfd_size_type stab_size
;
183 static bfd_size_type stabstr_size
;
185 static bfd_boolean is_relocatable
= FALSE
;
187 /* Handlers for -P/--private. */
188 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
190 OBJDUMP_PRIVATE_VECTORS
194 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
196 usage (FILE *stream
, int status
)
198 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
199 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
200 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
201 fprintf (stream
, _("\
202 -a, --archive-headers Display archive header information\n\
203 -f, --file-headers Display the contents of the overall file header\n\
204 -p, --private-headers Display object format specific file header contents\n\
205 -P, --private=OPT,OPT... Display object format specific contents\n\
206 -h, --[section-]headers Display the contents of the section headers\n\
207 -x, --all-headers Display the contents of all headers\n\
208 -d, --disassemble Display assembler contents of executable sections\n\
209 -D, --disassemble-all Display assembler contents of all sections\n\
210 -S, --source Intermix source code with disassembly\n\
211 -s, --full-contents Display the full contents of all sections requested\n\
212 -g, --debugging Display debug information in object file\n\
213 -e, --debugging-tags Display debug information using ctags style\n\
214 -G, --stabs Display (in raw form) any STABS info in the file\n\
215 -W[lLiaprmfFsoRt] or\n\
216 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
217 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
218 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
220 Display DWARF info in the file\n\
221 -t, --syms Display the contents of the symbol table(s)\n\
222 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
223 -r, --reloc Display the relocation entries in the file\n\
224 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
225 @<file> Read options from <file>\n\
226 -v, --version Display this program's version number\n\
227 -i, --info List object formats and architectures supported\n\
228 -H, --help Display this information\n\
232 const struct objdump_private_desc
* const *desc
;
234 fprintf (stream
, _("\n The following switches are optional:\n"));
235 fprintf (stream
, _("\
236 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
237 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
238 -j, --section=NAME Only display information for section NAME\n\
239 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
240 -EB --endian=big Assume big endian format when disassembling\n\
241 -EL --endian=little Assume little endian format when disassembling\n\
242 --file-start-context Include context from start of file (with -S)\n\
243 -I, --include=DIR Add DIR to search list for source files\n\
244 -l, --line-numbers Include line numbers and filenames in output\n\
245 -F, --file-offsets Include file offsets when displaying information\n\
246 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
247 The STYLE, if specified, can be `auto', `gnu',\n\
248 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
250 -w, --wide Format output for more than 80 columns\n\
251 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
252 --start-address=ADDR Only process data whose address is >= ADDR\n\
253 --stop-address=ADDR Only process data whose address is <= ADDR\n\
254 --prefix-addresses Print complete address alongside disassembly\n\
255 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
256 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
257 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
258 --special-syms Include special symbols in symbol dumps\n\
259 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
260 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
261 fprintf (stream
, _("\
262 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
263 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
265 --dwarf-check Make additional dwarf internal consistency checks.\
267 list_supported_targets (program_name
, stream
);
268 list_supported_architectures (program_name
, stream
);
270 disassembler_usage (stream
);
272 if (objdump_private_vectors
[0] != NULL
)
275 _("\nOptions supported for -P/--private switch:\n"));
276 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
277 (*desc
)->help (stream
);
280 if (REPORT_BUGS_TO
[0] && status
== 0)
281 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
285 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
289 OPTION_START_ADDRESS
,
301 static struct option long_options
[]=
303 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
304 {"all-headers", no_argument
, NULL
, 'x'},
305 {"private-headers", no_argument
, NULL
, 'p'},
306 {"private", required_argument
, NULL
, 'P'},
307 {"architecture", required_argument
, NULL
, 'm'},
308 {"archive-headers", no_argument
, NULL
, 'a'},
309 {"debugging", no_argument
, NULL
, 'g'},
310 {"debugging-tags", no_argument
, NULL
, 'e'},
311 {"demangle", optional_argument
, NULL
, 'C'},
312 {"disassemble", no_argument
, NULL
, 'd'},
313 {"disassemble-all", no_argument
, NULL
, 'D'},
314 {"disassembler-options", required_argument
, NULL
, 'M'},
315 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
316 {"dynamic-reloc", no_argument
, NULL
, 'R'},
317 {"dynamic-syms", no_argument
, NULL
, 'T'},
318 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
319 {"file-headers", no_argument
, NULL
, 'f'},
320 {"file-offsets", no_argument
, NULL
, 'F'},
321 {"file-start-context", no_argument
, &file_start_context
, 1},
322 {"full-contents", no_argument
, NULL
, 's'},
323 {"headers", no_argument
, NULL
, 'h'},
324 {"help", no_argument
, NULL
, 'H'},
325 {"info", no_argument
, NULL
, 'i'},
326 {"line-numbers", no_argument
, NULL
, 'l'},
327 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
328 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
329 {"reloc", no_argument
, NULL
, 'r'},
330 {"section", required_argument
, NULL
, 'j'},
331 {"section-headers", no_argument
, NULL
, 'h'},
332 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
333 {"source", no_argument
, NULL
, 'S'},
334 {"special-syms", no_argument
, &dump_special_syms
, 1},
335 {"include", required_argument
, NULL
, 'I'},
336 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
337 {"stabs", no_argument
, NULL
, 'G'},
338 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
339 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
340 {"syms", no_argument
, NULL
, 't'},
341 {"target", required_argument
, NULL
, 'b'},
342 {"version", no_argument
, NULL
, 'V'},
343 {"wide", no_argument
, NULL
, 'w'},
344 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
345 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
346 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
347 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
348 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
349 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
350 {0, no_argument
, 0, 0}
354 nonfatal (const char *msg
)
360 /* Returns TRUE if the specified section should be dumped. */
363 process_section_p (asection
* section
)
367 if (only_list
== NULL
)
370 for (only
= only_list
; only
; only
= only
->next
)
371 if (strcmp (only
->name
, section
->name
) == 0)
380 /* Add an entry to the 'only' list. */
383 add_only (char * name
)
387 /* First check to make sure that we do not
388 already have an entry for this name. */
389 for (only
= only_list
; only
; only
= only
->next
)
390 if (strcmp (only
->name
, name
) == 0)
393 only
= xmalloc (sizeof * only
);
396 only
->next
= only_list
;
400 /* Release the memory used by the 'only' list.
401 PR 11225: Issue a warning message for unseen sections.
402 Only do this if none of the sections were seen. This is mainly to support
403 tools like the GAS testsuite where an object file is dumped with a list of
404 generic section names known to be present in a range of different file
408 free_only_list (void)
410 bfd_boolean at_least_one_seen
= FALSE
;
414 if (only_list
== NULL
)
417 for (only
= only_list
; only
; only
= only
->next
)
420 at_least_one_seen
= TRUE
;
424 for (only
= only_list
; only
; only
= next
)
426 if (! at_least_one_seen
)
428 non_fatal (_("section '%s' mentioned in a -j option, "
429 "but not found in any input file"),
440 dump_section_header (bfd
*abfd
, asection
*section
,
441 void *ignored ATTRIBUTE_UNUSED
)
444 unsigned int opb
= bfd_octets_per_byte (abfd
);
446 /* Ignore linker created section. See elfNN_ia64_object_p in
448 if (section
->flags
& SEC_LINKER_CREATED
)
451 /* PR 10413: Skip sections that we are ignoring. */
452 if (! process_section_p (section
))
455 printf ("%3d %-13s %08lx ", section
->index
,
456 bfd_get_section_name (abfd
, section
),
457 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
458 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
460 bfd_printf_vma (abfd
, section
->lma
);
461 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
462 bfd_get_section_alignment (abfd
, section
));
468 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
470 PF (SEC_HAS_CONTENTS
, "CONTENTS");
471 PF (SEC_ALLOC
, "ALLOC");
472 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
473 PF (SEC_LOAD
, "LOAD");
474 PF (SEC_RELOC
, "RELOC");
475 PF (SEC_READONLY
, "READONLY");
476 PF (SEC_CODE
, "CODE");
477 PF (SEC_DATA
, "DATA");
479 PF (SEC_DEBUGGING
, "DEBUGGING");
480 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
481 PF (SEC_EXCLUDE
, "EXCLUDE");
482 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
483 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
485 PF (SEC_TIC54X_BLOCK
, "BLOCK");
486 PF (SEC_TIC54X_CLINK
, "CLINK");
488 PF (SEC_SMALL_DATA
, "SMALL_DATA");
489 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
490 PF (SEC_COFF_SHARED
, "SHARED");
491 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
492 PF (SEC_GROUP
, "GROUP");
494 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
497 struct coff_comdat_info
*comdat
;
499 switch (section
->flags
& SEC_LINK_DUPLICATES
)
503 case SEC_LINK_DUPLICATES_DISCARD
:
504 ls
= "LINK_ONCE_DISCARD";
506 case SEC_LINK_DUPLICATES_ONE_ONLY
:
507 ls
= "LINK_ONCE_ONE_ONLY";
509 case SEC_LINK_DUPLICATES_SAME_SIZE
:
510 ls
= "LINK_ONCE_SAME_SIZE";
512 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
513 ls
= "LINK_ONCE_SAME_CONTENTS";
516 printf ("%s%s", comma
, ls
);
518 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
520 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
530 dump_headers (bfd
*abfd
)
532 printf (_("Sections:\n"));
535 printf (_("Idx Name Size VMA LMA File off Algn"));
537 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
538 if (bfd_get_arch_size (abfd
) == 32)
539 printf (_("Idx Name Size VMA LMA File off Algn"));
541 printf (_("Idx Name Size VMA LMA File off Algn"));
545 printf (_(" Flags"));
548 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
552 slurp_symtab (bfd
*abfd
)
557 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
563 storage
= bfd_get_symtab_upper_bound (abfd
);
566 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
567 bfd_fatal (_("error message was"));
570 sy
= (asymbol
**) xmalloc (storage
);
572 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
574 bfd_fatal (bfd_get_filename (abfd
));
578 /* Read in the dynamic symbols. */
581 slurp_dynamic_symtab (bfd
*abfd
)
586 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
589 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
591 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
597 bfd_fatal (bfd_get_filename (abfd
));
600 sy
= (asymbol
**) xmalloc (storage
);
602 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
604 bfd_fatal (bfd_get_filename (abfd
));
608 /* Filter out (in place) symbols that are useless for disassembly.
609 COUNT is the number of elements in SYMBOLS.
610 Return the number of useful symbols. */
613 remove_useless_symbols (asymbol
**symbols
, long count
)
615 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
619 asymbol
*sym
= *in_ptr
++;
621 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
623 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
625 if (bfd_is_und_section (sym
->section
)
626 || bfd_is_com_section (sym
->section
))
631 return out_ptr
- symbols
;
634 /* Sort symbols into value order. */
637 compare_symbols (const void *ap
, const void *bp
)
639 const asymbol
*a
= * (const asymbol
**) ap
;
640 const asymbol
*b
= * (const asymbol
**) bp
;
650 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
652 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
655 if (a
->section
> b
->section
)
657 else if (a
->section
< b
->section
)
660 an
= bfd_asymbol_name (a
);
661 bn
= bfd_asymbol_name (b
);
665 /* The symbols gnu_compiled and gcc2_compiled convey no real
666 information, so put them after other symbols with the same value. */
667 af
= (strstr (an
, "gnu_compiled") != NULL
668 || strstr (an
, "gcc2_compiled") != NULL
);
669 bf
= (strstr (bn
, "gnu_compiled") != NULL
670 || strstr (bn
, "gcc2_compiled") != NULL
);
677 /* We use a heuristic for the file name, to try to sort it after
678 more useful symbols. It may not work on non Unix systems, but it
679 doesn't really matter; the only difference is precisely which
680 symbol names get printed. */
682 #define file_symbol(s, sn, snl) \
683 (((s)->flags & BSF_FILE) != 0 \
684 || ((sn)[(snl) - 2] == '.' \
685 && ((sn)[(snl) - 1] == 'o' \
686 || (sn)[(snl) - 1] == 'a')))
688 af
= file_symbol (a
, an
, anl
);
689 bf
= file_symbol (b
, bn
, bnl
);
696 /* Try to sort global symbols before local symbols before function
697 symbols before debugging symbols. */
702 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
704 if ((aflags
& BSF_DEBUGGING
) != 0)
709 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
711 if ((aflags
& BSF_FUNCTION
) != 0)
716 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
718 if ((aflags
& BSF_LOCAL
) != 0)
723 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
725 if ((aflags
& BSF_GLOBAL
) != 0)
731 /* Symbols that start with '.' might be section names, so sort them
732 after symbols that don't start with '.'. */
733 if (an
[0] == '.' && bn
[0] != '.')
735 if (an
[0] != '.' && bn
[0] == '.')
738 /* Finally, if we can't distinguish them in any other way, try to
739 get consistent results by sorting the symbols by name. */
740 return strcmp (an
, bn
);
743 /* Sort relocs into address order. */
746 compare_relocs (const void *ap
, const void *bp
)
748 const arelent
*a
= * (const arelent
**) ap
;
749 const arelent
*b
= * (const arelent
**) bp
;
751 if (a
->address
> b
->address
)
753 else if (a
->address
< b
->address
)
756 /* So that associated relocations tied to the same address show up
757 in the correct order, we don't do any further sorting. */
766 /* Print an address (VMA) to the output stream in INFO.
767 If SKIP_ZEROES is TRUE, omit leading zeroes. */
770 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
771 bfd_boolean skip_zeroes
)
775 struct objdump_disasm_info
*aux
;
777 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
778 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
783 for (p
= buf
; *p
== '0'; ++p
)
788 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
791 /* Print the name of a symbol. */
794 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
798 const char *name
, *version_string
= NULL
;
799 bfd_boolean hidden
= FALSE
;
802 name
= bfd_asymbol_name (sym
);
803 if (do_demangle
&& name
[0] != '\0')
805 /* Demangle the name. */
806 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
811 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
813 if (bfd_is_und_section (bfd_get_section (sym
)))
818 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
819 if (version_string
&& *version_string
!= '\0')
820 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
826 if (version_string
&& *version_string
!= '\0')
827 printf (hidden
? "@%s" : "@@%s", version_string
);
834 /* Locate a symbol given a bfd and a section (from INFO->application_data),
835 and a VMA. If INFO->application_data->require_sec is TRUE, then always
836 require the symbol to be in the section. Returns NULL if there is no
837 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
838 of the symbol in sorted_syms. */
841 find_symbol_for_address (bfd_vma vma
,
842 struct disassemble_info
*inf
,
845 /* @@ Would it speed things up to cache the last two symbols returned,
846 and maybe their address ranges? For many processors, only one memory
847 operand can be present at a time, so the 2-entry cache wouldn't be
848 constantly churned by code doing heavy memory accesses. */
850 /* Indices in `sorted_syms'. */
852 long max_count
= sorted_symcount
;
854 struct objdump_disasm_info
*aux
;
858 bfd_boolean want_section
;
860 if (sorted_symcount
< 1)
863 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
866 opb
= inf
->octets_per_byte
;
868 /* Perform a binary search looking for the closest symbol to the
869 required value. We are searching the range (min, max_count]. */
870 while (min
+ 1 < max_count
)
874 thisplace
= (max_count
+ min
) / 2;
875 sym
= sorted_syms
[thisplace
];
877 if (bfd_asymbol_value (sym
) > vma
)
878 max_count
= thisplace
;
879 else if (bfd_asymbol_value (sym
) < vma
)
888 /* The symbol we want is now in min, the low end of the range we
889 were searching. If there are several symbols with the same
890 value, we want the first one. */
893 && (bfd_asymbol_value (sorted_syms
[thisplace
])
894 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
897 /* Prefer a symbol in the current section if we have multple symbols
898 with the same value, as can occur with overlays or zero size
901 while (min
< max_count
902 && (bfd_asymbol_value (sorted_syms
[min
])
903 == bfd_asymbol_value (sorted_syms
[thisplace
])))
905 if (sorted_syms
[min
]->section
== sec
906 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
913 return sorted_syms
[thisplace
];
918 /* If the file is relocatable, and the symbol could be from this
919 section, prefer a symbol from this section over symbols from
920 others, even if the other symbol's value might be closer.
922 Note that this may be wrong for some symbol references if the
923 sections have overlapping memory ranges, but in that case there's
924 no way to tell what's desired without looking at the relocation
927 Also give the target a chance to reject symbols. */
928 want_section
= (aux
->require_sec
929 || ((abfd
->flags
& HAS_RELOC
) != 0
930 && vma
>= bfd_get_section_vma (abfd
, sec
)
931 && vma
< (bfd_get_section_vma (abfd
, sec
)
932 + bfd_section_size (abfd
, sec
) / opb
)));
933 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
934 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
937 long newplace
= sorted_symcount
;
939 for (i
= min
- 1; i
>= 0; i
--)
941 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
942 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
944 if (newplace
== sorted_symcount
)
947 if (bfd_asymbol_value (sorted_syms
[i
])
948 != bfd_asymbol_value (sorted_syms
[newplace
]))
951 /* Remember this symbol and keep searching until we reach
952 an earlier address. */
957 if (newplace
!= sorted_symcount
)
958 thisplace
= newplace
;
961 /* We didn't find a good symbol with a smaller value.
962 Look for one with a larger value. */
963 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
965 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
966 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
974 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
975 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
976 /* There is no suitable symbol. */
983 return sorted_syms
[thisplace
];
986 /* Print an address and the offset to the nearest symbol. */
989 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
990 bfd_vma vma
, struct disassemble_info
*inf
,
991 bfd_boolean skip_zeroes
)
993 objdump_print_value (vma
, inf
, skip_zeroes
);
999 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1000 bfd_get_section_name (abfd
, sec
));
1001 secaddr
= bfd_get_section_vma (abfd
, sec
);
1004 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1005 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1007 else if (vma
> secaddr
)
1009 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1010 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1012 (*inf
->fprintf_func
) (inf
->stream
, ">");
1016 (*inf
->fprintf_func
) (inf
->stream
, " <");
1017 objdump_print_symname (abfd
, inf
, sym
);
1018 if (bfd_asymbol_value (sym
) > vma
)
1020 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1021 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1023 else if (vma
> bfd_asymbol_value (sym
))
1025 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1026 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1028 (*inf
->fprintf_func
) (inf
->stream
, ">");
1031 if (display_file_offsets
)
1032 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1033 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1036 /* Print an address (VMA), symbolically if possible.
1037 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1040 objdump_print_addr (bfd_vma vma
,
1041 struct disassemble_info
*inf
,
1042 bfd_boolean skip_zeroes
)
1044 struct objdump_disasm_info
*aux
;
1045 asymbol
*sym
= NULL
;
1046 bfd_boolean skip_find
= FALSE
;
1048 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1050 if (sorted_symcount
< 1)
1052 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1053 objdump_print_value (vma
, inf
, skip_zeroes
);
1055 if (display_file_offsets
)
1056 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1057 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1061 if (aux
->reloc
!= NULL
1062 && aux
->reloc
->sym_ptr_ptr
!= NULL
1063 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1065 sym
= * aux
->reloc
->sym_ptr_ptr
;
1067 /* Adjust the vma to the reloc. */
1068 vma
+= bfd_asymbol_value (sym
);
1070 if (bfd_is_und_section (bfd_get_section (sym
)))
1075 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1077 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1081 /* Print VMA to INFO. This function is passed to the disassembler
1085 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1087 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1090 /* Determine if the given address has a symbol associated with it. */
1093 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1097 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1099 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1102 /* Hold the last function name and the last line number we displayed
1103 in a disassembly. */
1105 static char *prev_functionname
;
1106 static unsigned int prev_line
;
1107 static unsigned int prev_discriminator
;
1109 /* We keep a list of all files that we have seen when doing a
1110 disassembly with source, so that we know how much of the file to
1111 display. This can be important for inlined functions. */
1113 struct print_file_list
1115 struct print_file_list
*next
;
1116 const char *filename
;
1117 const char *modname
;
1120 const char **linemap
;
1126 static struct print_file_list
*print_files
;
1128 /* The number of preceding context lines to show when we start
1129 displaying a file for the first time. */
1131 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1133 /* Read a complete file into memory. */
1136 slurp_file (const char *fn
, size_t *size
)
1139 int ps
= getpagesize ();
1144 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1148 if (fstat (fd
, &st
) < 0)
1155 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1156 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1157 if (map
!= (char *) -1L)
1163 map
= (const char *) malloc (*size
);
1164 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1166 free ((void *) map
);
1173 #define line_map_decrease 5
1175 /* Precompute array of lines for a mapped file. */
1177 static const char **
1178 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1180 const char *p
, *lstart
, *end
;
1181 int chars_per_line
= 45; /* First iteration will use 40. */
1182 unsigned int lineno
;
1183 const char **linemap
= NULL
;
1184 unsigned long line_map_size
= 0;
1190 for (p
= map
; p
< end
; p
++)
1194 if (p
+ 1 < end
&& p
[1] == '\r')
1197 else if (*p
== '\r')
1199 if (p
+ 1 < end
&& p
[1] == '\n')
1205 /* End of line found. */
1207 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1209 unsigned long newsize
;
1211 chars_per_line
-= line_map_decrease
;
1212 if (chars_per_line
<= 1)
1214 line_map_size
= size
/ chars_per_line
+ 1;
1215 if (line_map_size
< lineno
+ 1)
1216 line_map_size
= lineno
+ 1;
1217 newsize
= line_map_size
* sizeof (char *);
1218 linemap
= (const char **) xrealloc (linemap
, newsize
);
1221 linemap
[lineno
++] = lstart
;
1229 /* Tries to open MODNAME, and if successful adds a node to print_files
1230 linked list and returns that node. Returns NULL on failure. */
1232 static struct print_file_list
*
1233 try_print_file_open (const char *origname
, const char *modname
)
1235 struct print_file_list
*p
;
1237 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1239 p
->map
= slurp_file (modname
, &p
->mapsize
);
1246 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1248 p
->filename
= origname
;
1249 p
->modname
= modname
;
1250 p
->next
= print_files
;
1256 /* If the source file, as described in the symtab, is not found
1257 try to locate it in one of the paths specified with -I
1258 If found, add location to print_files linked list. */
1260 static struct print_file_list
*
1261 update_source_path (const char *filename
)
1263 struct print_file_list
*p
;
1267 p
= try_print_file_open (filename
, filename
);
1271 if (include_path_count
== 0)
1274 /* Get the name of the file. */
1275 fname
= lbasename (filename
);
1277 /* If file exists under a new path, we need to add it to the list
1278 so that show_line knows about it. */
1279 for (i
= 0; i
< include_path_count
; i
++)
1281 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1283 p
= try_print_file_open (filename
, modname
);
1293 /* Print a source file line. */
1296 print_line (struct print_file_list
*p
, unsigned int linenum
)
1302 if (linenum
>= p
->maxline
)
1304 l
= p
->linemap
[linenum
];
1305 /* Test fwrite return value to quiet glibc warning. */
1306 len
= strcspn (l
, "\n\r");
1307 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1311 /* Print a range of source code lines. */
1314 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1318 while (start
<= end
)
1320 print_line (p
, start
);
1325 /* Show the line number, or the source line, in a disassembly
1329 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1331 const char *filename
;
1332 const char *functionname
;
1333 unsigned int linenumber
;
1334 unsigned int discriminator
;
1337 if (! with_line_numbers
&& ! with_source_code
)
1340 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1341 &filename
, &functionname
,
1342 &linenumber
, &discriminator
))
1345 if (filename
!= NULL
&& *filename
== '\0')
1347 if (functionname
!= NULL
&& *functionname
== '\0')
1348 functionname
= NULL
;
1351 && IS_ABSOLUTE_PATH (filename
)
1355 const char *fname
= filename
;
1356 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1359 memcpy (path
, prefix
, prefix_length
);
1360 path_up
= path
+ prefix_length
;
1362 /* Build relocated filename, stripping off leading directories
1363 from the initial filename if requested. */
1364 if (prefix_strip
> 0)
1369 /* Skip selected directory levels. */
1370 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1371 if (IS_DIR_SEPARATOR(*s
))
1378 /* Update complete filename. */
1379 strncpy (path_up
, fname
, PATH_MAX
);
1380 path_up
[PATH_MAX
] = '\0';
1388 if (with_line_numbers
)
1390 if (functionname
!= NULL
1391 && (prev_functionname
== NULL
1392 || strcmp (functionname
, prev_functionname
) != 0))
1393 printf ("%s():\n", functionname
);
1394 if (linenumber
> 0 && (linenumber
!= prev_line
||
1395 (discriminator
!= prev_discriminator
)))
1397 if (discriminator
> 0)
1398 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1399 linenumber
, discriminator
);
1401 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1405 if (with_source_code
1409 struct print_file_list
**pp
, *p
;
1412 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1413 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1420 filename
= xstrdup (filename
);
1421 p
= update_source_path (filename
);
1424 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1426 if (file_start_context
&& p
->first
)
1430 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1431 if (l
>= linenumber
)
1433 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1434 l
= p
->last_line
+ 1;
1436 dump_lines (p
, l
, linenumber
);
1437 p
->last_line
= linenumber
;
1442 if (functionname
!= NULL
1443 && (prev_functionname
== NULL
1444 || strcmp (functionname
, prev_functionname
) != 0))
1446 if (prev_functionname
!= NULL
)
1447 free (prev_functionname
);
1448 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1449 strcpy (prev_functionname
, functionname
);
1452 if (linenumber
> 0 && linenumber
!= prev_line
)
1453 prev_line
= linenumber
;
1455 if (discriminator
!= prev_discriminator
)
1456 prev_discriminator
= discriminator
;
1459 /* Pseudo FILE object for strings. */
1467 /* sprintf to a "stream". */
1469 static int ATTRIBUTE_PRINTF_2
1470 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1477 size_t space
= f
->alloc
- f
->pos
;
1479 va_start (args
, format
);
1480 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1486 f
->alloc
= (f
->alloc
+ n
) * 2;
1487 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1494 /* The number of zeroes we want to see before we start skipping them.
1495 The number is arbitrarily chosen. */
1497 #define DEFAULT_SKIP_ZEROES 8
1499 /* The number of zeroes to skip at the end of a section. If the
1500 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1501 SKIP_ZEROES, they will be disassembled. If there are fewer than
1502 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1503 attempt to avoid disassembling zeroes inserted by section
1506 #define DEFAULT_SKIP_ZEROES_AT_END 3
1508 /* Disassemble some data in memory between given values. */
1511 disassemble_bytes (struct disassemble_info
* inf
,
1512 disassembler_ftype disassemble_fn
,
1515 bfd_vma start_offset
,
1516 bfd_vma stop_offset
,
1519 arelent
** relppend
)
1521 struct objdump_disasm_info
*aux
;
1523 int octets_per_line
;
1524 int skip_addr_chars
;
1525 bfd_vma addr_offset
;
1526 unsigned int opb
= inf
->octets_per_byte
;
1527 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1528 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1532 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1536 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1540 octets_per_line
= insn_width
;
1542 octets_per_line
= 4;
1544 octets_per_line
= 16;
1546 /* Figure out how many characters to skip at the start of an
1547 address, to make the disassembly look nicer. We discard leading
1548 zeroes in chunks of 4, ensuring that there is always a leading
1550 skip_addr_chars
= 0;
1551 if (! prefix_addresses
)
1555 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1557 while (buf
[skip_addr_chars
] == '0')
1560 /* Don't discard zeros on overflow. */
1561 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1562 skip_addr_chars
= 0;
1564 if (skip_addr_chars
!= 0)
1565 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1568 inf
->insn_info_valid
= 0;
1570 addr_offset
= start_offset
;
1571 while (addr_offset
< stop_offset
)
1574 bfd_boolean need_nl
= FALSE
;
1575 int previous_octets
;
1577 /* Remember the length of the previous instruction. */
1578 previous_octets
= octets
;
1581 /* Make sure we don't use relocs from previous instructions. */
1584 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1586 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1589 if (! disassemble_zeroes
1590 && (inf
->insn_info_valid
== 0
1591 || inf
->branch_delay_insns
== 0)
1592 && (z
- addr_offset
* opb
>= skip_zeroes
1593 || (z
== stop_offset
* opb
&&
1594 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1596 /* If there are more nonzero octets to follow, we only skip
1597 zeroes in multiples of 4, to try to avoid running over
1598 the start of an instruction which happens to start with
1600 if (z
!= stop_offset
* opb
)
1601 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1603 octets
= z
- addr_offset
* opb
;
1605 /* If we are going to display more data, and we are displaying
1606 file offsets, then tell the user how many zeroes we skip
1607 and the file offset from where we resume dumping. */
1608 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1609 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1611 (unsigned long) (section
->filepos
1612 + (addr_offset
+ (octets
/ opb
))));
1622 if (with_line_numbers
|| with_source_code
)
1623 show_line (aux
->abfd
, section
, addr_offset
);
1625 if (! prefix_addresses
)
1629 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1630 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1634 printf ("%s:\t", buf
+ skip_addr_chars
);
1638 aux
->require_sec
= TRUE
;
1639 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1640 aux
->require_sec
= FALSE
;
1647 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1648 inf
->stream
= &sfile
;
1649 inf
->bytes_per_line
= 0;
1650 inf
->bytes_per_chunk
= 0;
1651 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1653 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1655 if (inf
->disassembler_needs_relocs
1656 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1657 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1658 && *relppp
< relppend
)
1660 bfd_signed_vma distance_to_rel
;
1662 distance_to_rel
= (**relppp
)->address
1663 - (rel_offset
+ addr_offset
);
1665 /* Check to see if the current reloc is associated with
1666 the instruction that we are about to disassemble. */
1667 if (distance_to_rel
== 0
1668 /* FIXME: This is wrong. We are trying to catch
1669 relocs that are addressed part way through the
1670 current instruction, as might happen with a packed
1671 VLIW instruction. Unfortunately we do not know the
1672 length of the current instruction since we have not
1673 disassembled it yet. Instead we take a guess based
1674 upon the length of the previous instruction. The
1675 proper solution is to have a new target-specific
1676 disassembler function which just returns the length
1677 of an instruction at a given address without trying
1678 to display its disassembly. */
1679 || (distance_to_rel
> 0
1680 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1682 inf
->flags
|= INSN_HAS_RELOC
;
1683 aux
->reloc
= **relppp
;
1687 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1688 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1689 inf
->stream
= stdout
;
1690 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1691 octets_per_line
= inf
->bytes_per_line
;
1692 if (octets
< (int) opb
)
1695 printf ("%s\n", sfile
.buffer
);
1698 non_fatal (_("disassemble_fn returned length %d"),
1709 octets
= octets_per_line
;
1710 if (addr_offset
+ octets
/ opb
> stop_offset
)
1711 octets
= (stop_offset
- addr_offset
) * opb
;
1713 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1715 if (ISPRINT (data
[j
]))
1716 buf
[j
- addr_offset
* opb
] = data
[j
];
1718 buf
[j
- addr_offset
* opb
] = '.';
1720 buf
[j
- addr_offset
* opb
] = '\0';
1723 if (prefix_addresses
1725 : show_raw_insn
>= 0)
1729 /* If ! prefix_addresses and ! wide_output, we print
1730 octets_per_line octets per line. */
1732 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1733 pb
= octets_per_line
;
1735 if (inf
->bytes_per_chunk
)
1736 bpc
= inf
->bytes_per_chunk
;
1740 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1744 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1746 for (k
= bpc
- 1; k
>= 0; k
--)
1747 printf ("%02x", (unsigned) data
[j
+ k
]);
1752 for (k
= 0; k
< bpc
; k
++)
1753 printf ("%02x", (unsigned) data
[j
+ k
]);
1758 for (; pb
< octets_per_line
; pb
+= bpc
)
1762 for (k
= 0; k
< bpc
; k
++)
1767 /* Separate raw data from instruction by extra space. */
1777 printf ("%s", sfile
.buffer
);
1779 if (prefix_addresses
1781 : show_raw_insn
>= 0)
1789 j
= addr_offset
* opb
+ pb
;
1791 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1792 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1796 printf ("%s:\t", buf
+ skip_addr_chars
);
1798 pb
+= octets_per_line
;
1801 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1805 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1807 for (k
= bpc
- 1; k
>= 0; k
--)
1808 printf ("%02x", (unsigned) data
[j
+ k
]);
1813 for (k
= 0; k
< bpc
; k
++)
1814 printf ("%02x", (unsigned) data
[j
+ k
]);
1827 while ((*relppp
) < relppend
1828 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1830 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1841 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1844 if (q
->howto
== NULL
)
1845 printf (": *unknown*\t");
1846 else if (q
->howto
->name
)
1847 printf (": %s\t", q
->howto
->name
);
1849 printf (": %d\t", q
->howto
->type
);
1851 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1852 printf ("*unknown*");
1855 const char *sym_name
;
1857 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1858 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1859 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1864 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1865 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1866 if (sym_name
== NULL
|| *sym_name
== '\0')
1867 sym_name
= "*unknown*";
1868 printf ("%s", sym_name
);
1874 bfd_signed_vma addend
= q
->addend
;
1882 objdump_print_value (addend
, inf
, TRUE
);
1894 addr_offset
+= octets
/ opb
;
1897 free (sfile
.buffer
);
1901 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1903 const struct elf_backend_data
* bed
;
1904 bfd_vma sign_adjust
= 0;
1905 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1906 struct objdump_disasm_info
* paux
;
1907 unsigned int opb
= pinfo
->octets_per_byte
;
1908 bfd_byte
* data
= NULL
;
1909 bfd_size_type datasize
= 0;
1910 arelent
** rel_pp
= NULL
;
1911 arelent
** rel_ppstart
= NULL
;
1912 arelent
** rel_ppend
;
1913 unsigned long stop_offset
;
1914 asymbol
* sym
= NULL
;
1918 unsigned long addr_offset
;
1920 /* Sections that do not contain machine
1921 code are not normally disassembled. */
1922 if (! disassemble_all
1923 && only_list
== NULL
1924 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1925 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1928 if (! process_section_p (section
))
1931 datasize
= bfd_get_section_size (section
);
1935 if (start_address
== (bfd_vma
) -1
1936 || start_address
< section
->vma
)
1939 addr_offset
= start_address
- section
->vma
;
1941 if (stop_address
== (bfd_vma
) -1)
1942 stop_offset
= datasize
/ opb
;
1945 if (stop_address
< section
->vma
)
1948 stop_offset
= stop_address
- section
->vma
;
1949 if (stop_offset
> datasize
/ opb
)
1950 stop_offset
= datasize
/ opb
;
1953 if (addr_offset
>= stop_offset
)
1956 /* Decide which set of relocs to use. Load them if necessary. */
1957 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1958 if (paux
->dynrelbuf
)
1960 rel_pp
= paux
->dynrelbuf
;
1961 rel_count
= paux
->dynrelcount
;
1962 /* Dynamic reloc addresses are absolute, non-dynamic are section
1963 relative. REL_OFFSET specifies the reloc address corresponding
1964 to the start of this section. */
1965 rel_offset
= section
->vma
;
1973 if ((section
->flags
& SEC_RELOC
) != 0
1974 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1978 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1980 bfd_fatal (bfd_get_filename (abfd
));
1984 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1985 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1987 bfd_fatal (bfd_get_filename (abfd
));
1989 /* Sort the relocs by address. */
1990 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1994 rel_ppend
= rel_pp
+ rel_count
;
1996 data
= (bfd_byte
*) xmalloc (datasize
);
1998 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2000 paux
->sec
= section
;
2001 pinfo
->buffer
= data
;
2002 pinfo
->buffer_vma
= section
->vma
;
2003 pinfo
->buffer_length
= datasize
;
2004 pinfo
->section
= section
;
2006 /* Skip over the relocs belonging to addresses below the
2008 while (rel_pp
< rel_ppend
2009 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2012 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2014 /* Find the nearest symbol forwards from our current position. */
2015 paux
->require_sec
= TRUE
;
2016 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2017 (struct disassemble_info
*) inf
,
2019 paux
->require_sec
= FALSE
;
2021 /* PR 9774: If the target used signed addresses then we must make
2022 sure that we sign extend the value that we calculate for 'addr'
2023 in the loop below. */
2024 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2025 && (bed
= get_elf_backend_data (abfd
)) != NULL
2026 && bed
->sign_extend_vma
)
2027 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2029 /* Disassemble a block of instructions up to the address associated with
2030 the symbol we have just found. Then print the symbol and find the
2031 next symbol on. Repeat until we have disassembled the entire section
2032 or we have reached the end of the address range we are interested in. */
2033 while (addr_offset
< stop_offset
)
2037 unsigned long nextstop_offset
;
2040 addr
= section
->vma
+ addr_offset
;
2041 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2043 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2048 (x
< sorted_symcount
2049 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2053 pinfo
->symbols
= sorted_syms
+ place
;
2054 pinfo
->num_symbols
= x
- place
;
2055 pinfo
->symtab_pos
= place
;
2059 pinfo
->symbols
= NULL
;
2060 pinfo
->num_symbols
= 0;
2061 pinfo
->symtab_pos
= -1;
2064 if (! prefix_addresses
)
2066 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2067 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2069 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2072 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2074 else if (sym
== NULL
)
2078 #define is_valid_next_sym(SYM) \
2079 ((SYM)->section == section \
2080 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2081 && pinfo->symbol_is_valid (SYM, pinfo))
2083 /* Search forward for the next appropriate symbol in
2084 SECTION. Note that all the symbols are sorted
2085 together into one big array, and that some sections
2086 may have overlapping addresses. */
2087 while (place
< sorted_symcount
2088 && ! is_valid_next_sym (sorted_syms
[place
]))
2091 if (place
>= sorted_symcount
)
2094 nextsym
= sorted_syms
[place
];
2097 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2098 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2099 else if (nextsym
== NULL
)
2100 nextstop_offset
= stop_offset
;
2102 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2104 if (nextstop_offset
> stop_offset
2105 || nextstop_offset
<= addr_offset
)
2106 nextstop_offset
= stop_offset
;
2108 /* If a symbol is explicitly marked as being an object
2109 rather than a function, just dump the bytes without
2110 disassembling them. */
2113 || sym
->section
!= section
2114 || bfd_asymbol_value (sym
) > addr
2115 || ((sym
->flags
& BSF_OBJECT
) == 0
2116 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2118 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2120 || (sym
->flags
& BSF_FUNCTION
) != 0)
2125 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2126 addr_offset
, nextstop_offset
,
2127 rel_offset
, &rel_pp
, rel_ppend
);
2129 addr_offset
= nextstop_offset
;
2135 if (rel_ppstart
!= NULL
)
2139 /* Disassemble the contents of an object file. */
2142 disassemble_data (bfd
*abfd
)
2144 struct disassemble_info disasm_info
;
2145 struct objdump_disasm_info aux
;
2149 prev_functionname
= NULL
;
2151 prev_discriminator
= 0;
2153 /* We make a copy of syms to sort. We don't want to sort syms
2154 because that will screw up the relocs. */
2155 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2156 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2157 * sizeof (asymbol
*));
2158 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2159 sorted_symcount
* sizeof (asymbol
*));
2161 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2163 for (i
= 0; i
< synthcount
; ++i
)
2165 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2169 /* Sort the symbols into section and symbol order. */
2170 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2172 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2174 disasm_info
.application_data
= (void *) &aux
;
2176 aux
.require_sec
= FALSE
;
2177 aux
.dynrelbuf
= NULL
;
2178 aux
.dynrelcount
= 0;
2181 disasm_info
.print_address_func
= objdump_print_address
;
2182 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2184 if (machine
!= NULL
)
2186 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2189 fatal (_("can't use supplied machine %s"), machine
);
2191 abfd
->arch_info
= inf
;
2194 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2196 struct bfd_target
*xvec
;
2198 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2199 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2200 xvec
->byteorder
= endian
;
2204 /* Use libopcodes to locate a suitable disassembler. */
2205 aux
.disassemble_fn
= disassembler (abfd
);
2206 if (!aux
.disassemble_fn
)
2208 non_fatal (_("can't disassemble for architecture %s\n"),
2209 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2214 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2215 disasm_info
.arch
= bfd_get_arch (abfd
);
2216 disasm_info
.mach
= bfd_get_mach (abfd
);
2217 disasm_info
.disassembler_options
= disassembler_options
;
2218 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2219 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2220 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2221 disasm_info
.disassembler_needs_relocs
= FALSE
;
2223 if (bfd_big_endian (abfd
))
2224 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2225 else if (bfd_little_endian (abfd
))
2226 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2228 /* ??? Aborting here seems too drastic. We could default to big or little
2230 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2232 /* Allow the target to customize the info structure. */
2233 disassemble_init_for_target (& disasm_info
);
2235 /* Pre-load the dynamic relocs if we are going
2236 to be dumping them along with the disassembly. */
2237 if (dump_dynamic_reloc_info
)
2239 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2242 bfd_fatal (bfd_get_filename (abfd
));
2246 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2247 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2250 if (aux
.dynrelcount
< 0)
2251 bfd_fatal (bfd_get_filename (abfd
));
2253 /* Sort the relocs by address. */
2254 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2258 disasm_info
.symtab
= sorted_syms
;
2259 disasm_info
.symtab_size
= sorted_symcount
;
2261 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2263 if (aux
.dynrelbuf
!= NULL
)
2264 free (aux
.dynrelbuf
);
2269 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2270 asection
*sec
, void *file
)
2272 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2273 bfd
*abfd
= (bfd
*) file
;
2276 /* If it is already loaded, do nothing. */
2277 if (section
->start
!= NULL
)
2280 section
->address
= bfd_get_section_vma (abfd
, sec
);
2281 section
->size
= bfd_get_section_size (sec
);
2282 section
->start
= NULL
;
2283 section
->user_data
= sec
;
2284 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2288 free_debug_section (debug
);
2289 printf (_("\nCan't get contents for section '%s'.\n"),
2294 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2296 bfd_cache_section_contents (sec
, section
->start
);
2298 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2305 free_debug_section (debug
);
2306 printf (_("\nCan't get contents for section '%s'.\n"),
2316 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2318 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2319 bfd
*abfd
= (bfd
*) file
;
2322 /* If it is already loaded, do nothing. */
2323 if (section
->start
!= NULL
)
2326 /* Locate the debug section. */
2327 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2329 section
->name
= section
->uncompressed_name
;
2332 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2334 section
->name
= section
->compressed_name
;
2339 return load_specific_debug_section (debug
, sec
, file
);
2343 free_debug_section (enum dwarf_section_display_enum debug
)
2345 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2347 if (section
->start
== NULL
)
2350 /* PR 17512: file: 0f67f69d. */
2351 if (section
->user_data
!= NULL
)
2353 asection
* sec
= (asection
*) section
->user_data
;
2355 /* If we are freeing contents that are also pointed to by the BFD
2356 library's section structure then make sure to update those pointers
2357 too. Otherwise, the next time we try to load data for this section
2358 we can end up using a stale pointer. */
2359 if (section
->start
== sec
->contents
)
2361 sec
->contents
= NULL
;
2362 sec
->flags
&= ~ SEC_IN_MEMORY
;
2363 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2367 free ((char *) section
->start
);
2368 section
->start
= NULL
;
2369 section
->address
= 0;
2374 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2375 void *arg ATTRIBUTE_UNUSED
)
2377 const char *name
= bfd_get_section_name (abfd
, section
);
2381 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2382 match
= ".debug_info";
2386 for (i
= 0; i
< max
; i
++)
2387 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2388 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2389 && debug_displays
[i
].enabled
!= NULL
2390 && *debug_displays
[i
].enabled
)
2392 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2394 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2395 sec
->name
= sec
->uncompressed_name
;
2397 sec
->name
= sec
->compressed_name
;
2398 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2401 debug_displays
[i
].display (sec
, abfd
);
2403 if (i
!= info
&& i
!= abbrev
)
2404 free_debug_section ((enum dwarf_section_display_enum
) i
);
2410 /* Dump the dwarf debugging information. */
2413 dump_dwarf (bfd
*abfd
)
2415 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2417 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2419 if (bfd_big_endian (abfd
))
2420 byte_get
= byte_get_big_endian
;
2421 else if (bfd_little_endian (abfd
))
2422 byte_get
= byte_get_little_endian
;
2424 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2426 warn (_("File %s does not contain any dwarf debug information\n"),
2427 bfd_get_filename (abfd
));
2431 switch (bfd_get_arch (abfd
))
2434 switch (bfd_get_mach (abfd
))
2436 case bfd_mach_x86_64
:
2437 case bfd_mach_x86_64_intel_syntax
:
2438 case bfd_mach_x86_64_nacl
:
2439 case bfd_mach_x64_32
:
2440 case bfd_mach_x64_32_intel_syntax
:
2441 case bfd_mach_x64_32_nacl
:
2442 init_dwarf_regnames_x86_64 ();
2446 init_dwarf_regnames_i386 ();
2451 case bfd_arch_aarch64
:
2452 init_dwarf_regnames_aarch64();
2459 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2461 free_debug_memory ();
2464 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2465 it. Return NULL on failure. */
2468 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2474 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2475 if (stabsect
== NULL
)
2477 printf (_("No %s section present\n\n"), sect_name
);
2481 size
= bfd_section_size (abfd
, stabsect
);
2482 contents
= (char *) xmalloc (size
);
2484 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2486 non_fatal (_("reading %s section of %s failed: %s"),
2487 sect_name
, bfd_get_filename (abfd
),
2488 bfd_errmsg (bfd_get_error ()));
2499 /* Stabs entries use a 12 byte format:
2500 4 byte string table index
2502 1 byte stab other field
2503 2 byte stab desc field
2505 FIXME: This will have to change for a 64 bit object format. */
2507 #define STRDXOFF (0)
2509 #define OTHEROFF (5)
2512 #define STABSIZE (12)
2514 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2515 using string table section STRSECT_NAME (in `strtab'). */
2518 print_section_stabs (bfd
*abfd
,
2519 const char *stabsect_name
,
2520 unsigned *string_offset_ptr
)
2523 unsigned file_string_table_offset
= 0;
2524 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2525 bfd_byte
*stabp
, *stabs_end
;
2528 stabs_end
= stabp
+ stab_size
;
2530 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2531 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2533 /* Loop through all symbols and print them.
2535 We start the index at -1 because there is a dummy symbol on
2536 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2537 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2541 unsigned char type
, other
;
2542 unsigned short desc
;
2545 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2546 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2547 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2548 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2549 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2551 printf ("\n%-6d ", i
);
2552 /* Either print the stab name, or, if unnamed, print its number
2553 again (makes consistent formatting for tools like awk). */
2554 name
= bfd_get_stab_name (type
);
2556 printf ("%-6s", name
);
2557 else if (type
== N_UNDF
)
2560 printf ("%-6d", type
);
2561 printf (" %-6d %-6d ", other
, desc
);
2562 bfd_printf_vma (abfd
, value
);
2563 printf (" %-6lu", strx
);
2565 /* Symbols with type == 0 (N_UNDF) specify the length of the
2566 string table associated with this file. We use that info
2567 to know how to relocate the *next* file's string table indices. */
2570 file_string_table_offset
= next_file_string_table_offset
;
2571 next_file_string_table_offset
+= value
;
2575 bfd_size_type amt
= strx
+ file_string_table_offset
;
2577 /* Using the (possibly updated) string table offset, print the
2578 string (if any) associated with this symbol. */
2579 if (amt
< stabstr_size
)
2580 /* PR 17512: file: 079-79389-0.001:0.1. */
2581 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2587 *string_offset_ptr
= next_file_string_table_offset
;
2592 const char * section_name
;
2593 const char * string_section_name
;
2594 unsigned string_offset
;
2599 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2602 stab_section_names
* sought
= (stab_section_names
*) names
;
2604 /* Check for section names for which stabsect_name is a prefix, to
2605 handle .stab.N, etc. */
2606 len
= strlen (sought
->section_name
);
2608 /* If the prefix matches, and the files section name ends with a
2609 nul or a digit, then we match. I.e., we want either an exact
2610 match or a section followed by a number. */
2611 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2612 && (section
->name
[len
] == 0
2613 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2616 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2621 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2624 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2630 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2632 stab_section_names s
;
2634 s
.section_name
= stabsect_name
;
2635 s
.string_section_name
= strsect_name
;
2636 s
.string_offset
= 0;
2638 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2644 /* Dump the any sections containing stabs debugging information. */
2647 dump_stabs (bfd
*abfd
)
2649 dump_stabs_section (abfd
, ".stab", ".stabstr");
2650 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2651 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2654 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2656 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2660 dump_bfd_header (bfd
*abfd
)
2664 printf (_("architecture: %s, "),
2665 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2666 bfd_get_mach (abfd
)));
2667 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2669 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2670 PF (HAS_RELOC
, "HAS_RELOC");
2671 PF (EXEC_P
, "EXEC_P");
2672 PF (HAS_LINENO
, "HAS_LINENO");
2673 PF (HAS_DEBUG
, "HAS_DEBUG");
2674 PF (HAS_SYMS
, "HAS_SYMS");
2675 PF (HAS_LOCALS
, "HAS_LOCALS");
2676 PF (DYNAMIC
, "DYNAMIC");
2677 PF (WP_TEXT
, "WP_TEXT");
2678 PF (D_PAGED
, "D_PAGED");
2679 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2680 printf (_("\nstart address 0x"));
2681 bfd_printf_vma (abfd
, abfd
->start_address
);
2687 dump_bfd_private_header (bfd
*abfd
)
2689 bfd_print_private_bfd_data (abfd
, stdout
);
2693 dump_target_specific (bfd
*abfd
)
2695 const struct objdump_private_desc
* const *desc
;
2696 struct objdump_private_option
*opt
;
2699 /* Find the desc. */
2700 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2701 if ((*desc
)->filter (abfd
))
2706 non_fatal (_("option -P/--private not supported by this file"));
2710 /* Clear all options. */
2711 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2712 opt
->selected
= FALSE
;
2714 /* Decode options. */
2715 b
= dump_private_options
;
2718 e
= strchr (b
, ',');
2723 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2724 if (strcmp (opt
->name
, b
) == 0)
2726 opt
->selected
= TRUE
;
2729 if (opt
->name
== NULL
)
2730 non_fatal (_("target specific dump '%s' not supported"), b
);
2741 (*desc
)->dump (abfd
);
2744 /* Display a section in hexadecimal format with associated characters.
2745 Each line prefixed by the zero padded address. */
2748 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2751 bfd_size_type datasize
;
2752 bfd_size_type addr_offset
;
2753 bfd_size_type start_offset
;
2754 bfd_size_type stop_offset
;
2755 unsigned int opb
= bfd_octets_per_byte (abfd
);
2756 /* Bytes per line. */
2757 const int onaline
= 16;
2762 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2765 if (! process_section_p (section
))
2768 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2771 /* Compute the address range to display. */
2772 if (start_address
== (bfd_vma
) -1
2773 || start_address
< section
->vma
)
2776 start_offset
= start_address
- section
->vma
;
2778 if (stop_address
== (bfd_vma
) -1)
2779 stop_offset
= datasize
/ opb
;
2782 if (stop_address
< section
->vma
)
2785 stop_offset
= stop_address
- section
->vma
;
2787 if (stop_offset
> datasize
/ opb
)
2788 stop_offset
= datasize
/ opb
;
2791 if (start_offset
>= stop_offset
)
2794 printf (_("Contents of section %s:"), section
->name
);
2795 if (display_file_offsets
)
2796 printf (_(" (Starting at file offset: 0x%lx)"),
2797 (unsigned long) (section
->filepos
+ start_offset
));
2800 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2802 non_fatal (_("Reading section failed"));
2808 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2809 if (strlen (buf
) >= sizeof (buf
))
2813 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2815 count
= strlen (buf
) - count
;
2819 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2820 if (strlen (buf
) >= sizeof (buf
))
2824 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2826 count
= strlen (buf
) - count
;
2830 for (addr_offset
= start_offset
;
2831 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2835 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2836 count
= strlen (buf
);
2837 if ((size_t) count
>= sizeof (buf
))
2841 while (count
< width
)
2846 fputs (buf
+ count
- width
, stdout
);
2849 for (j
= addr_offset
* opb
;
2850 j
< addr_offset
* opb
+ onaline
; j
++)
2852 if (j
< stop_offset
* opb
)
2853 printf ("%02x", (unsigned) (data
[j
]));
2861 for (j
= addr_offset
* opb
;
2862 j
< addr_offset
* opb
+ onaline
; j
++)
2864 if (j
>= stop_offset
* opb
)
2867 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2874 /* Actually display the various requested regions. */
2877 dump_data (bfd
*abfd
)
2879 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2882 /* Should perhaps share code and display with nm? */
2885 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2894 max_count
= dynsymcount
;
2895 printf ("DYNAMIC SYMBOL TABLE:\n");
2900 max_count
= symcount
;
2901 printf ("SYMBOL TABLE:\n");
2905 printf (_("no symbols\n"));
2907 for (count
= 0; count
< max_count
; count
++)
2911 if (*current
== NULL
)
2912 printf (_("no information for symbol number %ld\n"), count
);
2914 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2915 printf (_("could not determine the type of symbol number %ld\n"),
2918 else if (process_section_p ((* current
)->section
)
2919 && (dump_special_syms
2920 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2922 const char *name
= (*current
)->name
;
2924 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2928 /* If we want to demangle the name, we demangle it
2929 here, and temporarily clobber it while calling
2930 bfd_print_symbol. FIXME: This is a gross hack. */
2931 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2933 (*current
)->name
= alloc
;
2934 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2935 bfd_print_symbol_all
);
2938 (*current
)->name
= name
;
2943 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2944 bfd_print_symbol_all
);
2954 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2957 char *last_filename
, *last_functionname
;
2958 unsigned int last_line
;
2959 unsigned int last_discriminator
;
2961 /* Get column headers lined up reasonably. */
2969 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2970 width
= strlen (buf
) - 7;
2972 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2975 last_filename
= NULL
;
2976 last_functionname
= NULL
;
2978 last_discriminator
= 0;
2980 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2983 const char *filename
, *functionname
;
2984 unsigned int linenumber
;
2985 unsigned int discriminator
;
2986 const char *sym_name
;
2987 const char *section_name
;
2988 bfd_vma addend2
= 0;
2990 if (start_address
!= (bfd_vma
) -1
2991 && q
->address
< start_address
)
2993 if (stop_address
!= (bfd_vma
) -1
2994 && q
->address
> stop_address
)
2997 if (with_line_numbers
2999 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3000 &filename
, &functionname
,
3001 &linenumber
, &discriminator
))
3003 if (functionname
!= NULL
3004 && (last_functionname
== NULL
3005 || strcmp (functionname
, last_functionname
) != 0))
3007 printf ("%s():\n", functionname
);
3008 if (last_functionname
!= NULL
)
3009 free (last_functionname
);
3010 last_functionname
= xstrdup (functionname
);
3014 && (linenumber
!= last_line
3015 || (filename
!= NULL
3016 && last_filename
!= NULL
3017 && filename_cmp (filename
, last_filename
) != 0)
3018 || (discriminator
!= last_discriminator
)))
3020 if (discriminator
> 0)
3021 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3023 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3024 linenumber
, discriminator
);
3025 last_line
= linenumber
;
3026 last_discriminator
= discriminator
;
3027 if (last_filename
!= NULL
)
3028 free (last_filename
);
3029 if (filename
== NULL
)
3030 last_filename
= NULL
;
3032 last_filename
= xstrdup (filename
);
3036 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3038 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3039 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3044 section_name
= NULL
;
3047 bfd_printf_vma (abfd
, q
->address
);
3048 if (q
->howto
== NULL
)
3049 printf (" *unknown* ");
3050 else if (q
->howto
->name
)
3052 const char *name
= q
->howto
->name
;
3054 /* R_SPARC_OLO10 relocations contain two addends.
3055 But because 'arelent' lacks enough storage to
3056 store them both, the 64-bit ELF Sparc backend
3057 records this as two relocations. One R_SPARC_LO10
3058 and one R_SPARC_13, both pointing to the same
3059 address. This is merely so that we have some
3060 place to store both addend fields.
3062 Undo this transformation, otherwise the output
3063 will be confusing. */
3064 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3065 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3067 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3069 arelent
*q2
= *(p
+ 1);
3072 && q
->address
== q2
->address
3073 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3075 name
= "R_SPARC_OLO10";
3076 addend2
= q2
->addend
;
3080 printf (" %-16s ", name
);
3083 printf (" %-16d ", q
->howto
->type
);
3087 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3091 if (section_name
== NULL
)
3092 section_name
= "*unknown*";
3093 printf ("[%s]", section_name
);
3098 bfd_signed_vma addend
= q
->addend
;
3106 bfd_printf_vma (abfd
, addend
);
3111 bfd_printf_vma (abfd
, addend2
);
3117 if (last_filename
!= NULL
)
3118 free (last_filename
);
3119 if (last_functionname
!= NULL
)
3120 free (last_functionname
);
3124 dump_relocs_in_section (bfd
*abfd
,
3126 void *dummy ATTRIBUTE_UNUSED
)
3132 if ( bfd_is_abs_section (section
)
3133 || bfd_is_und_section (section
)
3134 || bfd_is_com_section (section
)
3135 || (! process_section_p (section
))
3136 || ((section
->flags
& SEC_RELOC
) == 0))
3139 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3141 bfd_fatal (bfd_get_filename (abfd
));
3143 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3147 printf (" (none)\n\n");
3151 relpp
= (arelent
**) xmalloc (relsize
);
3152 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3157 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3158 bfd_fatal (_("error message was"));
3160 else if (relcount
== 0)
3161 printf (" (none)\n\n");
3165 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3172 dump_relocs (bfd
*abfd
)
3174 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3178 dump_dynamic_relocs (bfd
*abfd
)
3184 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3186 bfd_fatal (bfd_get_filename (abfd
));
3188 printf ("DYNAMIC RELOCATION RECORDS");
3191 printf (" (none)\n\n");
3194 relpp
= (arelent
**) xmalloc (relsize
);
3195 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3198 bfd_fatal (bfd_get_filename (abfd
));
3199 else if (relcount
== 0)
3200 printf (" (none)\n\n");
3204 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3211 /* Creates a table of paths, to search for source files. */
3214 add_include_path (const char *path
)
3218 include_path_count
++;
3219 include_paths
= (const char **)
3220 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3221 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3222 if (path
[1] == ':' && path
[2] == 0)
3223 path
= concat (path
, ".", (const char *) 0);
3225 include_paths
[include_path_count
- 1] = path
;
3229 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3233 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3235 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3236 section
->vma
+= adjust_section_vma
;
3238 section
->lma
+= adjust_section_vma
;
3242 /* Dump selected contents of ABFD. */
3245 dump_bfd (bfd
*abfd
)
3247 /* If we are adjusting section VMA's, change them all now. Changing
3248 the BFD information is a hack. However, we must do it, or
3249 bfd_find_nearest_line will not do the right thing. */
3250 if (adjust_section_vma
!= 0)
3252 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3253 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3256 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3257 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3260 print_arelt_descr (stdout
, abfd
, TRUE
);
3261 if (dump_file_header
)
3262 dump_bfd_header (abfd
);
3263 if (dump_private_headers
)
3264 dump_bfd_private_header (abfd
);
3265 if (dump_private_options
!= NULL
)
3266 dump_target_specific (abfd
);
3267 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3274 || dump_dwarf_section_info
)
3275 syms
= slurp_symtab (abfd
);
3277 if (dump_section_headers
)
3278 dump_headers (abfd
);
3280 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3281 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3282 dynsyms
= slurp_dynamic_symtab (abfd
);
3285 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3286 dynsymcount
, dynsyms
, &synthsyms
);
3292 dump_symbols (abfd
, FALSE
);
3293 if (dump_dynamic_symtab
)
3294 dump_symbols (abfd
, TRUE
);
3295 if (dump_dwarf_section_info
)
3297 if (dump_stab_section_info
)
3299 if (dump_reloc_info
&& ! disassemble
)
3301 if (dump_dynamic_reloc_info
&& ! disassemble
)
3302 dump_dynamic_relocs (abfd
);
3303 if (dump_section_contents
)
3306 disassemble_data (abfd
);
3312 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3313 if (dhandle
!= NULL
)
3315 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3317 dump_debugging_tags
? TRUE
: FALSE
))
3319 non_fatal (_("%s: printing debugging information failed"),
3320 bfd_get_filename (abfd
));
3324 /* PR 6483: If there was no STABS or IEEE debug
3325 info in the file, try DWARF instead. */
3326 else if (! dump_dwarf_section_info
)
3328 dwarf_select_sections_all ();
3357 display_object_bfd (bfd
*abfd
)
3361 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3367 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3369 nonfatal (bfd_get_filename (abfd
));
3370 list_matching_formats (matching
);
3375 if (bfd_get_error () != bfd_error_file_not_recognized
)
3377 nonfatal (bfd_get_filename (abfd
));
3381 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3387 nonfatal (bfd_get_filename (abfd
));
3389 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3391 list_matching_formats (matching
);
3397 display_any_bfd (bfd
*file
, int level
)
3399 /* Decompress sections unless dumping the section contents. */
3400 if (!dump_section_contents
)
3401 file
->flags
|= BFD_DECOMPRESS
;
3403 /* If the file is an archive, process all of its elements. */
3404 if (bfd_check_format (file
, bfd_archive
))
3407 bfd
*last_arfile
= NULL
;
3410 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3412 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3416 bfd_set_error (bfd_error_no_error
);
3418 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3421 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3422 nonfatal (bfd_get_filename (file
));
3426 display_any_bfd (arfile
, level
+ 1);
3428 if (last_arfile
!= NULL
)
3430 bfd_close (last_arfile
);
3431 /* PR 17512: file: ac585d01. */
3432 if (arfile
== last_arfile
)
3438 last_arfile
= arfile
;
3441 if (last_arfile
!= NULL
)
3442 bfd_close (last_arfile
);
3445 display_object_bfd (file
);
3449 display_file (char *filename
, char *target
)
3453 if (get_file_size (filename
) < 1)
3459 file
= bfd_openr (filename
, target
);
3462 nonfatal (filename
);
3466 display_any_bfd (file
, 0);
3472 main (int argc
, char **argv
)
3475 char *target
= default_target
;
3476 bfd_boolean seenflag
= FALSE
;
3478 #if defined (HAVE_SETLOCALE)
3479 #if defined (HAVE_LC_MESSAGES)
3480 setlocale (LC_MESSAGES
, "");
3482 setlocale (LC_CTYPE
, "");
3485 bindtextdomain (PACKAGE
, LOCALEDIR
);
3486 textdomain (PACKAGE
);
3488 program_name
= *argv
;
3489 xmalloc_set_program_name (program_name
);
3491 START_PROGRESS (program_name
, 0);
3493 expandargv (&argc
, &argv
);
3496 set_default_bfd_target ();
3498 while ((c
= getopt_long (argc
, argv
,
3499 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3500 long_options
, (int *) 0))
3506 break; /* We've been given a long option. */
3511 if (disassembler_options
)
3512 /* Ignore potential memory leak for now. */
3513 disassembler_options
= concat (disassembler_options
, ",",
3514 optarg
, (const char *) NULL
);
3516 disassembler_options
= optarg
;
3522 display_file_offsets
= TRUE
;
3525 with_line_numbers
= TRUE
;
3534 enum demangling_styles style
;
3536 style
= cplus_demangle_name_to_style (optarg
);
3537 if (style
== unknown_demangling
)
3538 fatal (_("unknown demangling style `%s'"),
3541 cplus_demangle_set_style (style
);
3547 case OPTION_ADJUST_VMA
:
3548 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3550 case OPTION_START_ADDRESS
:
3551 start_address
= parse_vma (optarg
, "--start-address");
3552 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3553 fatal (_("error: the start address should be before the end address"));
3555 case OPTION_STOP_ADDRESS
:
3556 stop_address
= parse_vma (optarg
, "--stop-address");
3557 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3558 fatal (_("error: the stop address should be after the start address"));
3562 prefix_length
= strlen (prefix
);
3563 /* Remove an unnecessary trailing '/' */
3564 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3567 case OPTION_PREFIX_STRIP
:
3568 prefix_strip
= atoi (optarg
);
3569 if (prefix_strip
< 0)
3570 fatal (_("error: prefix strip must be non-negative"));
3572 case OPTION_INSN_WIDTH
:
3573 insn_width
= strtoul (optarg
, NULL
, 0);
3574 if (insn_width
<= 0)
3575 fatal (_("error: instruction width must be positive"));
3578 if (strcmp (optarg
, "B") == 0)
3579 endian
= BFD_ENDIAN_BIG
;
3580 else if (strcmp (optarg
, "L") == 0)
3581 endian
= BFD_ENDIAN_LITTLE
;
3584 nonfatal (_("unrecognized -E option"));
3589 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3590 endian
= BFD_ENDIAN_BIG
;
3591 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3592 endian
= BFD_ENDIAN_LITTLE
;
3595 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3602 dump_file_header
= TRUE
;
3606 formats_info
= TRUE
;
3610 add_include_path (optarg
);
3613 dump_private_headers
= TRUE
;
3617 dump_private_options
= optarg
;
3621 dump_private_headers
= TRUE
;
3623 dump_reloc_info
= TRUE
;
3624 dump_file_header
= TRUE
;
3625 dump_ar_hdrs
= TRUE
;
3626 dump_section_headers
= TRUE
;
3634 dump_dynamic_symtab
= TRUE
;
3642 disassemble_zeroes
= TRUE
;
3646 disassemble_all
= TRUE
;
3651 with_source_code
= TRUE
;
3660 dump_debugging_tags
= 1;
3665 dump_dwarf_section_info
= TRUE
;
3668 dwarf_select_sections_by_letters (optarg
);
3670 dwarf_select_sections_all ();
3673 dump_dwarf_section_info
= TRUE
;
3676 dwarf_select_sections_by_names (optarg
);
3678 dwarf_select_sections_all ();
3680 case OPTION_DWARF_DEPTH
:
3683 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3686 case OPTION_DWARF_START
:
3689 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3690 suppress_bfd_header
= 1;
3693 case OPTION_DWARF_CHECK
:
3697 dump_stab_section_info
= TRUE
;
3701 dump_section_contents
= TRUE
;
3705 dump_reloc_info
= TRUE
;
3709 dump_dynamic_reloc_info
= TRUE
;
3713 dump_ar_hdrs
= TRUE
;
3717 dump_section_headers
= TRUE
;
3722 show_version
= TRUE
;
3728 /* No need to set seenflag or to break - usage() does not return. */
3735 print_version ("objdump");
3741 exit_status
= display_info ();
3745 display_file ("a.out", target
);
3747 for (; optind
< argc
;)
3748 display_file (argv
[optind
++], target
);
3753 END_PROGRESS (program_name
);