1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2016 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. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status
= 0;
80 static char *default_target
= NULL
; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version
= 0; /* Show the version number. */
85 static int dump_section_contents
; /* -s */
86 static int dump_section_headers
; /* -h */
87 static bfd_boolean dump_file_header
; /* -f */
88 static int dump_symtab
; /* -t */
89 static int dump_dynamic_symtab
; /* -T */
90 static int dump_reloc_info
; /* -r */
91 static int dump_dynamic_reloc_info
; /* -R */
92 static int dump_ar_hdrs
; /* -a */
93 static int dump_private_headers
; /* -p */
94 static char *dump_private_options
; /* -P */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int suppress_bfd_header
;
113 static int dump_special_syms
= 0; /* --special-syms */
114 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
115 static int file_start_context
= 0; /* --file-start-context */
116 static bfd_boolean display_file_offsets
;/* -F */
117 static const char *prefix
; /* --prefix */
118 static int prefix_strip
; /* --prefix-strip */
119 static size_t prefix_length
;
121 /* A structure to record the sections mentioned in -j switches. */
124 const char * name
; /* The name of the section. */
125 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
126 struct only
* next
; /* Pointer to the next structure in the list. */
128 /* Pointer to an array of 'only' structures.
129 This pointer is NULL if the -j switch has not been used. */
130 static struct only
* only_list
= NULL
;
132 /* Variables for handling include file path table. */
133 static const char **include_paths
;
134 static int include_path_count
;
136 /* Extra info to pass to the section disassembler and address printing
138 struct objdump_disasm_info
142 bfd_boolean require_sec
;
143 arelent
** dynrelbuf
;
145 disassembler_ftype disassemble_fn
;
149 /* Architecture to disassemble for, or default if NULL. */
150 static char *machine
= NULL
;
152 /* Target specific options to the disassembler. */
153 static char *disassembler_options
= NULL
;
155 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
156 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
158 /* The symbol table. */
159 static asymbol
**syms
;
161 /* Number of symbols in `syms'. */
162 static long symcount
= 0;
164 /* The sorted symbol table. */
165 static asymbol
**sorted_syms
;
167 /* Number of symbols in `sorted_syms'. */
168 static long sorted_symcount
= 0;
170 /* The dynamic symbol table. */
171 static asymbol
**dynsyms
;
173 /* The synthetic symbol table. */
174 static asymbol
*synthsyms
;
175 static long synthcount
= 0;
177 /* Number of symbols in `dynsyms'. */
178 static long dynsymcount
= 0;
180 static bfd_byte
*stabs
;
181 static bfd_size_type stab_size
;
184 static bfd_size_type stabstr_size
;
186 static bfd_boolean is_relocatable
= FALSE
;
188 /* Handlers for -P/--private. */
189 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
191 OBJDUMP_PRIVATE_VECTORS
195 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
197 usage (FILE *stream
, int status
)
199 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
200 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
201 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
202 fprintf (stream
, _("\
203 -a, --archive-headers Display archive header information\n\
204 -f, --file-headers Display the contents of the overall file header\n\
205 -p, --private-headers Display object format specific file header contents\n\
206 -P, --private=OPT,OPT... Display object format specific contents\n\
207 -h, --[section-]headers Display the contents of the section headers\n\
208 -x, --all-headers Display the contents of all headers\n\
209 -d, --disassemble Display assembler contents of executable sections\n\
210 -D, --disassemble-all Display assembler contents of all sections\n\
211 -S, --source Intermix source code with disassembly\n\
212 -s, --full-contents Display the full contents of all sections requested\n\
213 -g, --debugging Display debug information in object file\n\
214 -e, --debugging-tags Display debug information using ctags style\n\
215 -G, --stabs Display (in raw form) any STABS info in the file\n\
216 -W[lLiaprmfFsoRt] or\n\
217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
221 Display DWARF info in the file\n\
222 -t, --syms Display the contents of the symbol table(s)\n\
223 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
224 -r, --reloc Display the relocation entries in the file\n\
225 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
226 @<file> Read options from <file>\n\
227 -v, --version Display this program's version number\n\
228 -i, --info List object formats and architectures supported\n\
229 -H, --help Display this information\n\
233 const struct objdump_private_desc
* const *desc
;
235 fprintf (stream
, _("\n The following switches are optional:\n"));
236 fprintf (stream
, _("\
237 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
238 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
239 -j, --section=NAME Only display information for section NAME\n\
240 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
241 -EB --endian=big Assume big endian format when disassembling\n\
242 -EL --endian=little Assume little endian format when disassembling\n\
243 --file-start-context Include context from start of file (with -S)\n\
244 -I, --include=DIR Add DIR to search list for source files\n\
245 -l, --line-numbers Include line numbers and filenames in output\n\
246 -F, --file-offsets Include file offsets when displaying information\n\
247 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
248 The STYLE, if specified, can be `auto', `gnu',\n\
249 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251 -w, --wide Format output for more than 80 columns\n\
252 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
253 --start-address=ADDR Only process data whose address is >= ADDR\n\
254 --stop-address=ADDR Only process data whose address is <= ADDR\n\
255 --prefix-addresses Print complete address alongside disassembly\n\
256 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
257 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
258 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
259 --special-syms Include special symbols in symbol dumps\n\
260 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
261 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
262 fprintf (stream
, _("\
263 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
264 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
266 --dwarf-check Make additional dwarf internal consistency checks.\
268 list_supported_targets (program_name
, stream
);
269 list_supported_architectures (program_name
, stream
);
271 disassembler_usage (stream
);
273 if (objdump_private_vectors
[0] != NULL
)
276 _("\nOptions supported for -P/--private switch:\n"));
277 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
278 (*desc
)->help (stream
);
281 if (REPORT_BUGS_TO
[0] && status
== 0)
282 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
286 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
290 OPTION_START_ADDRESS
,
302 static struct option long_options
[]=
304 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
305 {"all-headers", no_argument
, NULL
, 'x'},
306 {"private-headers", no_argument
, NULL
, 'p'},
307 {"private", required_argument
, NULL
, 'P'},
308 {"architecture", required_argument
, NULL
, 'm'},
309 {"archive-headers", no_argument
, NULL
, 'a'},
310 {"debugging", no_argument
, NULL
, 'g'},
311 {"debugging-tags", no_argument
, NULL
, 'e'},
312 {"demangle", optional_argument
, NULL
, 'C'},
313 {"disassemble", no_argument
, NULL
, 'd'},
314 {"disassemble-all", no_argument
, NULL
, 'D'},
315 {"disassembler-options", required_argument
, NULL
, 'M'},
316 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
317 {"dynamic-reloc", no_argument
, NULL
, 'R'},
318 {"dynamic-syms", no_argument
, NULL
, 'T'},
319 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
320 {"file-headers", no_argument
, NULL
, 'f'},
321 {"file-offsets", no_argument
, NULL
, 'F'},
322 {"file-start-context", no_argument
, &file_start_context
, 1},
323 {"full-contents", no_argument
, NULL
, 's'},
324 {"headers", no_argument
, NULL
, 'h'},
325 {"help", no_argument
, NULL
, 'H'},
326 {"info", no_argument
, NULL
, 'i'},
327 {"line-numbers", no_argument
, NULL
, 'l'},
328 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
329 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
330 {"reloc", no_argument
, NULL
, 'r'},
331 {"section", required_argument
, NULL
, 'j'},
332 {"section-headers", no_argument
, NULL
, 'h'},
333 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
334 {"source", no_argument
, NULL
, 'S'},
335 {"special-syms", no_argument
, &dump_special_syms
, 1},
336 {"include", required_argument
, NULL
, 'I'},
337 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
338 {"stabs", no_argument
, NULL
, 'G'},
339 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
340 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
341 {"syms", no_argument
, NULL
, 't'},
342 {"target", required_argument
, NULL
, 'b'},
343 {"version", no_argument
, NULL
, 'V'},
344 {"wide", no_argument
, NULL
, 'w'},
345 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
346 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
347 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
348 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
349 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
350 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
351 {0, no_argument
, 0, 0}
355 nonfatal (const char *msg
)
361 /* Returns TRUE if the specified section should be dumped. */
364 process_section_p (asection
* section
)
368 if (only_list
== NULL
)
371 for (only
= only_list
; only
; only
= only
->next
)
372 if (strcmp (only
->name
, section
->name
) == 0)
381 /* Add an entry to the 'only' list. */
384 add_only (char * name
)
388 /* First check to make sure that we do not
389 already have an entry for this name. */
390 for (only
= only_list
; only
; only
= only
->next
)
391 if (strcmp (only
->name
, name
) == 0)
394 only
= xmalloc (sizeof * only
);
397 only
->next
= only_list
;
401 /* Release the memory used by the 'only' list.
402 PR 11225: Issue a warning message for unseen sections.
403 Only do this if none of the sections were seen. This is mainly to support
404 tools like the GAS testsuite where an object file is dumped with a list of
405 generic section names known to be present in a range of different file
409 free_only_list (void)
411 bfd_boolean at_least_one_seen
= FALSE
;
415 if (only_list
== NULL
)
418 for (only
= only_list
; only
; only
= only
->next
)
421 at_least_one_seen
= TRUE
;
425 for (only
= only_list
; only
; only
= next
)
427 if (! at_least_one_seen
)
429 non_fatal (_("section '%s' mentioned in a -j option, "
430 "but not found in any input file"),
441 dump_section_header (bfd
*abfd
, asection
*section
,
442 void *ignored ATTRIBUTE_UNUSED
)
445 unsigned int opb
= bfd_octets_per_byte (abfd
);
447 /* Ignore linker created section. See elfNN_ia64_object_p in
449 if (section
->flags
& SEC_LINKER_CREATED
)
452 /* PR 10413: Skip sections that we are ignoring. */
453 if (! process_section_p (section
))
456 printf ("%3d %-13s %08lx ", section
->index
,
457 bfd_get_section_name (abfd
, section
),
458 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
459 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
461 bfd_printf_vma (abfd
, section
->lma
);
462 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
463 bfd_get_section_alignment (abfd
, section
));
469 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
471 PF (SEC_HAS_CONTENTS
, "CONTENTS");
472 PF (SEC_ALLOC
, "ALLOC");
473 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
474 PF (SEC_LOAD
, "LOAD");
475 PF (SEC_RELOC
, "RELOC");
476 PF (SEC_READONLY
, "READONLY");
477 PF (SEC_CODE
, "CODE");
478 PF (SEC_DATA
, "DATA");
480 PF (SEC_DEBUGGING
, "DEBUGGING");
481 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
482 PF (SEC_EXCLUDE
, "EXCLUDE");
483 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
484 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
486 PF (SEC_TIC54X_BLOCK
, "BLOCK");
487 PF (SEC_TIC54X_CLINK
, "CLINK");
489 PF (SEC_SMALL_DATA
, "SMALL_DATA");
490 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
492 PF (SEC_COFF_SHARED
, "SHARED");
493 PF (SEC_COFF_NOREAD
, "NOREAD");
495 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
496 PF (SEC_ELF_PURECODE
, "PURECODE");
497 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
498 PF (SEC_GROUP
, "GROUP");
499 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
501 PF (SEC_MEP_VLIW
, "VLIW");
504 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
507 struct coff_comdat_info
*comdat
;
509 switch (section
->flags
& SEC_LINK_DUPLICATES
)
513 case SEC_LINK_DUPLICATES_DISCARD
:
514 ls
= "LINK_ONCE_DISCARD";
516 case SEC_LINK_DUPLICATES_ONE_ONLY
:
517 ls
= "LINK_ONCE_ONE_ONLY";
519 case SEC_LINK_DUPLICATES_SAME_SIZE
:
520 ls
= "LINK_ONCE_SAME_SIZE";
522 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
523 ls
= "LINK_ONCE_SAME_CONTENTS";
526 printf ("%s%s", comma
, ls
);
528 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
530 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
540 dump_headers (bfd
*abfd
)
542 printf (_("Sections:\n"));
545 printf (_("Idx Name Size VMA LMA File off Algn"));
547 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
548 if (bfd_get_arch_size (abfd
) == 32)
549 printf (_("Idx Name Size VMA LMA File off Algn"));
551 printf (_("Idx Name Size VMA LMA File off Algn"));
555 printf (_(" Flags"));
558 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
562 slurp_symtab (bfd
*abfd
)
567 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
573 storage
= bfd_get_symtab_upper_bound (abfd
);
576 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
577 bfd_fatal (_("error message was"));
580 sy
= (asymbol
**) xmalloc (storage
);
582 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
584 bfd_fatal (bfd_get_filename (abfd
));
588 /* Read in the dynamic symbols. */
591 slurp_dynamic_symtab (bfd
*abfd
)
596 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
599 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
601 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
607 bfd_fatal (bfd_get_filename (abfd
));
610 sy
= (asymbol
**) xmalloc (storage
);
612 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
614 bfd_fatal (bfd_get_filename (abfd
));
618 /* Filter out (in place) symbols that are useless for disassembly.
619 COUNT is the number of elements in SYMBOLS.
620 Return the number of useful symbols. */
623 remove_useless_symbols (asymbol
**symbols
, long count
)
625 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
629 asymbol
*sym
= *in_ptr
++;
631 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
633 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
635 if (bfd_is_und_section (sym
->section
)
636 || bfd_is_com_section (sym
->section
))
641 return out_ptr
- symbols
;
644 /* Sort symbols into value order. */
647 compare_symbols (const void *ap
, const void *bp
)
649 const asymbol
*a
= * (const asymbol
**) ap
;
650 const asymbol
*b
= * (const asymbol
**) bp
;
660 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
662 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
665 if (a
->section
> b
->section
)
667 else if (a
->section
< b
->section
)
670 an
= bfd_asymbol_name (a
);
671 bn
= bfd_asymbol_name (b
);
675 /* The symbols gnu_compiled and gcc2_compiled convey no real
676 information, so put them after other symbols with the same value. */
677 af
= (strstr (an
, "gnu_compiled") != NULL
678 || strstr (an
, "gcc2_compiled") != NULL
);
679 bf
= (strstr (bn
, "gnu_compiled") != NULL
680 || strstr (bn
, "gcc2_compiled") != NULL
);
687 /* We use a heuristic for the file name, to try to sort it after
688 more useful symbols. It may not work on non Unix systems, but it
689 doesn't really matter; the only difference is precisely which
690 symbol names get printed. */
692 #define file_symbol(s, sn, snl) \
693 (((s)->flags & BSF_FILE) != 0 \
694 || ((sn)[(snl) - 2] == '.' \
695 && ((sn)[(snl) - 1] == 'o' \
696 || (sn)[(snl) - 1] == 'a')))
698 af
= file_symbol (a
, an
, anl
);
699 bf
= file_symbol (b
, bn
, bnl
);
706 /* Try to sort global symbols before local symbols before function
707 symbols before debugging symbols. */
712 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
714 if ((aflags
& BSF_DEBUGGING
) != 0)
719 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
721 if ((aflags
& BSF_FUNCTION
) != 0)
726 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
728 if ((aflags
& BSF_LOCAL
) != 0)
733 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
735 if ((aflags
& BSF_GLOBAL
) != 0)
741 /* Symbols that start with '.' might be section names, so sort them
742 after symbols that don't start with '.'. */
743 if (an
[0] == '.' && bn
[0] != '.')
745 if (an
[0] != '.' && bn
[0] == '.')
748 /* Finally, if we can't distinguish them in any other way, try to
749 get consistent results by sorting the symbols by name. */
750 return strcmp (an
, bn
);
753 /* Sort relocs into address order. */
756 compare_relocs (const void *ap
, const void *bp
)
758 const arelent
*a
= * (const arelent
**) ap
;
759 const arelent
*b
= * (const arelent
**) bp
;
761 if (a
->address
> b
->address
)
763 else if (a
->address
< b
->address
)
766 /* So that associated relocations tied to the same address show up
767 in the correct order, we don't do any further sorting. */
776 /* Print an address (VMA) to the output stream in INFO.
777 If SKIP_ZEROES is TRUE, omit leading zeroes. */
780 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
781 bfd_boolean skip_zeroes
)
785 struct objdump_disasm_info
*aux
;
787 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
788 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
793 for (p
= buf
; *p
== '0'; ++p
)
798 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
801 /* Print the name of a symbol. */
804 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
808 const char *name
, *version_string
= NULL
;
809 bfd_boolean hidden
= FALSE
;
812 name
= bfd_asymbol_name (sym
);
813 if (do_demangle
&& name
[0] != '\0')
815 /* Demangle the name. */
816 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
821 if ((sym
->flags
& BSF_SYNTHETIC
) == 0)
822 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
824 if (bfd_is_und_section (bfd_get_section (sym
)))
829 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
830 if (version_string
&& *version_string
!= '\0')
831 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
837 if (version_string
&& *version_string
!= '\0')
838 printf (hidden
? "@%s" : "@@%s", version_string
);
845 /* Locate a symbol given a bfd and a section (from INFO->application_data),
846 and a VMA. If INFO->application_data->require_sec is TRUE, then always
847 require the symbol to be in the section. Returns NULL if there is no
848 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
849 of the symbol in sorted_syms. */
852 find_symbol_for_address (bfd_vma vma
,
853 struct disassemble_info
*inf
,
856 /* @@ Would it speed things up to cache the last two symbols returned,
857 and maybe their address ranges? For many processors, only one memory
858 operand can be present at a time, so the 2-entry cache wouldn't be
859 constantly churned by code doing heavy memory accesses. */
861 /* Indices in `sorted_syms'. */
863 long max_count
= sorted_symcount
;
865 struct objdump_disasm_info
*aux
;
869 bfd_boolean want_section
;
871 if (sorted_symcount
< 1)
874 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
877 opb
= inf
->octets_per_byte
;
879 /* Perform a binary search looking for the closest symbol to the
880 required value. We are searching the range (min, max_count]. */
881 while (min
+ 1 < max_count
)
885 thisplace
= (max_count
+ min
) / 2;
886 sym
= sorted_syms
[thisplace
];
888 if (bfd_asymbol_value (sym
) > vma
)
889 max_count
= thisplace
;
890 else if (bfd_asymbol_value (sym
) < vma
)
899 /* The symbol we want is now in min, the low end of the range we
900 were searching. If there are several symbols with the same
901 value, we want the first one. */
904 && (bfd_asymbol_value (sorted_syms
[thisplace
])
905 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
908 /* Prefer a symbol in the current section if we have multple symbols
909 with the same value, as can occur with overlays or zero size
912 while (min
< max_count
913 && (bfd_asymbol_value (sorted_syms
[min
])
914 == bfd_asymbol_value (sorted_syms
[thisplace
])))
916 if (sorted_syms
[min
]->section
== sec
917 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
924 return sorted_syms
[thisplace
];
929 /* If the file is relocatable, and the symbol could be from this
930 section, prefer a symbol from this section over symbols from
931 others, even if the other symbol's value might be closer.
933 Note that this may be wrong for some symbol references if the
934 sections have overlapping memory ranges, but in that case there's
935 no way to tell what's desired without looking at the relocation
938 Also give the target a chance to reject symbols. */
939 want_section
= (aux
->require_sec
940 || ((abfd
->flags
& HAS_RELOC
) != 0
941 && vma
>= bfd_get_section_vma (abfd
, sec
)
942 && vma
< (bfd_get_section_vma (abfd
, sec
)
943 + bfd_section_size (abfd
, sec
) / opb
)));
944 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
945 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
948 long newplace
= sorted_symcount
;
950 for (i
= min
- 1; i
>= 0; i
--)
952 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
953 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
955 if (newplace
== sorted_symcount
)
958 if (bfd_asymbol_value (sorted_syms
[i
])
959 != bfd_asymbol_value (sorted_syms
[newplace
]))
962 /* Remember this symbol and keep searching until we reach
963 an earlier address. */
968 if (newplace
!= sorted_symcount
)
969 thisplace
= newplace
;
972 /* We didn't find a good symbol with a smaller value.
973 Look for one with a larger value. */
974 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
976 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
977 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
985 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
986 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
987 /* There is no suitable symbol. */
994 return sorted_syms
[thisplace
];
997 /* Print an address and the offset to the nearest symbol. */
1000 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1001 bfd_vma vma
, struct disassemble_info
*inf
,
1002 bfd_boolean skip_zeroes
)
1004 objdump_print_value (vma
, inf
, skip_zeroes
);
1010 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1011 bfd_get_section_name (abfd
, sec
));
1012 secaddr
= bfd_get_section_vma (abfd
, sec
);
1015 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1016 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1018 else if (vma
> secaddr
)
1020 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1021 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1023 (*inf
->fprintf_func
) (inf
->stream
, ">");
1027 (*inf
->fprintf_func
) (inf
->stream
, " <");
1028 objdump_print_symname (abfd
, inf
, sym
);
1029 if (bfd_asymbol_value (sym
) > vma
)
1031 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1032 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1034 else if (vma
> bfd_asymbol_value (sym
))
1036 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1037 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1039 (*inf
->fprintf_func
) (inf
->stream
, ">");
1042 if (display_file_offsets
)
1043 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1044 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1047 /* Print an address (VMA), symbolically if possible.
1048 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1051 objdump_print_addr (bfd_vma vma
,
1052 struct disassemble_info
*inf
,
1053 bfd_boolean skip_zeroes
)
1055 struct objdump_disasm_info
*aux
;
1056 asymbol
*sym
= NULL
;
1057 bfd_boolean skip_find
= FALSE
;
1059 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1061 if (sorted_symcount
< 1)
1063 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1064 objdump_print_value (vma
, inf
, skip_zeroes
);
1066 if (display_file_offsets
)
1067 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1068 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1072 if (aux
->reloc
!= NULL
1073 && aux
->reloc
->sym_ptr_ptr
!= NULL
1074 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1076 sym
= * aux
->reloc
->sym_ptr_ptr
;
1078 /* Adjust the vma to the reloc. */
1079 vma
+= bfd_asymbol_value (sym
);
1081 if (bfd_is_und_section (bfd_get_section (sym
)))
1086 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1088 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1092 /* Print VMA to INFO. This function is passed to the disassembler
1096 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1098 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1101 /* Determine if the given address has a symbol associated with it. */
1104 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1108 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1110 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1113 /* Hold the last function name and the last line number we displayed
1114 in a disassembly. */
1116 static char *prev_functionname
;
1117 static unsigned int prev_line
;
1118 static unsigned int prev_discriminator
;
1120 /* We keep a list of all files that we have seen when doing a
1121 disassembly with source, so that we know how much of the file to
1122 display. This can be important for inlined functions. */
1124 struct print_file_list
1126 struct print_file_list
*next
;
1127 const char *filename
;
1128 const char *modname
;
1131 const char **linemap
;
1134 unsigned max_printed
;
1138 static struct print_file_list
*print_files
;
1140 /* The number of preceding context lines to show when we start
1141 displaying a file for the first time. */
1143 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1145 /* Read a complete file into memory. */
1148 slurp_file (const char *fn
, size_t *size
)
1151 int ps
= getpagesize ();
1156 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1160 if (fstat (fd
, &st
) < 0)
1167 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1168 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1169 if (map
!= (char *) -1L)
1175 map
= (const char *) malloc (*size
);
1176 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1178 free ((void *) map
);
1185 #define line_map_decrease 5
1187 /* Precompute array of lines for a mapped file. */
1189 static const char **
1190 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1192 const char *p
, *lstart
, *end
;
1193 int chars_per_line
= 45; /* First iteration will use 40. */
1194 unsigned int lineno
;
1195 const char **linemap
= NULL
;
1196 unsigned long line_map_size
= 0;
1202 for (p
= map
; p
< end
; p
++)
1206 if (p
+ 1 < end
&& p
[1] == '\r')
1209 else if (*p
== '\r')
1211 if (p
+ 1 < end
&& p
[1] == '\n')
1217 /* End of line found. */
1219 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1221 unsigned long newsize
;
1223 chars_per_line
-= line_map_decrease
;
1224 if (chars_per_line
<= 1)
1226 line_map_size
= size
/ chars_per_line
+ 1;
1227 if (line_map_size
< lineno
+ 1)
1228 line_map_size
= lineno
+ 1;
1229 newsize
= line_map_size
* sizeof (char *);
1230 linemap
= (const char **) xrealloc (linemap
, newsize
);
1233 linemap
[lineno
++] = lstart
;
1241 /* Tries to open MODNAME, and if successful adds a node to print_files
1242 linked list and returns that node. Returns NULL on failure. */
1244 static struct print_file_list
*
1245 try_print_file_open (const char *origname
, const char *modname
)
1247 struct print_file_list
*p
;
1249 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1251 p
->map
= slurp_file (modname
, &p
->mapsize
);
1258 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1261 p
->filename
= origname
;
1262 p
->modname
= modname
;
1263 p
->next
= print_files
;
1269 /* If the source file, as described in the symtab, is not found
1270 try to locate it in one of the paths specified with -I
1271 If found, add location to print_files linked list. */
1273 static struct print_file_list
*
1274 update_source_path (const char *filename
)
1276 struct print_file_list
*p
;
1280 p
= try_print_file_open (filename
, filename
);
1284 if (include_path_count
== 0)
1287 /* Get the name of the file. */
1288 fname
= lbasename (filename
);
1290 /* If file exists under a new path, we need to add it to the list
1291 so that show_line knows about it. */
1292 for (i
= 0; i
< include_path_count
; i
++)
1294 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1296 p
= try_print_file_open (filename
, modname
);
1306 /* Print a source file line. */
1309 print_line (struct print_file_list
*p
, unsigned int linenum
)
1315 if (linenum
>= p
->maxline
)
1317 l
= p
->linemap
[linenum
];
1318 /* Test fwrite return value to quiet glibc warning. */
1319 len
= strcspn (l
, "\n\r");
1320 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1324 /* Print a range of source code lines. */
1327 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1331 while (start
<= end
)
1333 print_line (p
, start
);
1338 /* Show the line number, or the source line, in a disassembly
1342 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1344 const char *filename
;
1345 const char *functionname
;
1346 unsigned int linenumber
;
1347 unsigned int discriminator
;
1351 if (! with_line_numbers
&& ! with_source_code
)
1354 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1355 &filename
, &functionname
,
1356 &linenumber
, &discriminator
))
1359 if (filename
!= NULL
&& *filename
== '\0')
1361 if (functionname
!= NULL
&& *functionname
== '\0')
1362 functionname
= NULL
;
1365 && IS_ABSOLUTE_PATH (filename
)
1369 const char *fname
= filename
;
1371 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1374 memcpy (path
, prefix
, prefix_length
);
1375 path_up
= path
+ prefix_length
;
1377 /* Build relocated filename, stripping off leading directories
1378 from the initial filename if requested. */
1379 if (prefix_strip
> 0)
1384 /* Skip selected directory levels. */
1385 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1386 if (IS_DIR_SEPARATOR(*s
))
1393 /* Update complete filename. */
1394 strncpy (path_up
, fname
, PATH_MAX
);
1395 path_up
[PATH_MAX
] = '\0';
1403 if (with_line_numbers
)
1405 if (functionname
!= NULL
1406 && (prev_functionname
== NULL
1407 || strcmp (functionname
, prev_functionname
) != 0))
1408 printf ("%s():\n", functionname
);
1409 if (linenumber
> 0 && (linenumber
!= prev_line
||
1410 (discriminator
!= prev_discriminator
)))
1412 if (discriminator
> 0)
1413 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1414 linenumber
, discriminator
);
1416 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1420 if (with_source_code
1424 struct print_file_list
**pp
, *p
;
1427 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1428 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1435 filename
= xstrdup (filename
);
1436 p
= update_source_path (filename
);
1439 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1441 if (file_start_context
&& p
->first
)
1445 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1446 if (l
>= linenumber
)
1448 if (p
->max_printed
>= l
)
1450 if (p
->max_printed
< linenumber
)
1451 l
= p
->max_printed
+ 1;
1456 dump_lines (p
, l
, linenumber
);
1457 if (p
->max_printed
< linenumber
)
1458 p
->max_printed
= linenumber
;
1459 p
->last_line
= linenumber
;
1464 if (functionname
!= NULL
1465 && (prev_functionname
== NULL
1466 || strcmp (functionname
, prev_functionname
) != 0))
1468 if (prev_functionname
!= NULL
)
1469 free (prev_functionname
);
1470 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1471 strcpy (prev_functionname
, functionname
);
1474 if (linenumber
> 0 && linenumber
!= prev_line
)
1475 prev_line
= linenumber
;
1477 if (discriminator
!= prev_discriminator
)
1478 prev_discriminator
= discriminator
;
1484 /* Pseudo FILE object for strings. */
1492 /* sprintf to a "stream". */
1494 static int ATTRIBUTE_PRINTF_2
1495 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1502 size_t space
= f
->alloc
- f
->pos
;
1504 va_start (args
, format
);
1505 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1511 f
->alloc
= (f
->alloc
+ n
) * 2;
1512 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1519 /* The number of zeroes we want to see before we start skipping them.
1520 The number is arbitrarily chosen. */
1522 #define DEFAULT_SKIP_ZEROES 8
1524 /* The number of zeroes to skip at the end of a section. If the
1525 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1526 SKIP_ZEROES, they will be disassembled. If there are fewer than
1527 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1528 attempt to avoid disassembling zeroes inserted by section
1531 #define DEFAULT_SKIP_ZEROES_AT_END 3
1533 /* Disassemble some data in memory between given values. */
1536 disassemble_bytes (struct disassemble_info
* inf
,
1537 disassembler_ftype disassemble_fn
,
1540 bfd_vma start_offset
,
1541 bfd_vma stop_offset
,
1544 arelent
** relppend
)
1546 struct objdump_disasm_info
*aux
;
1548 int octets_per_line
;
1549 int skip_addr_chars
;
1550 bfd_vma addr_offset
;
1551 unsigned int opb
= inf
->octets_per_byte
;
1552 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1553 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1557 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1561 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1565 octets_per_line
= insn_width
;
1567 octets_per_line
= 4;
1569 octets_per_line
= 16;
1571 /* Figure out how many characters to skip at the start of an
1572 address, to make the disassembly look nicer. We discard leading
1573 zeroes in chunks of 4, ensuring that there is always a leading
1575 skip_addr_chars
= 0;
1576 if (! prefix_addresses
)
1580 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1582 while (buf
[skip_addr_chars
] == '0')
1585 /* Don't discard zeros on overflow. */
1586 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1587 skip_addr_chars
= 0;
1589 if (skip_addr_chars
!= 0)
1590 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1593 inf
->insn_info_valid
= 0;
1595 addr_offset
= start_offset
;
1596 while (addr_offset
< stop_offset
)
1599 bfd_boolean need_nl
= FALSE
;
1600 int previous_octets
;
1602 /* Remember the length of the previous instruction. */
1603 previous_octets
= octets
;
1606 /* Make sure we don't use relocs from previous instructions. */
1609 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1611 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1614 if (! disassemble_zeroes
1615 && (inf
->insn_info_valid
== 0
1616 || inf
->branch_delay_insns
== 0)
1617 && (z
- addr_offset
* opb
>= skip_zeroes
1618 || (z
== stop_offset
* opb
&&
1619 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1621 /* If there are more nonzero octets to follow, we only skip
1622 zeroes in multiples of 4, to try to avoid running over
1623 the start of an instruction which happens to start with
1625 if (z
!= stop_offset
* opb
)
1626 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1628 octets
= z
- addr_offset
* opb
;
1630 /* If we are going to display more data, and we are displaying
1631 file offsets, then tell the user how many zeroes we skip
1632 and the file offset from where we resume dumping. */
1633 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1634 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1636 (unsigned long) (section
->filepos
1637 + (addr_offset
+ (octets
/ opb
))));
1647 if (with_line_numbers
|| with_source_code
)
1648 show_line (aux
->abfd
, section
, addr_offset
);
1650 if (! prefix_addresses
)
1654 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1655 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1659 printf ("%s:\t", buf
+ skip_addr_chars
);
1663 aux
->require_sec
= TRUE
;
1664 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1665 aux
->require_sec
= FALSE
;
1672 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1673 inf
->stream
= &sfile
;
1674 inf
->bytes_per_line
= 0;
1675 inf
->bytes_per_chunk
= 0;
1676 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1678 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1680 if (inf
->disassembler_needs_relocs
1681 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1682 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1683 && *relppp
< relppend
)
1685 bfd_signed_vma distance_to_rel
;
1687 distance_to_rel
= (**relppp
)->address
1688 - (rel_offset
+ addr_offset
);
1690 /* Check to see if the current reloc is associated with
1691 the instruction that we are about to disassemble. */
1692 if (distance_to_rel
== 0
1693 /* FIXME: This is wrong. We are trying to catch
1694 relocs that are addressed part way through the
1695 current instruction, as might happen with a packed
1696 VLIW instruction. Unfortunately we do not know the
1697 length of the current instruction since we have not
1698 disassembled it yet. Instead we take a guess based
1699 upon the length of the previous instruction. The
1700 proper solution is to have a new target-specific
1701 disassembler function which just returns the length
1702 of an instruction at a given address without trying
1703 to display its disassembly. */
1704 || (distance_to_rel
> 0
1705 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1707 inf
->flags
|= INSN_HAS_RELOC
;
1708 aux
->reloc
= **relppp
;
1712 if (! disassemble_all
1713 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1714 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1715 /* Set a stop_vma so that the disassembler will not read
1716 beyond the next symbol. We assume that symbols appear on
1717 the boundaries between instructions. We only do this when
1718 disassembling code of course, and when -D is in effect. */
1719 inf
->stop_vma
= section
->vma
+ stop_offset
;
1721 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1724 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1725 inf
->stream
= stdout
;
1726 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1727 octets_per_line
= inf
->bytes_per_line
;
1728 if (octets
< (int) opb
)
1731 printf ("%s\n", sfile
.buffer
);
1734 non_fatal (_("disassemble_fn returned length %d"),
1745 octets
= octets_per_line
;
1746 if (addr_offset
+ octets
/ opb
> stop_offset
)
1747 octets
= (stop_offset
- addr_offset
) * opb
;
1749 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1751 if (ISPRINT (data
[j
]))
1752 buf
[j
- addr_offset
* opb
] = data
[j
];
1754 buf
[j
- addr_offset
* opb
] = '.';
1756 buf
[j
- addr_offset
* opb
] = '\0';
1759 if (prefix_addresses
1761 : show_raw_insn
>= 0)
1765 /* If ! prefix_addresses and ! wide_output, we print
1766 octets_per_line octets per line. */
1768 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1769 pb
= octets_per_line
;
1771 if (inf
->bytes_per_chunk
)
1772 bpc
= inf
->bytes_per_chunk
;
1776 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1780 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1782 for (k
= bpc
- 1; k
>= 0; k
--)
1783 printf ("%02x", (unsigned) data
[j
+ k
]);
1788 for (k
= 0; k
< bpc
; k
++)
1789 printf ("%02x", (unsigned) data
[j
+ k
]);
1794 for (; pb
< octets_per_line
; pb
+= bpc
)
1798 for (k
= 0; k
< bpc
; k
++)
1803 /* Separate raw data from instruction by extra space. */
1813 printf ("%s", sfile
.buffer
);
1815 if (prefix_addresses
1817 : show_raw_insn
>= 0)
1825 j
= addr_offset
* opb
+ pb
;
1827 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1828 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1832 printf ("%s:\t", buf
+ skip_addr_chars
);
1834 pb
+= octets_per_line
;
1837 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1841 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1843 for (k
= bpc
- 1; k
>= 0; k
--)
1844 printf ("%02x", (unsigned) data
[j
+ k
]);
1849 for (k
= 0; k
< bpc
; k
++)
1850 printf ("%02x", (unsigned) data
[j
+ k
]);
1863 while ((*relppp
) < relppend
1864 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1866 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1877 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1880 if (q
->howto
== NULL
)
1881 printf (": *unknown*\t");
1882 else if (q
->howto
->name
)
1883 printf (": %s\t", q
->howto
->name
);
1885 printf (": %d\t", q
->howto
->type
);
1887 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1888 printf ("*unknown*");
1891 const char *sym_name
;
1893 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1894 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1895 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1900 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1901 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1902 if (sym_name
== NULL
|| *sym_name
== '\0')
1903 sym_name
= "*unknown*";
1904 printf ("%s", sym_name
);
1910 bfd_signed_vma addend
= q
->addend
;
1918 objdump_print_value (addend
, inf
, TRUE
);
1930 addr_offset
+= octets
/ opb
;
1933 free (sfile
.buffer
);
1937 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1939 const struct elf_backend_data
* bed
;
1940 bfd_vma sign_adjust
= 0;
1941 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1942 struct objdump_disasm_info
* paux
;
1943 unsigned int opb
= pinfo
->octets_per_byte
;
1944 bfd_byte
* data
= NULL
;
1945 bfd_size_type datasize
= 0;
1946 arelent
** rel_pp
= NULL
;
1947 arelent
** rel_ppstart
= NULL
;
1948 arelent
** rel_ppend
;
1949 bfd_vma stop_offset
;
1950 asymbol
* sym
= NULL
;
1954 unsigned long addr_offset
;
1956 /* Sections that do not contain machine
1957 code are not normally disassembled. */
1958 if (! disassemble_all
1959 && only_list
== NULL
1960 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1961 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1964 if (! process_section_p (section
))
1967 datasize
= bfd_get_section_size (section
);
1971 if (start_address
== (bfd_vma
) -1
1972 || start_address
< section
->vma
)
1975 addr_offset
= start_address
- section
->vma
;
1977 if (stop_address
== (bfd_vma
) -1)
1978 stop_offset
= datasize
/ opb
;
1981 if (stop_address
< section
->vma
)
1984 stop_offset
= stop_address
- section
->vma
;
1985 if (stop_offset
> datasize
/ opb
)
1986 stop_offset
= datasize
/ opb
;
1989 if (addr_offset
>= stop_offset
)
1992 /* Decide which set of relocs to use. Load them if necessary. */
1993 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1994 if (paux
->dynrelbuf
)
1996 rel_pp
= paux
->dynrelbuf
;
1997 rel_count
= paux
->dynrelcount
;
1998 /* Dynamic reloc addresses are absolute, non-dynamic are section
1999 relative. REL_OFFSET specifies the reloc address corresponding
2000 to the start of this section. */
2001 rel_offset
= section
->vma
;
2009 if ((section
->flags
& SEC_RELOC
) != 0
2010 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2014 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2016 bfd_fatal (bfd_get_filename (abfd
));
2020 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2021 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2023 bfd_fatal (bfd_get_filename (abfd
));
2025 /* Sort the relocs by address. */
2026 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2030 rel_ppend
= rel_pp
+ rel_count
;
2032 data
= (bfd_byte
*) xmalloc (datasize
);
2034 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2036 paux
->sec
= section
;
2037 pinfo
->buffer
= data
;
2038 pinfo
->buffer_vma
= section
->vma
;
2039 pinfo
->buffer_length
= datasize
;
2040 pinfo
->section
= section
;
2042 /* Skip over the relocs belonging to addresses below the
2044 while (rel_pp
< rel_ppend
2045 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2048 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2050 /* Find the nearest symbol forwards from our current position. */
2051 paux
->require_sec
= TRUE
;
2052 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2053 (struct disassemble_info
*) inf
,
2055 paux
->require_sec
= FALSE
;
2057 /* PR 9774: If the target used signed addresses then we must make
2058 sure that we sign extend the value that we calculate for 'addr'
2059 in the loop below. */
2060 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2061 && (bed
= get_elf_backend_data (abfd
)) != NULL
2062 && bed
->sign_extend_vma
)
2063 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2065 /* Disassemble a block of instructions up to the address associated with
2066 the symbol we have just found. Then print the symbol and find the
2067 next symbol on. Repeat until we have disassembled the entire section
2068 or we have reached the end of the address range we are interested in. */
2069 while (addr_offset
< stop_offset
)
2073 bfd_vma nextstop_offset
;
2076 addr
= section
->vma
+ addr_offset
;
2077 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2079 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2084 (x
< sorted_symcount
2085 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2089 pinfo
->symbols
= sorted_syms
+ place
;
2090 pinfo
->num_symbols
= x
- place
;
2091 pinfo
->symtab_pos
= place
;
2095 pinfo
->symbols
= NULL
;
2096 pinfo
->num_symbols
= 0;
2097 pinfo
->symtab_pos
= -1;
2100 if (! prefix_addresses
)
2102 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2103 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2105 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2108 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2110 else if (sym
== NULL
)
2114 #define is_valid_next_sym(SYM) \
2115 ((SYM)->section == section \
2116 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2117 && pinfo->symbol_is_valid (SYM, pinfo))
2119 /* Search forward for the next appropriate symbol in
2120 SECTION. Note that all the symbols are sorted
2121 together into one big array, and that some sections
2122 may have overlapping addresses. */
2123 while (place
< sorted_symcount
2124 && ! is_valid_next_sym (sorted_syms
[place
]))
2127 if (place
>= sorted_symcount
)
2130 nextsym
= sorted_syms
[place
];
2133 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2134 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2135 else if (nextsym
== NULL
)
2136 nextstop_offset
= stop_offset
;
2138 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2140 if (nextstop_offset
> stop_offset
2141 || nextstop_offset
<= addr_offset
)
2142 nextstop_offset
= stop_offset
;
2144 /* If a symbol is explicitly marked as being an object
2145 rather than a function, just dump the bytes without
2146 disassembling them. */
2149 || sym
->section
!= section
2150 || bfd_asymbol_value (sym
) > addr
2151 || ((sym
->flags
& BSF_OBJECT
) == 0
2152 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2154 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2156 || (sym
->flags
& BSF_FUNCTION
) != 0)
2161 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2162 addr_offset
, nextstop_offset
,
2163 rel_offset
, &rel_pp
, rel_ppend
);
2165 addr_offset
= nextstop_offset
;
2171 if (rel_ppstart
!= NULL
)
2175 /* Disassemble the contents of an object file. */
2178 disassemble_data (bfd
*abfd
)
2180 struct disassemble_info disasm_info
;
2181 struct objdump_disasm_info aux
;
2185 prev_functionname
= NULL
;
2187 prev_discriminator
= 0;
2189 /* We make a copy of syms to sort. We don't want to sort syms
2190 because that will screw up the relocs. */
2191 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2192 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2193 * sizeof (asymbol
*));
2194 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2195 sorted_symcount
* sizeof (asymbol
*));
2197 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2199 for (i
= 0; i
< synthcount
; ++i
)
2201 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2205 /* Sort the symbols into section and symbol order. */
2206 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2208 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2210 disasm_info
.application_data
= (void *) &aux
;
2212 aux
.require_sec
= FALSE
;
2213 aux
.dynrelbuf
= NULL
;
2214 aux
.dynrelcount
= 0;
2217 disasm_info
.print_address_func
= objdump_print_address
;
2218 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2220 if (machine
!= NULL
)
2222 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2225 fatal (_("can't use supplied machine %s"), machine
);
2227 abfd
->arch_info
= inf
;
2230 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2232 struct bfd_target
*xvec
;
2234 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2235 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2236 xvec
->byteorder
= endian
;
2240 /* Use libopcodes to locate a suitable disassembler. */
2241 aux
.disassemble_fn
= disassembler (abfd
);
2242 if (!aux
.disassemble_fn
)
2244 non_fatal (_("can't disassemble for architecture %s\n"),
2245 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2250 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2251 disasm_info
.arch
= bfd_get_arch (abfd
);
2252 disasm_info
.mach
= bfd_get_mach (abfd
);
2253 disasm_info
.disassembler_options
= disassembler_options
;
2254 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2255 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2256 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2257 disasm_info
.disassembler_needs_relocs
= FALSE
;
2259 if (bfd_big_endian (abfd
))
2260 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2261 else if (bfd_little_endian (abfd
))
2262 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2264 /* ??? Aborting here seems too drastic. We could default to big or little
2266 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2268 /* Allow the target to customize the info structure. */
2269 disassemble_init_for_target (& disasm_info
);
2271 /* Pre-load the dynamic relocs if we are going
2272 to be dumping them along with the disassembly. */
2273 if (dump_dynamic_reloc_info
)
2275 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2278 bfd_fatal (bfd_get_filename (abfd
));
2282 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2283 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2286 if (aux
.dynrelcount
< 0)
2287 bfd_fatal (bfd_get_filename (abfd
));
2289 /* Sort the relocs by address. */
2290 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2294 disasm_info
.symtab
= sorted_syms
;
2295 disasm_info
.symtab_size
= sorted_symcount
;
2297 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2299 if (aux
.dynrelbuf
!= NULL
)
2300 free (aux
.dynrelbuf
);
2305 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2306 asection
*sec
, void *file
)
2308 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2309 bfd
*abfd
= (bfd
*) file
;
2312 /* If it is already loaded, do nothing. */
2313 if (section
->start
!= NULL
)
2316 section
->reloc_info
= NULL
;
2317 section
->num_relocs
= 0;
2318 section
->address
= bfd_get_section_vma (abfd
, sec
);
2319 section
->size
= bfd_get_section_size (sec
);
2320 section
->start
= NULL
;
2321 section
->user_data
= sec
;
2322 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2326 free_debug_section (debug
);
2327 printf (_("\nCan't get contents for section '%s'.\n"),
2332 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2334 bfd_cache_section_contents (sec
, section
->start
);
2336 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2343 free_debug_section (debug
);
2344 printf (_("\nCan't get contents for section '%s'.\n"),
2351 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2354 unsigned long reloc_count
;
2357 relocs
= (arelent
**) xmalloc (reloc_size
);
2359 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2360 if (reloc_count
== 0)
2364 section
->reloc_info
= relocs
;
2365 section
->num_relocs
= reloc_count
;
2374 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2379 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2382 relocs
= (arelent
**) dsec
->reloc_info
;
2384 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2385 if (rp
->address
== offset
)
2392 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2394 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2395 bfd
*abfd
= (bfd
*) file
;
2398 /* If it is already loaded, do nothing. */
2399 if (section
->start
!= NULL
)
2402 /* Locate the debug section. */
2403 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2405 section
->name
= section
->uncompressed_name
;
2408 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2410 section
->name
= section
->compressed_name
;
2415 return load_specific_debug_section (debug
, sec
, file
);
2419 free_debug_section (enum dwarf_section_display_enum debug
)
2421 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2423 if (section
->start
== NULL
)
2426 /* PR 17512: file: 0f67f69d. */
2427 if (section
->user_data
!= NULL
)
2429 asection
* sec
= (asection
*) section
->user_data
;
2431 /* If we are freeing contents that are also pointed to by the BFD
2432 library's section structure then make sure to update those pointers
2433 too. Otherwise, the next time we try to load data for this section
2434 we can end up using a stale pointer. */
2435 if (section
->start
== sec
->contents
)
2437 sec
->contents
= NULL
;
2438 sec
->flags
&= ~ SEC_IN_MEMORY
;
2439 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2443 free ((char *) section
->start
);
2444 section
->start
= NULL
;
2445 section
->address
= 0;
2450 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2451 void *arg ATTRIBUTE_UNUSED
)
2453 const char *name
= bfd_get_section_name (abfd
, section
);
2457 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2458 match
= ".debug_info";
2462 for (i
= 0; i
< max
; i
++)
2463 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2464 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2465 && debug_displays
[i
].enabled
!= NULL
2466 && *debug_displays
[i
].enabled
)
2468 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2470 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2471 sec
->name
= sec
->uncompressed_name
;
2473 sec
->name
= sec
->compressed_name
;
2474 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2477 debug_displays
[i
].display (sec
, abfd
);
2479 if (i
!= info
&& i
!= abbrev
)
2480 free_debug_section ((enum dwarf_section_display_enum
) i
);
2486 /* Dump the dwarf debugging information. */
2489 dump_dwarf (bfd
*abfd
)
2491 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2493 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2495 if (bfd_big_endian (abfd
))
2496 byte_get
= byte_get_big_endian
;
2497 else if (bfd_little_endian (abfd
))
2498 byte_get
= byte_get_little_endian
;
2500 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2502 warn (_("File %s does not contain any dwarf debug information\n"),
2503 bfd_get_filename (abfd
));
2507 switch (bfd_get_arch (abfd
))
2510 switch (bfd_get_mach (abfd
))
2512 case bfd_mach_x86_64
:
2513 case bfd_mach_x86_64_intel_syntax
:
2514 case bfd_mach_x86_64_nacl
:
2515 case bfd_mach_x64_32
:
2516 case bfd_mach_x64_32_intel_syntax
:
2517 case bfd_mach_x64_32_nacl
:
2518 init_dwarf_regnames_x86_64 ();
2522 init_dwarf_regnames_i386 ();
2527 case bfd_arch_iamcu
:
2528 init_dwarf_regnames_iamcu ();
2531 case bfd_arch_aarch64
:
2532 init_dwarf_regnames_aarch64();
2536 init_dwarf_regnames_s390 ();
2543 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2545 free_debug_memory ();
2548 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2549 it. Return NULL on failure. */
2552 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2558 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2559 if (stabsect
== NULL
)
2561 printf (_("No %s section present\n\n"), sect_name
);
2565 size
= bfd_section_size (abfd
, stabsect
);
2566 contents
= (char *) xmalloc (size
);
2568 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2570 non_fatal (_("reading %s section of %s failed: %s"),
2571 sect_name
, bfd_get_filename (abfd
),
2572 bfd_errmsg (bfd_get_error ()));
2583 /* Stabs entries use a 12 byte format:
2584 4 byte string table index
2586 1 byte stab other field
2587 2 byte stab desc field
2589 FIXME: This will have to change for a 64 bit object format. */
2591 #define STRDXOFF (0)
2593 #define OTHEROFF (5)
2596 #define STABSIZE (12)
2598 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2599 using string table section STRSECT_NAME (in `strtab'). */
2602 print_section_stabs (bfd
*abfd
,
2603 const char *stabsect_name
,
2604 unsigned *string_offset_ptr
)
2607 unsigned file_string_table_offset
= 0;
2608 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2609 bfd_byte
*stabp
, *stabs_end
;
2612 stabs_end
= stabp
+ stab_size
;
2614 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2615 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2617 /* Loop through all symbols and print them.
2619 We start the index at -1 because there is a dummy symbol on
2620 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2621 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2625 unsigned char type
, other
;
2626 unsigned short desc
;
2629 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2630 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2631 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2632 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2633 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2635 printf ("\n%-6d ", i
);
2636 /* Either print the stab name, or, if unnamed, print its number
2637 again (makes consistent formatting for tools like awk). */
2638 name
= bfd_get_stab_name (type
);
2640 printf ("%-6s", name
);
2641 else if (type
== N_UNDF
)
2644 printf ("%-6d", type
);
2645 printf (" %-6d %-6d ", other
, desc
);
2646 bfd_printf_vma (abfd
, value
);
2647 printf (" %-6lu", strx
);
2649 /* Symbols with type == 0 (N_UNDF) specify the length of the
2650 string table associated with this file. We use that info
2651 to know how to relocate the *next* file's string table indices. */
2654 file_string_table_offset
= next_file_string_table_offset
;
2655 next_file_string_table_offset
+= value
;
2659 bfd_size_type amt
= strx
+ file_string_table_offset
;
2661 /* Using the (possibly updated) string table offset, print the
2662 string (if any) associated with this symbol. */
2663 if (amt
< stabstr_size
)
2664 /* PR 17512: file: 079-79389-0.001:0.1. */
2665 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2671 *string_offset_ptr
= next_file_string_table_offset
;
2676 const char * section_name
;
2677 const char * string_section_name
;
2678 unsigned string_offset
;
2683 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2686 stab_section_names
* sought
= (stab_section_names
*) names
;
2688 /* Check for section names for which stabsect_name is a prefix, to
2689 handle .stab.N, etc. */
2690 len
= strlen (sought
->section_name
);
2692 /* If the prefix matches, and the files section name ends with a
2693 nul or a digit, then we match. I.e., we want either an exact
2694 match or a section followed by a number. */
2695 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2696 && (section
->name
[len
] == 0
2697 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2700 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2705 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2708 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2714 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2716 stab_section_names s
;
2718 s
.section_name
= stabsect_name
;
2719 s
.string_section_name
= strsect_name
;
2720 s
.string_offset
= 0;
2722 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2728 /* Dump the any sections containing stabs debugging information. */
2731 dump_stabs (bfd
*abfd
)
2733 dump_stabs_section (abfd
, ".stab", ".stabstr");
2734 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2735 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2738 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2740 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2744 dump_bfd_header (bfd
*abfd
)
2748 printf (_("architecture: %s, "),
2749 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2750 bfd_get_mach (abfd
)));
2751 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2753 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2754 PF (HAS_RELOC
, "HAS_RELOC");
2755 PF (EXEC_P
, "EXEC_P");
2756 PF (HAS_LINENO
, "HAS_LINENO");
2757 PF (HAS_DEBUG
, "HAS_DEBUG");
2758 PF (HAS_SYMS
, "HAS_SYMS");
2759 PF (HAS_LOCALS
, "HAS_LOCALS");
2760 PF (DYNAMIC
, "DYNAMIC");
2761 PF (WP_TEXT
, "WP_TEXT");
2762 PF (D_PAGED
, "D_PAGED");
2763 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2764 printf (_("\nstart address 0x"));
2765 bfd_printf_vma (abfd
, abfd
->start_address
);
2771 dump_bfd_private_header (bfd
*abfd
)
2773 bfd_print_private_bfd_data (abfd
, stdout
);
2777 dump_target_specific (bfd
*abfd
)
2779 const struct objdump_private_desc
* const *desc
;
2780 struct objdump_private_option
*opt
;
2783 /* Find the desc. */
2784 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2785 if ((*desc
)->filter (abfd
))
2790 non_fatal (_("option -P/--private not supported by this file"));
2794 /* Clear all options. */
2795 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2796 opt
->selected
= FALSE
;
2798 /* Decode options. */
2799 b
= dump_private_options
;
2802 e
= strchr (b
, ',');
2807 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2808 if (strcmp (opt
->name
, b
) == 0)
2810 opt
->selected
= TRUE
;
2813 if (opt
->name
== NULL
)
2814 non_fatal (_("target specific dump '%s' not supported"), b
);
2825 (*desc
)->dump (abfd
);
2828 /* Display a section in hexadecimal format with associated characters.
2829 Each line prefixed by the zero padded address. */
2832 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2835 bfd_size_type datasize
;
2836 bfd_vma addr_offset
;
2837 bfd_vma start_offset
;
2838 bfd_vma stop_offset
;
2839 unsigned int opb
= bfd_octets_per_byte (abfd
);
2840 /* Bytes per line. */
2841 const int onaline
= 16;
2846 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2849 if (! process_section_p (section
))
2852 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2855 /* Compute the address range to display. */
2856 if (start_address
== (bfd_vma
) -1
2857 || start_address
< section
->vma
)
2860 start_offset
= start_address
- section
->vma
;
2862 if (stop_address
== (bfd_vma
) -1)
2863 stop_offset
= datasize
/ opb
;
2866 if (stop_address
< section
->vma
)
2869 stop_offset
= stop_address
- section
->vma
;
2871 if (stop_offset
> datasize
/ opb
)
2872 stop_offset
= datasize
/ opb
;
2875 if (start_offset
>= stop_offset
)
2878 printf (_("Contents of section %s:"), section
->name
);
2879 if (display_file_offsets
)
2880 printf (_(" (Starting at file offset: 0x%lx)"),
2881 (unsigned long) (section
->filepos
+ start_offset
));
2884 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2886 non_fatal (_("Reading section %s failed because: %s"),
2887 section
->name
, bfd_errmsg (bfd_get_error ()));
2893 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2894 if (strlen (buf
) >= sizeof (buf
))
2898 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2900 count
= strlen (buf
) - count
;
2904 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2905 if (strlen (buf
) >= sizeof (buf
))
2909 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2911 count
= strlen (buf
) - count
;
2915 for (addr_offset
= start_offset
;
2916 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2920 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2921 count
= strlen (buf
);
2922 if ((size_t) count
>= sizeof (buf
))
2926 while (count
< width
)
2931 fputs (buf
+ count
- width
, stdout
);
2934 for (j
= addr_offset
* opb
;
2935 j
< addr_offset
* opb
+ onaline
; j
++)
2937 if (j
< stop_offset
* opb
)
2938 printf ("%02x", (unsigned) (data
[j
]));
2946 for (j
= addr_offset
* opb
;
2947 j
< addr_offset
* opb
+ onaline
; j
++)
2949 if (j
>= stop_offset
* opb
)
2952 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2959 /* Actually display the various requested regions. */
2962 dump_data (bfd
*abfd
)
2964 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2967 /* Should perhaps share code and display with nm? */
2970 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2979 max_count
= dynsymcount
;
2980 printf ("DYNAMIC SYMBOL TABLE:\n");
2985 max_count
= symcount
;
2986 printf ("SYMBOL TABLE:\n");
2990 printf (_("no symbols\n"));
2992 for (count
= 0; count
< max_count
; count
++)
2996 if (*current
== NULL
)
2997 printf (_("no information for symbol number %ld\n"), count
);
2999 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3000 printf (_("could not determine the type of symbol number %ld\n"),
3003 else if (process_section_p ((* current
)->section
)
3004 && (dump_special_syms
3005 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3007 const char *name
= (*current
)->name
;
3009 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3013 /* If we want to demangle the name, we demangle it
3014 here, and temporarily clobber it while calling
3015 bfd_print_symbol. FIXME: This is a gross hack. */
3016 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3018 (*current
)->name
= alloc
;
3019 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3020 bfd_print_symbol_all
);
3023 (*current
)->name
= name
;
3028 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3029 bfd_print_symbol_all
);
3039 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3042 char *last_filename
, *last_functionname
;
3043 unsigned int last_line
;
3044 unsigned int last_discriminator
;
3046 /* Get column headers lined up reasonably. */
3054 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3055 width
= strlen (buf
) - 7;
3057 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3060 last_filename
= NULL
;
3061 last_functionname
= NULL
;
3063 last_discriminator
= 0;
3065 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3068 const char *filename
, *functionname
;
3069 unsigned int linenumber
;
3070 unsigned int discriminator
;
3071 const char *sym_name
;
3072 const char *section_name
;
3073 bfd_vma addend2
= 0;
3075 if (start_address
!= (bfd_vma
) -1
3076 && q
->address
< start_address
)
3078 if (stop_address
!= (bfd_vma
) -1
3079 && q
->address
> stop_address
)
3082 if (with_line_numbers
3084 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3085 &filename
, &functionname
,
3086 &linenumber
, &discriminator
))
3088 if (functionname
!= NULL
3089 && (last_functionname
== NULL
3090 || strcmp (functionname
, last_functionname
) != 0))
3092 printf ("%s():\n", functionname
);
3093 if (last_functionname
!= NULL
)
3094 free (last_functionname
);
3095 last_functionname
= xstrdup (functionname
);
3099 && (linenumber
!= last_line
3100 || (filename
!= NULL
3101 && last_filename
!= NULL
3102 && filename_cmp (filename
, last_filename
) != 0)
3103 || (discriminator
!= last_discriminator
)))
3105 if (discriminator
> 0)
3106 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3108 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3109 linenumber
, discriminator
);
3110 last_line
= linenumber
;
3111 last_discriminator
= discriminator
;
3112 if (last_filename
!= NULL
)
3113 free (last_filename
);
3114 if (filename
== NULL
)
3115 last_filename
= NULL
;
3117 last_filename
= xstrdup (filename
);
3121 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3123 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3124 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3129 section_name
= NULL
;
3132 bfd_printf_vma (abfd
, q
->address
);
3133 if (q
->howto
== NULL
)
3134 printf (" *unknown* ");
3135 else if (q
->howto
->name
)
3137 const char *name
= q
->howto
->name
;
3139 /* R_SPARC_OLO10 relocations contain two addends.
3140 But because 'arelent' lacks enough storage to
3141 store them both, the 64-bit ELF Sparc backend
3142 records this as two relocations. One R_SPARC_LO10
3143 and one R_SPARC_13, both pointing to the same
3144 address. This is merely so that we have some
3145 place to store both addend fields.
3147 Undo this transformation, otherwise the output
3148 will be confusing. */
3149 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3150 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3152 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3154 arelent
*q2
= *(p
+ 1);
3157 && q
->address
== q2
->address
3158 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3160 name
= "R_SPARC_OLO10";
3161 addend2
= q2
->addend
;
3165 printf (" %-16s ", name
);
3168 printf (" %-16d ", q
->howto
->type
);
3172 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3176 if (section_name
== NULL
)
3177 section_name
= "*unknown*";
3178 printf ("[%s]", section_name
);
3183 bfd_signed_vma addend
= q
->addend
;
3191 bfd_printf_vma (abfd
, addend
);
3196 bfd_printf_vma (abfd
, addend2
);
3202 if (last_filename
!= NULL
)
3203 free (last_filename
);
3204 if (last_functionname
!= NULL
)
3205 free (last_functionname
);
3209 dump_relocs_in_section (bfd
*abfd
,
3211 void *dummy ATTRIBUTE_UNUSED
)
3217 if ( bfd_is_abs_section (section
)
3218 || bfd_is_und_section (section
)
3219 || bfd_is_com_section (section
)
3220 || (! process_section_p (section
))
3221 || ((section
->flags
& SEC_RELOC
) == 0))
3224 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3226 bfd_fatal (bfd_get_filename (abfd
));
3228 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3232 printf (" (none)\n\n");
3236 relpp
= (arelent
**) xmalloc (relsize
);
3237 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3242 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3243 bfd_fatal (_("error message was"));
3245 else if (relcount
== 0)
3246 printf (" (none)\n\n");
3250 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3257 dump_relocs (bfd
*abfd
)
3259 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3263 dump_dynamic_relocs (bfd
*abfd
)
3269 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3271 bfd_fatal (bfd_get_filename (abfd
));
3273 printf ("DYNAMIC RELOCATION RECORDS");
3276 printf (" (none)\n\n");
3279 relpp
= (arelent
**) xmalloc (relsize
);
3280 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3283 bfd_fatal (bfd_get_filename (abfd
));
3284 else if (relcount
== 0)
3285 printf (" (none)\n\n");
3289 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3296 /* Creates a table of paths, to search for source files. */
3299 add_include_path (const char *path
)
3303 include_path_count
++;
3304 include_paths
= (const char **)
3305 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3306 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3307 if (path
[1] == ':' && path
[2] == 0)
3308 path
= concat (path
, ".", (const char *) 0);
3310 include_paths
[include_path_count
- 1] = path
;
3314 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3318 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3320 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3321 section
->vma
+= adjust_section_vma
;
3323 section
->lma
+= adjust_section_vma
;
3327 /* Dump selected contents of ABFD. */
3330 dump_bfd (bfd
*abfd
)
3332 /* If we are adjusting section VMA's, change them all now. Changing
3333 the BFD information is a hack. However, we must do it, or
3334 bfd_find_nearest_line will not do the right thing. */
3335 if (adjust_section_vma
!= 0)
3337 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3338 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3341 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3342 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3345 print_arelt_descr (stdout
, abfd
, TRUE
);
3346 if (dump_file_header
)
3347 dump_bfd_header (abfd
);
3348 if (dump_private_headers
)
3349 dump_bfd_private_header (abfd
);
3350 if (dump_private_options
!= NULL
)
3351 dump_target_specific (abfd
);
3352 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3359 || dump_dwarf_section_info
)
3360 syms
= slurp_symtab (abfd
);
3362 if (dump_section_headers
)
3363 dump_headers (abfd
);
3365 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3366 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3367 dynsyms
= slurp_dynamic_symtab (abfd
);
3370 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3371 dynsymcount
, dynsyms
, &synthsyms
);
3377 dump_symbols (abfd
, FALSE
);
3378 if (dump_dynamic_symtab
)
3379 dump_symbols (abfd
, TRUE
);
3380 if (dump_dwarf_section_info
)
3382 if (dump_stab_section_info
)
3384 if (dump_reloc_info
&& ! disassemble
)
3386 if (dump_dynamic_reloc_info
&& ! disassemble
)
3387 dump_dynamic_relocs (abfd
);
3388 if (dump_section_contents
)
3391 disassemble_data (abfd
);
3397 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3398 if (dhandle
!= NULL
)
3400 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3402 dump_debugging_tags
? TRUE
: FALSE
))
3404 non_fatal (_("%s: printing debugging information failed"),
3405 bfd_get_filename (abfd
));
3409 /* PR 6483: If there was no STABS or IEEE debug
3410 info in the file, try DWARF instead. */
3411 else if (! dump_dwarf_section_info
)
3413 dwarf_select_sections_all ();
3442 display_object_bfd (bfd
*abfd
)
3446 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3452 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3454 nonfatal (bfd_get_filename (abfd
));
3455 list_matching_formats (matching
);
3460 if (bfd_get_error () != bfd_error_file_not_recognized
)
3462 nonfatal (bfd_get_filename (abfd
));
3466 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3472 nonfatal (bfd_get_filename (abfd
));
3474 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3476 list_matching_formats (matching
);
3482 display_any_bfd (bfd
*file
, int level
)
3484 /* Decompress sections unless dumping the section contents. */
3485 if (!dump_section_contents
)
3486 file
->flags
|= BFD_DECOMPRESS
;
3488 /* If the file is an archive, process all of its elements. */
3489 if (bfd_check_format (file
, bfd_archive
))
3492 bfd
*last_arfile
= NULL
;
3495 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3496 else if (level
> 100)
3498 /* Prevent corrupted files from spinning us into an
3499 infinite loop. 100 is an arbitrary heuristic. */
3500 fatal (_("Archive nesting is too deep"));
3504 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3508 bfd_set_error (bfd_error_no_error
);
3510 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3513 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3514 nonfatal (bfd_get_filename (file
));
3518 display_any_bfd (arfile
, level
+ 1);
3520 if (last_arfile
!= NULL
)
3522 bfd_close (last_arfile
);
3523 /* PR 17512: file: ac585d01. */
3524 if (arfile
== last_arfile
)
3530 last_arfile
= arfile
;
3533 if (last_arfile
!= NULL
)
3534 bfd_close (last_arfile
);
3537 display_object_bfd (file
);
3541 display_file (char *filename
, char *target
)
3545 if (get_file_size (filename
) < 1)
3551 file
= bfd_openr (filename
, target
);
3554 nonfatal (filename
);
3558 display_any_bfd (file
, 0);
3564 main (int argc
, char **argv
)
3567 char *target
= default_target
;
3568 bfd_boolean seenflag
= FALSE
;
3570 #if defined (HAVE_SETLOCALE)
3571 #if defined (HAVE_LC_MESSAGES)
3572 setlocale (LC_MESSAGES
, "");
3574 setlocale (LC_CTYPE
, "");
3577 bindtextdomain (PACKAGE
, LOCALEDIR
);
3578 textdomain (PACKAGE
);
3580 program_name
= *argv
;
3581 xmalloc_set_program_name (program_name
);
3582 bfd_set_error_program_name (program_name
);
3584 START_PROGRESS (program_name
, 0);
3586 expandargv (&argc
, &argv
);
3589 set_default_bfd_target ();
3591 while ((c
= getopt_long (argc
, argv
,
3592 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3593 long_options
, (int *) 0))
3599 break; /* We've been given a long option. */
3604 if (disassembler_options
)
3605 /* Ignore potential memory leak for now. */
3606 disassembler_options
= concat (disassembler_options
, ",",
3607 optarg
, (const char *) NULL
);
3609 disassembler_options
= optarg
;
3615 display_file_offsets
= TRUE
;
3618 with_line_numbers
= TRUE
;
3627 enum demangling_styles style
;
3629 style
= cplus_demangle_name_to_style (optarg
);
3630 if (style
== unknown_demangling
)
3631 fatal (_("unknown demangling style `%s'"),
3634 cplus_demangle_set_style (style
);
3640 case OPTION_ADJUST_VMA
:
3641 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3643 case OPTION_START_ADDRESS
:
3644 start_address
= parse_vma (optarg
, "--start-address");
3645 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3646 fatal (_("error: the start address should be before the end address"));
3648 case OPTION_STOP_ADDRESS
:
3649 stop_address
= parse_vma (optarg
, "--stop-address");
3650 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3651 fatal (_("error: the stop address should be after the start address"));
3655 prefix_length
= strlen (prefix
);
3656 /* Remove an unnecessary trailing '/' */
3657 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3660 case OPTION_PREFIX_STRIP
:
3661 prefix_strip
= atoi (optarg
);
3662 if (prefix_strip
< 0)
3663 fatal (_("error: prefix strip must be non-negative"));
3665 case OPTION_INSN_WIDTH
:
3666 insn_width
= strtoul (optarg
, NULL
, 0);
3667 if (insn_width
<= 0)
3668 fatal (_("error: instruction width must be positive"));
3671 if (strcmp (optarg
, "B") == 0)
3672 endian
= BFD_ENDIAN_BIG
;
3673 else if (strcmp (optarg
, "L") == 0)
3674 endian
= BFD_ENDIAN_LITTLE
;
3677 nonfatal (_("unrecognized -E option"));
3682 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3683 endian
= BFD_ENDIAN_BIG
;
3684 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3685 endian
= BFD_ENDIAN_LITTLE
;
3688 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3695 dump_file_header
= TRUE
;
3699 formats_info
= TRUE
;
3703 add_include_path (optarg
);
3706 dump_private_headers
= TRUE
;
3710 dump_private_options
= optarg
;
3714 dump_private_headers
= TRUE
;
3716 dump_reloc_info
= TRUE
;
3717 dump_file_header
= TRUE
;
3718 dump_ar_hdrs
= TRUE
;
3719 dump_section_headers
= TRUE
;
3727 dump_dynamic_symtab
= TRUE
;
3735 disassemble_zeroes
= TRUE
;
3739 disassemble_all
= TRUE
;
3744 with_source_code
= TRUE
;
3753 dump_debugging_tags
= 1;
3758 dump_dwarf_section_info
= TRUE
;
3761 dwarf_select_sections_by_letters (optarg
);
3763 dwarf_select_sections_all ();
3766 dump_dwarf_section_info
= TRUE
;
3769 dwarf_select_sections_by_names (optarg
);
3771 dwarf_select_sections_all ();
3773 case OPTION_DWARF_DEPTH
:
3776 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3779 case OPTION_DWARF_START
:
3782 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3783 suppress_bfd_header
= 1;
3786 case OPTION_DWARF_CHECK
:
3790 dump_stab_section_info
= TRUE
;
3794 dump_section_contents
= TRUE
;
3798 dump_reloc_info
= TRUE
;
3802 dump_dynamic_reloc_info
= TRUE
;
3806 dump_ar_hdrs
= TRUE
;
3810 dump_section_headers
= TRUE
;
3815 show_version
= TRUE
;
3821 /* No need to set seenflag or to break - usage() does not return. */
3828 print_version ("objdump");
3834 exit_status
= display_info ();
3838 display_file ("a.out", target
);
3840 for (; optind
< argc
;)
3841 display_file (argv
[optind
++], target
);
3846 END_PROGRESS (program_name
);