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
)
497 /* Note - sections can have both the READONLY and NOREAD attributes
498 set. In this case the NOREAD takes precedence, but we report both
499 since the user may need to know that both bits are set. */
500 PF (SEC_ELF_NOREAD
, "NOREAD");
502 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
503 PF (SEC_GROUP
, "GROUP");
504 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
506 PF (SEC_MEP_VLIW
, "VLIW");
509 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
512 struct coff_comdat_info
*comdat
;
514 switch (section
->flags
& SEC_LINK_DUPLICATES
)
518 case SEC_LINK_DUPLICATES_DISCARD
:
519 ls
= "LINK_ONCE_DISCARD";
521 case SEC_LINK_DUPLICATES_ONE_ONLY
:
522 ls
= "LINK_ONCE_ONE_ONLY";
524 case SEC_LINK_DUPLICATES_SAME_SIZE
:
525 ls
= "LINK_ONCE_SAME_SIZE";
527 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
528 ls
= "LINK_ONCE_SAME_CONTENTS";
531 printf ("%s%s", comma
, ls
);
533 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
535 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
545 dump_headers (bfd
*abfd
)
547 printf (_("Sections:\n"));
550 printf (_("Idx Name Size VMA LMA File off Algn"));
552 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
553 if (bfd_get_arch_size (abfd
) == 32)
554 printf (_("Idx Name Size VMA LMA File off Algn"));
556 printf (_("Idx Name Size VMA LMA File off Algn"));
560 printf (_(" Flags"));
563 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
567 slurp_symtab (bfd
*abfd
)
572 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
578 storage
= bfd_get_symtab_upper_bound (abfd
);
581 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
582 bfd_fatal (_("error message was"));
585 sy
= (asymbol
**) xmalloc (storage
);
587 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
589 bfd_fatal (bfd_get_filename (abfd
));
593 /* Read in the dynamic symbols. */
596 slurp_dynamic_symtab (bfd
*abfd
)
601 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
604 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
606 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
612 bfd_fatal (bfd_get_filename (abfd
));
615 sy
= (asymbol
**) xmalloc (storage
);
617 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
619 bfd_fatal (bfd_get_filename (abfd
));
623 /* Filter out (in place) symbols that are useless for disassembly.
624 COUNT is the number of elements in SYMBOLS.
625 Return the number of useful symbols. */
628 remove_useless_symbols (asymbol
**symbols
, long count
)
630 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
634 asymbol
*sym
= *in_ptr
++;
636 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
638 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
640 if (bfd_is_und_section (sym
->section
)
641 || bfd_is_com_section (sym
->section
))
646 return out_ptr
- symbols
;
649 /* Sort symbols into value order. */
652 compare_symbols (const void *ap
, const void *bp
)
654 const asymbol
*a
= * (const asymbol
**) ap
;
655 const asymbol
*b
= * (const asymbol
**) bp
;
665 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
667 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
670 if (a
->section
> b
->section
)
672 else if (a
->section
< b
->section
)
675 an
= bfd_asymbol_name (a
);
676 bn
= bfd_asymbol_name (b
);
680 /* The symbols gnu_compiled and gcc2_compiled convey no real
681 information, so put them after other symbols with the same value. */
682 af
= (strstr (an
, "gnu_compiled") != NULL
683 || strstr (an
, "gcc2_compiled") != NULL
);
684 bf
= (strstr (bn
, "gnu_compiled") != NULL
685 || strstr (bn
, "gcc2_compiled") != NULL
);
692 /* We use a heuristic for the file name, to try to sort it after
693 more useful symbols. It may not work on non Unix systems, but it
694 doesn't really matter; the only difference is precisely which
695 symbol names get printed. */
697 #define file_symbol(s, sn, snl) \
698 (((s)->flags & BSF_FILE) != 0 \
699 || ((sn)[(snl) - 2] == '.' \
700 && ((sn)[(snl) - 1] == 'o' \
701 || (sn)[(snl) - 1] == 'a')))
703 af
= file_symbol (a
, an
, anl
);
704 bf
= file_symbol (b
, bn
, bnl
);
711 /* Try to sort global symbols before local symbols before function
712 symbols before debugging symbols. */
717 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
719 if ((aflags
& BSF_DEBUGGING
) != 0)
724 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
726 if ((aflags
& BSF_FUNCTION
) != 0)
731 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
733 if ((aflags
& BSF_LOCAL
) != 0)
738 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
740 if ((aflags
& BSF_GLOBAL
) != 0)
746 /* Symbols that start with '.' might be section names, so sort them
747 after symbols that don't start with '.'. */
748 if (an
[0] == '.' && bn
[0] != '.')
750 if (an
[0] != '.' && bn
[0] == '.')
753 /* Finally, if we can't distinguish them in any other way, try to
754 get consistent results by sorting the symbols by name. */
755 return strcmp (an
, bn
);
758 /* Sort relocs into address order. */
761 compare_relocs (const void *ap
, const void *bp
)
763 const arelent
*a
= * (const arelent
**) ap
;
764 const arelent
*b
= * (const arelent
**) bp
;
766 if (a
->address
> b
->address
)
768 else if (a
->address
< b
->address
)
771 /* So that associated relocations tied to the same address show up
772 in the correct order, we don't do any further sorting. */
781 /* Print an address (VMA) to the output stream in INFO.
782 If SKIP_ZEROES is TRUE, omit leading zeroes. */
785 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
786 bfd_boolean skip_zeroes
)
790 struct objdump_disasm_info
*aux
;
792 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
793 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
798 for (p
= buf
; *p
== '0'; ++p
)
803 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
806 /* Print the name of a symbol. */
809 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
813 const char *name
, *version_string
= NULL
;
814 bfd_boolean hidden
= FALSE
;
817 name
= bfd_asymbol_name (sym
);
818 if (do_demangle
&& name
[0] != '\0')
820 /* Demangle the name. */
821 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
826 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
828 if (bfd_is_und_section (bfd_get_section (sym
)))
833 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
834 if (version_string
&& *version_string
!= '\0')
835 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
841 if (version_string
&& *version_string
!= '\0')
842 printf (hidden
? "@%s" : "@@%s", version_string
);
849 /* Locate a symbol given a bfd and a section (from INFO->application_data),
850 and a VMA. If INFO->application_data->require_sec is TRUE, then always
851 require the symbol to be in the section. Returns NULL if there is no
852 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
853 of the symbol in sorted_syms. */
856 find_symbol_for_address (bfd_vma vma
,
857 struct disassemble_info
*inf
,
860 /* @@ Would it speed things up to cache the last two symbols returned,
861 and maybe their address ranges? For many processors, only one memory
862 operand can be present at a time, so the 2-entry cache wouldn't be
863 constantly churned by code doing heavy memory accesses. */
865 /* Indices in `sorted_syms'. */
867 long max_count
= sorted_symcount
;
869 struct objdump_disasm_info
*aux
;
873 bfd_boolean want_section
;
875 if (sorted_symcount
< 1)
878 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
881 opb
= inf
->octets_per_byte
;
883 /* Perform a binary search looking for the closest symbol to the
884 required value. We are searching the range (min, max_count]. */
885 while (min
+ 1 < max_count
)
889 thisplace
= (max_count
+ min
) / 2;
890 sym
= sorted_syms
[thisplace
];
892 if (bfd_asymbol_value (sym
) > vma
)
893 max_count
= thisplace
;
894 else if (bfd_asymbol_value (sym
) < vma
)
903 /* The symbol we want is now in min, the low end of the range we
904 were searching. If there are several symbols with the same
905 value, we want the first one. */
908 && (bfd_asymbol_value (sorted_syms
[thisplace
])
909 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
912 /* Prefer a symbol in the current section if we have multple symbols
913 with the same value, as can occur with overlays or zero size
916 while (min
< max_count
917 && (bfd_asymbol_value (sorted_syms
[min
])
918 == bfd_asymbol_value (sorted_syms
[thisplace
])))
920 if (sorted_syms
[min
]->section
== sec
921 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
928 return sorted_syms
[thisplace
];
933 /* If the file is relocatable, and the symbol could be from this
934 section, prefer a symbol from this section over symbols from
935 others, even if the other symbol's value might be closer.
937 Note that this may be wrong for some symbol references if the
938 sections have overlapping memory ranges, but in that case there's
939 no way to tell what's desired without looking at the relocation
942 Also give the target a chance to reject symbols. */
943 want_section
= (aux
->require_sec
944 || ((abfd
->flags
& HAS_RELOC
) != 0
945 && vma
>= bfd_get_section_vma (abfd
, sec
)
946 && vma
< (bfd_get_section_vma (abfd
, sec
)
947 + bfd_section_size (abfd
, sec
) / opb
)));
948 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
949 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
952 long newplace
= sorted_symcount
;
954 for (i
= min
- 1; i
>= 0; i
--)
956 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
957 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
959 if (newplace
== sorted_symcount
)
962 if (bfd_asymbol_value (sorted_syms
[i
])
963 != bfd_asymbol_value (sorted_syms
[newplace
]))
966 /* Remember this symbol and keep searching until we reach
967 an earlier address. */
972 if (newplace
!= sorted_symcount
)
973 thisplace
= newplace
;
976 /* We didn't find a good symbol with a smaller value.
977 Look for one with a larger value. */
978 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
980 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
981 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
989 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
990 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
991 /* There is no suitable symbol. */
998 return sorted_syms
[thisplace
];
1001 /* Print an address and the offset to the nearest symbol. */
1004 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1005 bfd_vma vma
, struct disassemble_info
*inf
,
1006 bfd_boolean skip_zeroes
)
1008 objdump_print_value (vma
, inf
, skip_zeroes
);
1014 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1015 bfd_get_section_name (abfd
, sec
));
1016 secaddr
= bfd_get_section_vma (abfd
, sec
);
1019 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1020 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1022 else if (vma
> secaddr
)
1024 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1025 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1027 (*inf
->fprintf_func
) (inf
->stream
, ">");
1031 (*inf
->fprintf_func
) (inf
->stream
, " <");
1032 objdump_print_symname (abfd
, inf
, sym
);
1033 if (bfd_asymbol_value (sym
) > vma
)
1035 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1036 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1038 else if (vma
> bfd_asymbol_value (sym
))
1040 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1041 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1043 (*inf
->fprintf_func
) (inf
->stream
, ">");
1046 if (display_file_offsets
)
1047 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1048 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1051 /* Print an address (VMA), symbolically if possible.
1052 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1055 objdump_print_addr (bfd_vma vma
,
1056 struct disassemble_info
*inf
,
1057 bfd_boolean skip_zeroes
)
1059 struct objdump_disasm_info
*aux
;
1060 asymbol
*sym
= NULL
;
1061 bfd_boolean skip_find
= FALSE
;
1063 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1065 if (sorted_symcount
< 1)
1067 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1068 objdump_print_value (vma
, inf
, skip_zeroes
);
1070 if (display_file_offsets
)
1071 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1072 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1076 if (aux
->reloc
!= NULL
1077 && aux
->reloc
->sym_ptr_ptr
!= NULL
1078 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1080 sym
= * aux
->reloc
->sym_ptr_ptr
;
1082 /* Adjust the vma to the reloc. */
1083 vma
+= bfd_asymbol_value (sym
);
1085 if (bfd_is_und_section (bfd_get_section (sym
)))
1090 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1092 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1096 /* Print VMA to INFO. This function is passed to the disassembler
1100 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1102 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1105 /* Determine if the given address has a symbol associated with it. */
1108 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1112 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1114 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1117 /* Hold the last function name and the last line number we displayed
1118 in a disassembly. */
1120 static char *prev_functionname
;
1121 static unsigned int prev_line
;
1122 static unsigned int prev_discriminator
;
1124 /* We keep a list of all files that we have seen when doing a
1125 disassembly with source, so that we know how much of the file to
1126 display. This can be important for inlined functions. */
1128 struct print_file_list
1130 struct print_file_list
*next
;
1131 const char *filename
;
1132 const char *modname
;
1135 const char **linemap
;
1141 static struct print_file_list
*print_files
;
1143 /* The number of preceding context lines to show when we start
1144 displaying a file for the first time. */
1146 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1148 /* Read a complete file into memory. */
1151 slurp_file (const char *fn
, size_t *size
)
1154 int ps
= getpagesize ();
1159 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1163 if (fstat (fd
, &st
) < 0)
1170 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1171 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1172 if (map
!= (char *) -1L)
1178 map
= (const char *) malloc (*size
);
1179 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1181 free ((void *) map
);
1188 #define line_map_decrease 5
1190 /* Precompute array of lines for a mapped file. */
1192 static const char **
1193 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1195 const char *p
, *lstart
, *end
;
1196 int chars_per_line
= 45; /* First iteration will use 40. */
1197 unsigned int lineno
;
1198 const char **linemap
= NULL
;
1199 unsigned long line_map_size
= 0;
1205 for (p
= map
; p
< end
; p
++)
1209 if (p
+ 1 < end
&& p
[1] == '\r')
1212 else if (*p
== '\r')
1214 if (p
+ 1 < end
&& p
[1] == '\n')
1220 /* End of line found. */
1222 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1224 unsigned long newsize
;
1226 chars_per_line
-= line_map_decrease
;
1227 if (chars_per_line
<= 1)
1229 line_map_size
= size
/ chars_per_line
+ 1;
1230 if (line_map_size
< lineno
+ 1)
1231 line_map_size
= lineno
+ 1;
1232 newsize
= line_map_size
* sizeof (char *);
1233 linemap
= (const char **) xrealloc (linemap
, newsize
);
1236 linemap
[lineno
++] = lstart
;
1244 /* Tries to open MODNAME, and if successful adds a node to print_files
1245 linked list and returns that node. Returns NULL on failure. */
1247 static struct print_file_list
*
1248 try_print_file_open (const char *origname
, const char *modname
)
1250 struct print_file_list
*p
;
1252 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1254 p
->map
= slurp_file (modname
, &p
->mapsize
);
1261 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1263 p
->filename
= origname
;
1264 p
->modname
= modname
;
1265 p
->next
= print_files
;
1271 /* If the source file, as described in the symtab, is not found
1272 try to locate it in one of the paths specified with -I
1273 If found, add location to print_files linked list. */
1275 static struct print_file_list
*
1276 update_source_path (const char *filename
)
1278 struct print_file_list
*p
;
1282 p
= try_print_file_open (filename
, filename
);
1286 if (include_path_count
== 0)
1289 /* Get the name of the file. */
1290 fname
= lbasename (filename
);
1292 /* If file exists under a new path, we need to add it to the list
1293 so that show_line knows about it. */
1294 for (i
= 0; i
< include_path_count
; i
++)
1296 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1298 p
= try_print_file_open (filename
, modname
);
1308 /* Print a source file line. */
1311 print_line (struct print_file_list
*p
, unsigned int linenum
)
1317 if (linenum
>= p
->maxline
)
1319 l
= p
->linemap
[linenum
];
1320 /* Test fwrite return value to quiet glibc warning. */
1321 len
= strcspn (l
, "\n\r");
1322 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1326 /* Print a range of source code lines. */
1329 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1333 while (start
<= end
)
1335 print_line (p
, start
);
1340 /* Show the line number, or the source line, in a disassembly
1344 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1346 const char *filename
;
1347 const char *functionname
;
1348 unsigned int linenumber
;
1349 unsigned int discriminator
;
1353 if (! with_line_numbers
&& ! with_source_code
)
1356 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1357 &filename
, &functionname
,
1358 &linenumber
, &discriminator
))
1361 if (filename
!= NULL
&& *filename
== '\0')
1363 if (functionname
!= NULL
&& *functionname
== '\0')
1364 functionname
= NULL
;
1367 && IS_ABSOLUTE_PATH (filename
)
1371 const char *fname
= filename
;
1373 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1376 memcpy (path
, prefix
, prefix_length
);
1377 path_up
= path
+ prefix_length
;
1379 /* Build relocated filename, stripping off leading directories
1380 from the initial filename if requested. */
1381 if (prefix_strip
> 0)
1386 /* Skip selected directory levels. */
1387 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1388 if (IS_DIR_SEPARATOR(*s
))
1395 /* Update complete filename. */
1396 strncpy (path_up
, fname
, PATH_MAX
);
1397 path_up
[PATH_MAX
] = '\0';
1405 if (with_line_numbers
)
1407 if (functionname
!= NULL
1408 && (prev_functionname
== NULL
1409 || strcmp (functionname
, prev_functionname
) != 0))
1410 printf ("%s():\n", functionname
);
1411 if (linenumber
> 0 && (linenumber
!= prev_line
||
1412 (discriminator
!= prev_discriminator
)))
1414 if (discriminator
> 0)
1415 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
1416 linenumber
, discriminator
);
1418 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1422 if (with_source_code
1426 struct print_file_list
**pp
, *p
;
1429 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1430 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1437 filename
= xstrdup (filename
);
1438 p
= update_source_path (filename
);
1441 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1443 if (file_start_context
&& p
->first
)
1447 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1448 if (l
>= linenumber
)
1450 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1451 l
= p
->last_line
+ 1;
1453 dump_lines (p
, l
, linenumber
);
1454 p
->last_line
= linenumber
;
1459 if (functionname
!= NULL
1460 && (prev_functionname
== NULL
1461 || strcmp (functionname
, prev_functionname
) != 0))
1463 if (prev_functionname
!= NULL
)
1464 free (prev_functionname
);
1465 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1466 strcpy (prev_functionname
, functionname
);
1469 if (linenumber
> 0 && linenumber
!= prev_line
)
1470 prev_line
= linenumber
;
1472 if (discriminator
!= prev_discriminator
)
1473 prev_discriminator
= discriminator
;
1479 /* Pseudo FILE object for strings. */
1487 /* sprintf to a "stream". */
1489 static int ATTRIBUTE_PRINTF_2
1490 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1497 size_t space
= f
->alloc
- f
->pos
;
1499 va_start (args
, format
);
1500 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1506 f
->alloc
= (f
->alloc
+ n
) * 2;
1507 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1514 /* The number of zeroes we want to see before we start skipping them.
1515 The number is arbitrarily chosen. */
1517 #define DEFAULT_SKIP_ZEROES 8
1519 /* The number of zeroes to skip at the end of a section. If the
1520 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1521 SKIP_ZEROES, they will be disassembled. If there are fewer than
1522 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1523 attempt to avoid disassembling zeroes inserted by section
1526 #define DEFAULT_SKIP_ZEROES_AT_END 3
1528 /* Disassemble some data in memory between given values. */
1531 disassemble_bytes (struct disassemble_info
* inf
,
1532 disassembler_ftype disassemble_fn
,
1535 bfd_vma start_offset
,
1536 bfd_vma stop_offset
,
1539 arelent
** relppend
)
1541 struct objdump_disasm_info
*aux
;
1543 int octets_per_line
;
1544 int skip_addr_chars
;
1545 bfd_vma addr_offset
;
1546 unsigned int opb
= inf
->octets_per_byte
;
1547 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1548 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1552 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1556 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1560 octets_per_line
= insn_width
;
1562 octets_per_line
= 4;
1564 octets_per_line
= 16;
1566 /* Figure out how many characters to skip at the start of an
1567 address, to make the disassembly look nicer. We discard leading
1568 zeroes in chunks of 4, ensuring that there is always a leading
1570 skip_addr_chars
= 0;
1571 if (! prefix_addresses
)
1575 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1577 while (buf
[skip_addr_chars
] == '0')
1580 /* Don't discard zeros on overflow. */
1581 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1582 skip_addr_chars
= 0;
1584 if (skip_addr_chars
!= 0)
1585 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1588 inf
->insn_info_valid
= 0;
1590 addr_offset
= start_offset
;
1591 while (addr_offset
< stop_offset
)
1594 bfd_boolean need_nl
= FALSE
;
1595 int previous_octets
;
1597 /* Remember the length of the previous instruction. */
1598 previous_octets
= octets
;
1601 /* Make sure we don't use relocs from previous instructions. */
1604 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1606 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1609 if (! disassemble_zeroes
1610 && (inf
->insn_info_valid
== 0
1611 || inf
->branch_delay_insns
== 0)
1612 && (z
- addr_offset
* opb
>= skip_zeroes
1613 || (z
== stop_offset
* opb
&&
1614 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1616 /* If there are more nonzero octets to follow, we only skip
1617 zeroes in multiples of 4, to try to avoid running over
1618 the start of an instruction which happens to start with
1620 if (z
!= stop_offset
* opb
)
1621 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1623 octets
= z
- addr_offset
* opb
;
1625 /* If we are going to display more data, and we are displaying
1626 file offsets, then tell the user how many zeroes we skip
1627 and the file offset from where we resume dumping. */
1628 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1629 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1631 (unsigned long) (section
->filepos
1632 + (addr_offset
+ (octets
/ opb
))));
1642 if (with_line_numbers
|| with_source_code
)
1643 show_line (aux
->abfd
, section
, addr_offset
);
1645 if (! prefix_addresses
)
1649 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1650 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1654 printf ("%s:\t", buf
+ skip_addr_chars
);
1658 aux
->require_sec
= TRUE
;
1659 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1660 aux
->require_sec
= FALSE
;
1667 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1668 inf
->stream
= &sfile
;
1669 inf
->bytes_per_line
= 0;
1670 inf
->bytes_per_chunk
= 0;
1671 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1673 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1675 if (inf
->disassembler_needs_relocs
1676 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1677 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1678 && *relppp
< relppend
)
1680 bfd_signed_vma distance_to_rel
;
1682 distance_to_rel
= (**relppp
)->address
1683 - (rel_offset
+ addr_offset
);
1685 /* Check to see if the current reloc is associated with
1686 the instruction that we are about to disassemble. */
1687 if (distance_to_rel
== 0
1688 /* FIXME: This is wrong. We are trying to catch
1689 relocs that are addressed part way through the
1690 current instruction, as might happen with a packed
1691 VLIW instruction. Unfortunately we do not know the
1692 length of the current instruction since we have not
1693 disassembled it yet. Instead we take a guess based
1694 upon the length of the previous instruction. The
1695 proper solution is to have a new target-specific
1696 disassembler function which just returns the length
1697 of an instruction at a given address without trying
1698 to display its disassembly. */
1699 || (distance_to_rel
> 0
1700 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1702 inf
->flags
|= INSN_HAS_RELOC
;
1703 aux
->reloc
= **relppp
;
1707 if (! disassemble_all
1708 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1709 == (SEC_CODE
| SEC_HAS_CONTENTS
))
1710 /* Set a stop_vma so that the disassembler will not read
1711 beyond the next symbol. We assume that symbols appear on
1712 the boundaries between instructions. We only do this when
1713 disassembling code of course, and when -D is in effect. */
1714 inf
->stop_vma
= section
->vma
+ stop_offset
;
1716 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1719 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1720 inf
->stream
= stdout
;
1721 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1722 octets_per_line
= inf
->bytes_per_line
;
1723 if (octets
< (int) opb
)
1726 printf ("%s\n", sfile
.buffer
);
1729 non_fatal (_("disassemble_fn returned length %d"),
1740 octets
= octets_per_line
;
1741 if (addr_offset
+ octets
/ opb
> stop_offset
)
1742 octets
= (stop_offset
- addr_offset
) * opb
;
1744 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1746 if (ISPRINT (data
[j
]))
1747 buf
[j
- addr_offset
* opb
] = data
[j
];
1749 buf
[j
- addr_offset
* opb
] = '.';
1751 buf
[j
- addr_offset
* opb
] = '\0';
1754 if (prefix_addresses
1756 : show_raw_insn
>= 0)
1760 /* If ! prefix_addresses and ! wide_output, we print
1761 octets_per_line octets per line. */
1763 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1764 pb
= octets_per_line
;
1766 if (inf
->bytes_per_chunk
)
1767 bpc
= inf
->bytes_per_chunk
;
1771 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1775 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1777 for (k
= bpc
- 1; k
>= 0; k
--)
1778 printf ("%02x", (unsigned) data
[j
+ k
]);
1783 for (k
= 0; k
< bpc
; k
++)
1784 printf ("%02x", (unsigned) data
[j
+ k
]);
1789 for (; pb
< octets_per_line
; pb
+= bpc
)
1793 for (k
= 0; k
< bpc
; k
++)
1798 /* Separate raw data from instruction by extra space. */
1808 printf ("%s", sfile
.buffer
);
1810 if (prefix_addresses
1812 : show_raw_insn
>= 0)
1820 j
= addr_offset
* opb
+ pb
;
1822 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1823 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1827 printf ("%s:\t", buf
+ skip_addr_chars
);
1829 pb
+= octets_per_line
;
1832 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1836 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1838 for (k
= bpc
- 1; k
>= 0; k
--)
1839 printf ("%02x", (unsigned) data
[j
+ k
]);
1844 for (k
= 0; k
< bpc
; k
++)
1845 printf ("%02x", (unsigned) data
[j
+ k
]);
1858 while ((*relppp
) < relppend
1859 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1861 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1872 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1875 if (q
->howto
== NULL
)
1876 printf (": *unknown*\t");
1877 else if (q
->howto
->name
)
1878 printf (": %s\t", q
->howto
->name
);
1880 printf (": %d\t", q
->howto
->type
);
1882 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1883 printf ("*unknown*");
1886 const char *sym_name
;
1888 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1889 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1890 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1895 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1896 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1897 if (sym_name
== NULL
|| *sym_name
== '\0')
1898 sym_name
= "*unknown*";
1899 printf ("%s", sym_name
);
1905 bfd_signed_vma addend
= q
->addend
;
1913 objdump_print_value (addend
, inf
, TRUE
);
1925 addr_offset
+= octets
/ opb
;
1928 free (sfile
.buffer
);
1932 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1934 const struct elf_backend_data
* bed
;
1935 bfd_vma sign_adjust
= 0;
1936 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1937 struct objdump_disasm_info
* paux
;
1938 unsigned int opb
= pinfo
->octets_per_byte
;
1939 bfd_byte
* data
= NULL
;
1940 bfd_size_type datasize
= 0;
1941 arelent
** rel_pp
= NULL
;
1942 arelent
** rel_ppstart
= NULL
;
1943 arelent
** rel_ppend
;
1944 bfd_vma stop_offset
;
1945 asymbol
* sym
= NULL
;
1949 unsigned long addr_offset
;
1951 /* Sections that do not contain machine
1952 code are not normally disassembled. */
1953 if (! disassemble_all
1954 && only_list
== NULL
1955 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1956 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1959 if (! process_section_p (section
))
1962 datasize
= bfd_get_section_size (section
);
1966 if (start_address
== (bfd_vma
) -1
1967 || start_address
< section
->vma
)
1970 addr_offset
= start_address
- section
->vma
;
1972 if (stop_address
== (bfd_vma
) -1)
1973 stop_offset
= datasize
/ opb
;
1976 if (stop_address
< section
->vma
)
1979 stop_offset
= stop_address
- section
->vma
;
1980 if (stop_offset
> datasize
/ opb
)
1981 stop_offset
= datasize
/ opb
;
1984 if (addr_offset
>= stop_offset
)
1987 /* Decide which set of relocs to use. Load them if necessary. */
1988 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1989 if (paux
->dynrelbuf
)
1991 rel_pp
= paux
->dynrelbuf
;
1992 rel_count
= paux
->dynrelcount
;
1993 /* Dynamic reloc addresses are absolute, non-dynamic are section
1994 relative. REL_OFFSET specifies the reloc address corresponding
1995 to the start of this section. */
1996 rel_offset
= section
->vma
;
2004 if ((section
->flags
& SEC_RELOC
) != 0
2005 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2009 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2011 bfd_fatal (bfd_get_filename (abfd
));
2015 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2016 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2018 bfd_fatal (bfd_get_filename (abfd
));
2020 /* Sort the relocs by address. */
2021 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2025 rel_ppend
= rel_pp
+ rel_count
;
2027 data
= (bfd_byte
*) xmalloc (datasize
);
2029 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2031 paux
->sec
= section
;
2032 pinfo
->buffer
= data
;
2033 pinfo
->buffer_vma
= section
->vma
;
2034 pinfo
->buffer_length
= datasize
;
2035 pinfo
->section
= section
;
2037 /* Skip over the relocs belonging to addresses below the
2039 while (rel_pp
< rel_ppend
2040 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2043 printf (_("\nDisassembly of section %s:\n"), section
->name
);
2045 /* Find the nearest symbol forwards from our current position. */
2046 paux
->require_sec
= TRUE
;
2047 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2048 (struct disassemble_info
*) inf
,
2050 paux
->require_sec
= FALSE
;
2052 /* PR 9774: If the target used signed addresses then we must make
2053 sure that we sign extend the value that we calculate for 'addr'
2054 in the loop below. */
2055 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2056 && (bed
= get_elf_backend_data (abfd
)) != NULL
2057 && bed
->sign_extend_vma
)
2058 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2060 /* Disassemble a block of instructions up to the address associated with
2061 the symbol we have just found. Then print the symbol and find the
2062 next symbol on. Repeat until we have disassembled the entire section
2063 or we have reached the end of the address range we are interested in. */
2064 while (addr_offset
< stop_offset
)
2068 bfd_vma nextstop_offset
;
2071 addr
= section
->vma
+ addr_offset
;
2072 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2074 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2079 (x
< sorted_symcount
2080 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2084 pinfo
->symbols
= sorted_syms
+ place
;
2085 pinfo
->num_symbols
= x
- place
;
2086 pinfo
->symtab_pos
= place
;
2090 pinfo
->symbols
= NULL
;
2091 pinfo
->num_symbols
= 0;
2092 pinfo
->symtab_pos
= -1;
2095 if (! prefix_addresses
)
2097 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2098 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2100 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2103 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2105 else if (sym
== NULL
)
2109 #define is_valid_next_sym(SYM) \
2110 ((SYM)->section == section \
2111 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2112 && pinfo->symbol_is_valid (SYM, pinfo))
2114 /* Search forward for the next appropriate symbol in
2115 SECTION. Note that all the symbols are sorted
2116 together into one big array, and that some sections
2117 may have overlapping addresses. */
2118 while (place
< sorted_symcount
2119 && ! is_valid_next_sym (sorted_syms
[place
]))
2122 if (place
>= sorted_symcount
)
2125 nextsym
= sorted_syms
[place
];
2128 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2129 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2130 else if (nextsym
== NULL
)
2131 nextstop_offset
= stop_offset
;
2133 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2135 if (nextstop_offset
> stop_offset
2136 || nextstop_offset
<= addr_offset
)
2137 nextstop_offset
= stop_offset
;
2139 /* If a symbol is explicitly marked as being an object
2140 rather than a function, just dump the bytes without
2141 disassembling them. */
2144 || sym
->section
!= section
2145 || bfd_asymbol_value (sym
) > addr
2146 || ((sym
->flags
& BSF_OBJECT
) == 0
2147 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2149 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2151 || (sym
->flags
& BSF_FUNCTION
) != 0)
2156 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2157 addr_offset
, nextstop_offset
,
2158 rel_offset
, &rel_pp
, rel_ppend
);
2160 addr_offset
= nextstop_offset
;
2166 if (rel_ppstart
!= NULL
)
2170 /* Disassemble the contents of an object file. */
2173 disassemble_data (bfd
*abfd
)
2175 struct disassemble_info disasm_info
;
2176 struct objdump_disasm_info aux
;
2180 prev_functionname
= NULL
;
2182 prev_discriminator
= 0;
2184 /* We make a copy of syms to sort. We don't want to sort syms
2185 because that will screw up the relocs. */
2186 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2187 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2188 * sizeof (asymbol
*));
2189 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2190 sorted_symcount
* sizeof (asymbol
*));
2192 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2194 for (i
= 0; i
< synthcount
; ++i
)
2196 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2200 /* Sort the symbols into section and symbol order. */
2201 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2203 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2205 disasm_info
.application_data
= (void *) &aux
;
2207 aux
.require_sec
= FALSE
;
2208 aux
.dynrelbuf
= NULL
;
2209 aux
.dynrelcount
= 0;
2212 disasm_info
.print_address_func
= objdump_print_address
;
2213 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2215 if (machine
!= NULL
)
2217 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2220 fatal (_("can't use supplied machine %s"), machine
);
2222 abfd
->arch_info
= inf
;
2225 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2227 struct bfd_target
*xvec
;
2229 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2230 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2231 xvec
->byteorder
= endian
;
2235 /* Use libopcodes to locate a suitable disassembler. */
2236 aux
.disassemble_fn
= disassembler (abfd
);
2237 if (!aux
.disassemble_fn
)
2239 non_fatal (_("can't disassemble for architecture %s\n"),
2240 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2245 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2246 disasm_info
.arch
= bfd_get_arch (abfd
);
2247 disasm_info
.mach
= bfd_get_mach (abfd
);
2248 disasm_info
.disassembler_options
= disassembler_options
;
2249 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2250 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2251 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2252 disasm_info
.disassembler_needs_relocs
= FALSE
;
2254 if (bfd_big_endian (abfd
))
2255 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2256 else if (bfd_little_endian (abfd
))
2257 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2259 /* ??? Aborting here seems too drastic. We could default to big or little
2261 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2263 /* Allow the target to customize the info structure. */
2264 disassemble_init_for_target (& disasm_info
);
2266 /* Pre-load the dynamic relocs if we are going
2267 to be dumping them along with the disassembly. */
2268 if (dump_dynamic_reloc_info
)
2270 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2273 bfd_fatal (bfd_get_filename (abfd
));
2277 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2278 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2281 if (aux
.dynrelcount
< 0)
2282 bfd_fatal (bfd_get_filename (abfd
));
2284 /* Sort the relocs by address. */
2285 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2289 disasm_info
.symtab
= sorted_syms
;
2290 disasm_info
.symtab_size
= sorted_symcount
;
2292 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2294 if (aux
.dynrelbuf
!= NULL
)
2295 free (aux
.dynrelbuf
);
2300 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2301 asection
*sec
, void *file
)
2303 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2304 bfd
*abfd
= (bfd
*) file
;
2307 /* If it is already loaded, do nothing. */
2308 if (section
->start
!= NULL
)
2311 section
->reloc_info
= NULL
;
2312 section
->num_relocs
= 0;
2313 section
->address
= bfd_get_section_vma (abfd
, sec
);
2314 section
->size
= bfd_get_section_size (sec
);
2315 section
->start
= NULL
;
2316 section
->user_data
= sec
;
2317 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2321 free_debug_section (debug
);
2322 printf (_("\nCan't get contents for section '%s'.\n"),
2327 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2329 bfd_cache_section_contents (sec
, section
->start
);
2331 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2338 free_debug_section (debug
);
2339 printf (_("\nCan't get contents for section '%s'.\n"),
2346 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2349 unsigned long reloc_count
;
2352 relocs
= (arelent
**) xmalloc (reloc_size
);
2354 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2355 if (reloc_count
== 0)
2359 section
->reloc_info
= relocs
;
2360 section
->num_relocs
= reloc_count
;
2369 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2374 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2377 relocs
= (arelent
**) dsec
->reloc_info
;
2379 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2380 if (rp
->address
== offset
)
2387 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2389 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2390 bfd
*abfd
= (bfd
*) file
;
2393 /* If it is already loaded, do nothing. */
2394 if (section
->start
!= NULL
)
2397 /* Locate the debug section. */
2398 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2400 section
->name
= section
->uncompressed_name
;
2403 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2405 section
->name
= section
->compressed_name
;
2410 return load_specific_debug_section (debug
, sec
, file
);
2414 free_debug_section (enum dwarf_section_display_enum debug
)
2416 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2418 if (section
->start
== NULL
)
2421 /* PR 17512: file: 0f67f69d. */
2422 if (section
->user_data
!= NULL
)
2424 asection
* sec
= (asection
*) section
->user_data
;
2426 /* If we are freeing contents that are also pointed to by the BFD
2427 library's section structure then make sure to update those pointers
2428 too. Otherwise, the next time we try to load data for this section
2429 we can end up using a stale pointer. */
2430 if (section
->start
== sec
->contents
)
2432 sec
->contents
= NULL
;
2433 sec
->flags
&= ~ SEC_IN_MEMORY
;
2434 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2438 free ((char *) section
->start
);
2439 section
->start
= NULL
;
2440 section
->address
= 0;
2445 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2446 void *arg ATTRIBUTE_UNUSED
)
2448 const char *name
= bfd_get_section_name (abfd
, section
);
2452 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2453 match
= ".debug_info";
2457 for (i
= 0; i
< max
; i
++)
2458 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2459 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2460 && debug_displays
[i
].enabled
!= NULL
2461 && *debug_displays
[i
].enabled
)
2463 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2465 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2466 sec
->name
= sec
->uncompressed_name
;
2468 sec
->name
= sec
->compressed_name
;
2469 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2472 debug_displays
[i
].display (sec
, abfd
);
2474 if (i
!= info
&& i
!= abbrev
)
2475 free_debug_section ((enum dwarf_section_display_enum
) i
);
2481 /* Dump the dwarf debugging information. */
2484 dump_dwarf (bfd
*abfd
)
2486 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2488 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2490 if (bfd_big_endian (abfd
))
2491 byte_get
= byte_get_big_endian
;
2492 else if (bfd_little_endian (abfd
))
2493 byte_get
= byte_get_little_endian
;
2495 /* PR 17512: file: objdump-s-endless-loop.tekhex. */
2497 warn (_("File %s does not contain any dwarf debug information\n"),
2498 bfd_get_filename (abfd
));
2502 switch (bfd_get_arch (abfd
))
2505 switch (bfd_get_mach (abfd
))
2507 case bfd_mach_x86_64
:
2508 case bfd_mach_x86_64_intel_syntax
:
2509 case bfd_mach_x86_64_nacl
:
2510 case bfd_mach_x64_32
:
2511 case bfd_mach_x64_32_intel_syntax
:
2512 case bfd_mach_x64_32_nacl
:
2513 init_dwarf_regnames_x86_64 ();
2517 init_dwarf_regnames_i386 ();
2522 case bfd_arch_iamcu
:
2523 init_dwarf_regnames_iamcu ();
2526 case bfd_arch_aarch64
:
2527 init_dwarf_regnames_aarch64();
2534 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2536 free_debug_memory ();
2539 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2540 it. Return NULL on failure. */
2543 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2549 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2550 if (stabsect
== NULL
)
2552 printf (_("No %s section present\n\n"), sect_name
);
2556 size
= bfd_section_size (abfd
, stabsect
);
2557 contents
= (char *) xmalloc (size
);
2559 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2561 non_fatal (_("reading %s section of %s failed: %s"),
2562 sect_name
, bfd_get_filename (abfd
),
2563 bfd_errmsg (bfd_get_error ()));
2574 /* Stabs entries use a 12 byte format:
2575 4 byte string table index
2577 1 byte stab other field
2578 2 byte stab desc field
2580 FIXME: This will have to change for a 64 bit object format. */
2582 #define STRDXOFF (0)
2584 #define OTHEROFF (5)
2587 #define STABSIZE (12)
2589 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2590 using string table section STRSECT_NAME (in `strtab'). */
2593 print_section_stabs (bfd
*abfd
,
2594 const char *stabsect_name
,
2595 unsigned *string_offset_ptr
)
2598 unsigned file_string_table_offset
= 0;
2599 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2600 bfd_byte
*stabp
, *stabs_end
;
2603 stabs_end
= stabp
+ stab_size
;
2605 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2606 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2608 /* Loop through all symbols and print them.
2610 We start the index at -1 because there is a dummy symbol on
2611 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2612 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
2616 unsigned char type
, other
;
2617 unsigned short desc
;
2620 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2621 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2622 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2623 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2624 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2626 printf ("\n%-6d ", i
);
2627 /* Either print the stab name, or, if unnamed, print its number
2628 again (makes consistent formatting for tools like awk). */
2629 name
= bfd_get_stab_name (type
);
2631 printf ("%-6s", name
);
2632 else if (type
== N_UNDF
)
2635 printf ("%-6d", type
);
2636 printf (" %-6d %-6d ", other
, desc
);
2637 bfd_printf_vma (abfd
, value
);
2638 printf (" %-6lu", strx
);
2640 /* Symbols with type == 0 (N_UNDF) specify the length of the
2641 string table associated with this file. We use that info
2642 to know how to relocate the *next* file's string table indices. */
2645 file_string_table_offset
= next_file_string_table_offset
;
2646 next_file_string_table_offset
+= value
;
2650 bfd_size_type amt
= strx
+ file_string_table_offset
;
2652 /* Using the (possibly updated) string table offset, print the
2653 string (if any) associated with this symbol. */
2654 if (amt
< stabstr_size
)
2655 /* PR 17512: file: 079-79389-0.001:0.1. */
2656 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
2662 *string_offset_ptr
= next_file_string_table_offset
;
2667 const char * section_name
;
2668 const char * string_section_name
;
2669 unsigned string_offset
;
2674 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2677 stab_section_names
* sought
= (stab_section_names
*) names
;
2679 /* Check for section names for which stabsect_name is a prefix, to
2680 handle .stab.N, etc. */
2681 len
= strlen (sought
->section_name
);
2683 /* If the prefix matches, and the files section name ends with a
2684 nul or a digit, then we match. I.e., we want either an exact
2685 match or a section followed by a number. */
2686 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2687 && (section
->name
[len
] == 0
2688 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2691 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2696 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2699 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2705 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2707 stab_section_names s
;
2709 s
.section_name
= stabsect_name
;
2710 s
.string_section_name
= strsect_name
;
2711 s
.string_offset
= 0;
2713 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2719 /* Dump the any sections containing stabs debugging information. */
2722 dump_stabs (bfd
*abfd
)
2724 dump_stabs_section (abfd
, ".stab", ".stabstr");
2725 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2726 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2729 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2731 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2735 dump_bfd_header (bfd
*abfd
)
2739 printf (_("architecture: %s, "),
2740 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2741 bfd_get_mach (abfd
)));
2742 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
2744 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2745 PF (HAS_RELOC
, "HAS_RELOC");
2746 PF (EXEC_P
, "EXEC_P");
2747 PF (HAS_LINENO
, "HAS_LINENO");
2748 PF (HAS_DEBUG
, "HAS_DEBUG");
2749 PF (HAS_SYMS
, "HAS_SYMS");
2750 PF (HAS_LOCALS
, "HAS_LOCALS");
2751 PF (DYNAMIC
, "DYNAMIC");
2752 PF (WP_TEXT
, "WP_TEXT");
2753 PF (D_PAGED
, "D_PAGED");
2754 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2755 printf (_("\nstart address 0x"));
2756 bfd_printf_vma (abfd
, abfd
->start_address
);
2762 dump_bfd_private_header (bfd
*abfd
)
2764 bfd_print_private_bfd_data (abfd
, stdout
);
2768 dump_target_specific (bfd
*abfd
)
2770 const struct objdump_private_desc
* const *desc
;
2771 struct objdump_private_option
*opt
;
2774 /* Find the desc. */
2775 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
2776 if ((*desc
)->filter (abfd
))
2781 non_fatal (_("option -P/--private not supported by this file"));
2785 /* Clear all options. */
2786 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2787 opt
->selected
= FALSE
;
2789 /* Decode options. */
2790 b
= dump_private_options
;
2793 e
= strchr (b
, ',');
2798 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
2799 if (strcmp (opt
->name
, b
) == 0)
2801 opt
->selected
= TRUE
;
2804 if (opt
->name
== NULL
)
2805 non_fatal (_("target specific dump '%s' not supported"), b
);
2816 (*desc
)->dump (abfd
);
2819 /* Display a section in hexadecimal format with associated characters.
2820 Each line prefixed by the zero padded address. */
2823 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2826 bfd_size_type datasize
;
2827 bfd_vma addr_offset
;
2828 bfd_vma start_offset
;
2829 bfd_vma stop_offset
;
2830 unsigned int opb
= bfd_octets_per_byte (abfd
);
2831 /* Bytes per line. */
2832 const int onaline
= 16;
2837 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2840 if (! process_section_p (section
))
2843 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2846 /* Compute the address range to display. */
2847 if (start_address
== (bfd_vma
) -1
2848 || start_address
< section
->vma
)
2851 start_offset
= start_address
- section
->vma
;
2853 if (stop_address
== (bfd_vma
) -1)
2854 stop_offset
= datasize
/ opb
;
2857 if (stop_address
< section
->vma
)
2860 stop_offset
= stop_address
- section
->vma
;
2862 if (stop_offset
> datasize
/ opb
)
2863 stop_offset
= datasize
/ opb
;
2866 if (start_offset
>= stop_offset
)
2869 printf (_("Contents of section %s:"), section
->name
);
2870 if (display_file_offsets
)
2871 printf (_(" (Starting at file offset: 0x%lx)"),
2872 (unsigned long) (section
->filepos
+ start_offset
));
2875 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2877 non_fatal (_("Reading section %s failed because: %s"),
2878 section
->name
, bfd_errmsg (bfd_get_error ()));
2884 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2885 if (strlen (buf
) >= sizeof (buf
))
2889 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2891 count
= strlen (buf
) - count
;
2895 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2896 if (strlen (buf
) >= sizeof (buf
))
2900 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2902 count
= strlen (buf
) - count
;
2906 for (addr_offset
= start_offset
;
2907 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2911 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2912 count
= strlen (buf
);
2913 if ((size_t) count
>= sizeof (buf
))
2917 while (count
< width
)
2922 fputs (buf
+ count
- width
, stdout
);
2925 for (j
= addr_offset
* opb
;
2926 j
< addr_offset
* opb
+ onaline
; j
++)
2928 if (j
< stop_offset
* opb
)
2929 printf ("%02x", (unsigned) (data
[j
]));
2937 for (j
= addr_offset
* opb
;
2938 j
< addr_offset
* opb
+ onaline
; j
++)
2940 if (j
>= stop_offset
* opb
)
2943 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2950 /* Actually display the various requested regions. */
2953 dump_data (bfd
*abfd
)
2955 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2958 /* Should perhaps share code and display with nm? */
2961 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2970 max_count
= dynsymcount
;
2971 printf ("DYNAMIC SYMBOL TABLE:\n");
2976 max_count
= symcount
;
2977 printf ("SYMBOL TABLE:\n");
2981 printf (_("no symbols\n"));
2983 for (count
= 0; count
< max_count
; count
++)
2987 if (*current
== NULL
)
2988 printf (_("no information for symbol number %ld\n"), count
);
2990 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2991 printf (_("could not determine the type of symbol number %ld\n"),
2994 else if (process_section_p ((* current
)->section
)
2995 && (dump_special_syms
2996 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2998 const char *name
= (*current
)->name
;
3000 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3004 /* If we want to demangle the name, we demangle it
3005 here, and temporarily clobber it while calling
3006 bfd_print_symbol. FIXME: This is a gross hack. */
3007 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
3009 (*current
)->name
= alloc
;
3010 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3011 bfd_print_symbol_all
);
3014 (*current
)->name
= name
;
3019 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3020 bfd_print_symbol_all
);
3030 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3033 char *last_filename
, *last_functionname
;
3034 unsigned int last_line
;
3035 unsigned int last_discriminator
;
3037 /* Get column headers lined up reasonably. */
3045 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3046 width
= strlen (buf
) - 7;
3048 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3051 last_filename
= NULL
;
3052 last_functionname
= NULL
;
3054 last_discriminator
= 0;
3056 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3059 const char *filename
, *functionname
;
3060 unsigned int linenumber
;
3061 unsigned int discriminator
;
3062 const char *sym_name
;
3063 const char *section_name
;
3064 bfd_vma addend2
= 0;
3066 if (start_address
!= (bfd_vma
) -1
3067 && q
->address
< start_address
)
3069 if (stop_address
!= (bfd_vma
) -1
3070 && q
->address
> stop_address
)
3073 if (with_line_numbers
3075 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3076 &filename
, &functionname
,
3077 &linenumber
, &discriminator
))
3079 if (functionname
!= NULL
3080 && (last_functionname
== NULL
3081 || strcmp (functionname
, last_functionname
) != 0))
3083 printf ("%s():\n", functionname
);
3084 if (last_functionname
!= NULL
)
3085 free (last_functionname
);
3086 last_functionname
= xstrdup (functionname
);
3090 && (linenumber
!= last_line
3091 || (filename
!= NULL
3092 && last_filename
!= NULL
3093 && filename_cmp (filename
, last_filename
) != 0)
3094 || (discriminator
!= last_discriminator
)))
3096 if (discriminator
> 0)
3097 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
3099 printf ("%s:%u (discriminator %u)\n", filename
== NULL
? "???" : filename
,
3100 linenumber
, discriminator
);
3101 last_line
= linenumber
;
3102 last_discriminator
= discriminator
;
3103 if (last_filename
!= NULL
)
3104 free (last_filename
);
3105 if (filename
== NULL
)
3106 last_filename
= NULL
;
3108 last_filename
= xstrdup (filename
);
3112 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3114 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3115 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3120 section_name
= NULL
;
3123 bfd_printf_vma (abfd
, q
->address
);
3124 if (q
->howto
== NULL
)
3125 printf (" *unknown* ");
3126 else if (q
->howto
->name
)
3128 const char *name
= q
->howto
->name
;
3130 /* R_SPARC_OLO10 relocations contain two addends.
3131 But because 'arelent' lacks enough storage to
3132 store them both, the 64-bit ELF Sparc backend
3133 records this as two relocations. One R_SPARC_LO10
3134 and one R_SPARC_13, both pointing to the same
3135 address. This is merely so that we have some
3136 place to store both addend fields.
3138 Undo this transformation, otherwise the output
3139 will be confusing. */
3140 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3141 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3143 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3145 arelent
*q2
= *(p
+ 1);
3148 && q
->address
== q2
->address
3149 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3151 name
= "R_SPARC_OLO10";
3152 addend2
= q2
->addend
;
3156 printf (" %-16s ", name
);
3159 printf (" %-16d ", q
->howto
->type
);
3163 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3167 if (section_name
== NULL
)
3168 section_name
= "*unknown*";
3169 printf ("[%s]", section_name
);
3174 bfd_signed_vma addend
= q
->addend
;
3182 bfd_printf_vma (abfd
, addend
);
3187 bfd_printf_vma (abfd
, addend2
);
3193 if (last_filename
!= NULL
)
3194 free (last_filename
);
3195 if (last_functionname
!= NULL
)
3196 free (last_functionname
);
3200 dump_relocs_in_section (bfd
*abfd
,
3202 void *dummy ATTRIBUTE_UNUSED
)
3208 if ( bfd_is_abs_section (section
)
3209 || bfd_is_und_section (section
)
3210 || bfd_is_com_section (section
)
3211 || (! process_section_p (section
))
3212 || ((section
->flags
& SEC_RELOC
) == 0))
3215 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3217 bfd_fatal (bfd_get_filename (abfd
));
3219 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
3223 printf (" (none)\n\n");
3227 relpp
= (arelent
**) xmalloc (relsize
);
3228 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3233 non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd
));
3234 bfd_fatal (_("error message was"));
3236 else if (relcount
== 0)
3237 printf (" (none)\n\n");
3241 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3248 dump_relocs (bfd
*abfd
)
3250 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3254 dump_dynamic_relocs (bfd
*abfd
)
3260 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3262 bfd_fatal (bfd_get_filename (abfd
));
3264 printf ("DYNAMIC RELOCATION RECORDS");
3267 printf (" (none)\n\n");
3270 relpp
= (arelent
**) xmalloc (relsize
);
3271 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3274 bfd_fatal (bfd_get_filename (abfd
));
3275 else if (relcount
== 0)
3276 printf (" (none)\n\n");
3280 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3287 /* Creates a table of paths, to search for source files. */
3290 add_include_path (const char *path
)
3294 include_path_count
++;
3295 include_paths
= (const char **)
3296 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3297 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3298 if (path
[1] == ':' && path
[2] == 0)
3299 path
= concat (path
, ".", (const char *) 0);
3301 include_paths
[include_path_count
- 1] = path
;
3305 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3309 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3311 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3312 section
->vma
+= adjust_section_vma
;
3314 section
->lma
+= adjust_section_vma
;
3318 /* Dump selected contents of ABFD. */
3321 dump_bfd (bfd
*abfd
)
3323 /* If we are adjusting section VMA's, change them all now. Changing
3324 the BFD information is a hack. However, we must do it, or
3325 bfd_find_nearest_line will not do the right thing. */
3326 if (adjust_section_vma
!= 0)
3328 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3329 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3332 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3333 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3336 print_arelt_descr (stdout
, abfd
, TRUE
);
3337 if (dump_file_header
)
3338 dump_bfd_header (abfd
);
3339 if (dump_private_headers
)
3340 dump_bfd_private_header (abfd
);
3341 if (dump_private_options
!= NULL
)
3342 dump_target_specific (abfd
);
3343 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3350 || dump_dwarf_section_info
)
3351 syms
= slurp_symtab (abfd
);
3353 if (dump_section_headers
)
3354 dump_headers (abfd
);
3356 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3357 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3358 dynsyms
= slurp_dynamic_symtab (abfd
);
3361 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3362 dynsymcount
, dynsyms
, &synthsyms
);
3368 dump_symbols (abfd
, FALSE
);
3369 if (dump_dynamic_symtab
)
3370 dump_symbols (abfd
, TRUE
);
3371 if (dump_dwarf_section_info
)
3373 if (dump_stab_section_info
)
3375 if (dump_reloc_info
&& ! disassemble
)
3377 if (dump_dynamic_reloc_info
&& ! disassemble
)
3378 dump_dynamic_relocs (abfd
);
3379 if (dump_section_contents
)
3382 disassemble_data (abfd
);
3388 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3389 if (dhandle
!= NULL
)
3391 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3393 dump_debugging_tags
? TRUE
: FALSE
))
3395 non_fatal (_("%s: printing debugging information failed"),
3396 bfd_get_filename (abfd
));
3400 /* PR 6483: If there was no STABS or IEEE debug
3401 info in the file, try DWARF instead. */
3402 else if (! dump_dwarf_section_info
)
3404 dwarf_select_sections_all ();
3433 display_object_bfd (bfd
*abfd
)
3437 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3443 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3445 nonfatal (bfd_get_filename (abfd
));
3446 list_matching_formats (matching
);
3451 if (bfd_get_error () != bfd_error_file_not_recognized
)
3453 nonfatal (bfd_get_filename (abfd
));
3457 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3463 nonfatal (bfd_get_filename (abfd
));
3465 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3467 list_matching_formats (matching
);
3473 display_any_bfd (bfd
*file
, int level
)
3475 /* Decompress sections unless dumping the section contents. */
3476 if (!dump_section_contents
)
3477 file
->flags
|= BFD_DECOMPRESS
;
3479 /* If the file is an archive, process all of its elements. */
3480 if (bfd_check_format (file
, bfd_archive
))
3483 bfd
*last_arfile
= NULL
;
3486 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3487 else if (level
> 100)
3489 /* Prevent corrupted files from spinning us into an
3490 infinite loop. 100 is an arbitrary heuristic. */
3491 fatal (_("Archive nesting is too deep"));
3495 printf (_("In nested archive %s:\n"), bfd_get_filename (file
));
3499 bfd_set_error (bfd_error_no_error
);
3501 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3504 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3505 nonfatal (bfd_get_filename (file
));
3509 display_any_bfd (arfile
, level
+ 1);
3511 if (last_arfile
!= NULL
)
3513 bfd_close (last_arfile
);
3514 /* PR 17512: file: ac585d01. */
3515 if (arfile
== last_arfile
)
3521 last_arfile
= arfile
;
3524 if (last_arfile
!= NULL
)
3525 bfd_close (last_arfile
);
3528 display_object_bfd (file
);
3532 display_file (char *filename
, char *target
)
3536 if (get_file_size (filename
) < 1)
3542 file
= bfd_openr (filename
, target
);
3545 nonfatal (filename
);
3549 display_any_bfd (file
, 0);
3555 main (int argc
, char **argv
)
3558 char *target
= default_target
;
3559 bfd_boolean seenflag
= FALSE
;
3561 #if defined (HAVE_SETLOCALE)
3562 #if defined (HAVE_LC_MESSAGES)
3563 setlocale (LC_MESSAGES
, "");
3565 setlocale (LC_CTYPE
, "");
3568 bindtextdomain (PACKAGE
, LOCALEDIR
);
3569 textdomain (PACKAGE
);
3571 program_name
= *argv
;
3572 xmalloc_set_program_name (program_name
);
3573 bfd_set_error_program_name (program_name
);
3575 START_PROGRESS (program_name
, 0);
3577 expandargv (&argc
, &argv
);
3580 set_default_bfd_target ();
3582 while ((c
= getopt_long (argc
, argv
,
3583 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3584 long_options
, (int *) 0))
3590 break; /* We've been given a long option. */
3595 if (disassembler_options
)
3596 /* Ignore potential memory leak for now. */
3597 disassembler_options
= concat (disassembler_options
, ",",
3598 optarg
, (const char *) NULL
);
3600 disassembler_options
= optarg
;
3606 display_file_offsets
= TRUE
;
3609 with_line_numbers
= TRUE
;
3618 enum demangling_styles style
;
3620 style
= cplus_demangle_name_to_style (optarg
);
3621 if (style
== unknown_demangling
)
3622 fatal (_("unknown demangling style `%s'"),
3625 cplus_demangle_set_style (style
);
3631 case OPTION_ADJUST_VMA
:
3632 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3634 case OPTION_START_ADDRESS
:
3635 start_address
= parse_vma (optarg
, "--start-address");
3636 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3637 fatal (_("error: the start address should be before the end address"));
3639 case OPTION_STOP_ADDRESS
:
3640 stop_address
= parse_vma (optarg
, "--stop-address");
3641 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3642 fatal (_("error: the stop address should be after the start address"));
3646 prefix_length
= strlen (prefix
);
3647 /* Remove an unnecessary trailing '/' */
3648 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3651 case OPTION_PREFIX_STRIP
:
3652 prefix_strip
= atoi (optarg
);
3653 if (prefix_strip
< 0)
3654 fatal (_("error: prefix strip must be non-negative"));
3656 case OPTION_INSN_WIDTH
:
3657 insn_width
= strtoul (optarg
, NULL
, 0);
3658 if (insn_width
<= 0)
3659 fatal (_("error: instruction width must be positive"));
3662 if (strcmp (optarg
, "B") == 0)
3663 endian
= BFD_ENDIAN_BIG
;
3664 else if (strcmp (optarg
, "L") == 0)
3665 endian
= BFD_ENDIAN_LITTLE
;
3668 nonfatal (_("unrecognized -E option"));
3673 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3674 endian
= BFD_ENDIAN_BIG
;
3675 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3676 endian
= BFD_ENDIAN_LITTLE
;
3679 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3686 dump_file_header
= TRUE
;
3690 formats_info
= TRUE
;
3694 add_include_path (optarg
);
3697 dump_private_headers
= TRUE
;
3701 dump_private_options
= optarg
;
3705 dump_private_headers
= TRUE
;
3707 dump_reloc_info
= TRUE
;
3708 dump_file_header
= TRUE
;
3709 dump_ar_hdrs
= TRUE
;
3710 dump_section_headers
= TRUE
;
3718 dump_dynamic_symtab
= TRUE
;
3726 disassemble_zeroes
= TRUE
;
3730 disassemble_all
= TRUE
;
3735 with_source_code
= TRUE
;
3744 dump_debugging_tags
= 1;
3749 dump_dwarf_section_info
= TRUE
;
3752 dwarf_select_sections_by_letters (optarg
);
3754 dwarf_select_sections_all ();
3757 dump_dwarf_section_info
= TRUE
;
3760 dwarf_select_sections_by_names (optarg
);
3762 dwarf_select_sections_all ();
3764 case OPTION_DWARF_DEPTH
:
3767 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3770 case OPTION_DWARF_START
:
3773 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3774 suppress_bfd_header
= 1;
3777 case OPTION_DWARF_CHECK
:
3781 dump_stab_section_info
= TRUE
;
3785 dump_section_contents
= TRUE
;
3789 dump_reloc_info
= TRUE
;
3793 dump_dynamic_reloc_info
= TRUE
;
3797 dump_ar_hdrs
= TRUE
;
3801 dump_section_headers
= TRUE
;
3806 show_version
= TRUE
;
3812 /* No need to set seenflag or to break - usage() does not return. */
3819 print_version ("objdump");
3825 exit_status
= display_info ();
3829 display_file ("a.out", target
);
3831 for (; optind
< argc
;)
3832 display_file (argv
[optind
++], target
);
3837 END_PROGRESS (program_name
);