1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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. */
57 #include "safe-ctype.h"
59 #include "libiberty.h"
64 /* Internal headers for the ELF .stab-dump code - sorry. */
65 #define BYTES_IN_WORD 32
66 #include "aout/aout64.h"
68 #ifdef NEED_DECLARATION_FPRINTF
69 /* This is needed by init_disassemble_info(). */
70 extern int fprintf (FILE *, const char *, ...);
74 static int exit_status
= 0;
76 static char *default_target
= NULL
; /* Default at runtime. */
78 /* The following variables are set based on arguments passed on the
80 static int show_version
= 0; /* Show the version number. */
81 static int dump_section_contents
; /* -s */
82 static int dump_section_headers
; /* -h */
83 static bfd_boolean dump_file_header
; /* -f */
84 static int dump_symtab
; /* -t */
85 static int dump_dynamic_symtab
; /* -T */
86 static int dump_reloc_info
; /* -r */
87 static int dump_dynamic_reloc_info
; /* -R */
88 static int dump_ar_hdrs
; /* -a */
89 static int dump_private_headers
; /* -p */
90 static int prefix_addresses
; /* --prefix-addresses */
91 static int with_line_numbers
; /* -l */
92 static bfd_boolean with_source_code
; /* -S */
93 static int show_raw_insn
; /* --show-raw-insn */
94 static int dump_stab_section_info
; /* --stabs */
95 static int do_demangle
; /* -C, --demangle */
96 static bfd_boolean disassemble
; /* -d */
97 static bfd_boolean disassemble_all
; /* -D */
98 static int disassemble_zeroes
; /* --disassemble-zeroes */
99 static bfd_boolean formats_info
; /* -i */
100 static int wide_output
; /* -w */
101 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
102 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
103 static int dump_debugging
; /* --debugging */
104 static int dump_debugging_tags
; /* --debugging-tags */
105 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
106 static int file_start_context
= 0; /* --file-start-context */
108 /* Pointer to an array of section names provided by
109 one or more "-j secname" command line options. */
111 /* The total number of slots in the only[] array. */
112 static size_t only_size
= 0;
113 /* The number of occupied slots in the only[] array. */
114 static size_t only_used
= 0;
116 /* Variables for handling include file path table. */
117 static const char **include_paths
;
118 static int include_path_count
;
120 /* Extra info to pass to the section disassembler and address printing
122 struct objdump_disasm_info
126 bfd_boolean require_sec
;
127 arelent
** dynrelbuf
;
129 disassembler_ftype disassemble_fn
;
132 /* Architecture to disassemble for, or default if NULL. */
133 static char *machine
= NULL
;
135 /* Target specific options to the disassembler. */
136 static char *disassembler_options
= NULL
;
138 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
139 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
141 /* The symbol table. */
142 static asymbol
**syms
;
144 /* Number of symbols in `syms'. */
145 static long symcount
= 0;
147 /* The sorted symbol table. */
148 static asymbol
**sorted_syms
;
150 /* Number of symbols in `sorted_syms'. */
151 static long sorted_symcount
= 0;
153 /* The dynamic symbol table. */
154 static asymbol
**dynsyms
;
156 /* Number of symbols in `dynsyms'. */
157 static long dynsymcount
= 0;
159 static bfd_byte
*stabs
;
160 static bfd_size_type stab_size
;
163 static bfd_size_type stabstr_size
;
166 usage (FILE *stream
, int status
)
168 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
169 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
170 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
171 fprintf (stream
, _("\
172 -a, --archive-headers Display archive header information\n\
173 -f, --file-headers Display the contents of the overall file header\n\
174 -p, --private-headers Display object format specific file header contents\n\
175 -h, --[section-]headers Display the contents of the section headers\n\
176 -x, --all-headers Display the contents of all headers\n\
177 -d, --disassemble Display assembler contents of executable sections\n\
178 -D, --disassemble-all Display assembler contents of all sections\n\
179 -S, --source Intermix source code with disassembly\n\
180 -s, --full-contents Display the full contents of all sections requested\n\
181 -g, --debugging Display debug information in object file\n\
182 -e, --debugging-tags Display debug information using ctags style\n\
183 -G, --stabs Display (in raw form) any STABS info in the file\n\
184 -t, --syms Display the contents of the symbol table(s)\n\
185 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
186 -r, --reloc Display the relocation entries in the file\n\
187 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
188 -v, --version Display this program's version number\n\
189 -i, --info List object formats and architectures supported\n\
190 -H, --help Display this information\n\
194 fprintf (stream
, _("\n The following switches are optional:\n"));
195 fprintf (stream
, _("\
196 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
197 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
198 -j, --section=NAME Only display information for section NAME\n\
199 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
200 -EB --endian=big Assume big endian format when disassembling\n\
201 -EL --endian=little Assume little endian format when disassembling\n\
202 --file-start-context Include context from start of file (with -S)\n\
203 -I, --include=DIR Add DIR to search list for source files\n\
204 -l, --line-numbers Include line numbers and filenames in output\n\
205 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
206 The STYLE, if specified, can be `auto', `gnu',\n\
207 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
209 -w, --wide Format output for more than 80 columns\n\
210 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
211 --start-address=ADDR Only process data whose address is >= ADDR\n\
212 --stop-address=ADDR Only process data whose address is <= ADDR\n\
213 --prefix-addresses Print complete address alongside disassembly\n\
214 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
215 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
217 list_supported_targets (program_name
, stream
);
218 list_supported_architectures (program_name
, stream
);
220 disassembler_usage (stream
);
223 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
227 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
231 OPTION_START_ADDRESS
,
236 static struct option long_options
[]=
238 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
239 {"all-headers", no_argument
, NULL
, 'x'},
240 {"private-headers", no_argument
, NULL
, 'p'},
241 {"architecture", required_argument
, NULL
, 'm'},
242 {"archive-headers", no_argument
, NULL
, 'a'},
243 {"debugging", no_argument
, NULL
, 'g'},
244 {"debugging-tags", no_argument
, NULL
, 'e'},
245 {"demangle", optional_argument
, NULL
, 'C'},
246 {"disassemble", no_argument
, NULL
, 'd'},
247 {"disassemble-all", no_argument
, NULL
, 'D'},
248 {"disassembler-options", required_argument
, NULL
, 'M'},
249 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
250 {"dynamic-reloc", no_argument
, NULL
, 'R'},
251 {"dynamic-syms", no_argument
, NULL
, 'T'},
252 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
253 {"file-headers", no_argument
, NULL
, 'f'},
254 {"file-start-context", no_argument
, &file_start_context
, 1},
255 {"full-contents", no_argument
, NULL
, 's'},
256 {"headers", no_argument
, NULL
, 'h'},
257 {"help", no_argument
, NULL
, 'H'},
258 {"info", no_argument
, NULL
, 'i'},
259 {"line-numbers", no_argument
, NULL
, 'l'},
260 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
261 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
262 {"reloc", no_argument
, NULL
, 'r'},
263 {"section", required_argument
, NULL
, 'j'},
264 {"section-headers", no_argument
, NULL
, 'h'},
265 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
266 {"source", no_argument
, NULL
, 'S'},
267 {"include", required_argument
, NULL
, 'I'},
268 {"stabs", no_argument
, NULL
, 'G'},
269 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
270 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
271 {"syms", no_argument
, NULL
, 't'},
272 {"target", required_argument
, NULL
, 'b'},
273 {"version", no_argument
, NULL
, 'V'},
274 {"wide", no_argument
, NULL
, 'w'},
275 {0, no_argument
, 0, 0}
279 nonfatal (const char *msg
)
286 dump_section_header (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
,
287 void *ignored ATTRIBUTE_UNUSED
)
290 unsigned int opb
= bfd_octets_per_byte (abfd
);
292 printf ("%3d %-13s %08lx ", section
->index
,
293 bfd_get_section_name (abfd
, section
),
294 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
295 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
297 bfd_printf_vma (abfd
, section
->lma
);
298 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
299 bfd_get_section_alignment (abfd
, section
));
305 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
307 PF (SEC_HAS_CONTENTS
, "CONTENTS");
308 PF (SEC_ALLOC
, "ALLOC");
309 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
310 PF (SEC_LOAD
, "LOAD");
311 PF (SEC_RELOC
, "RELOC");
312 PF (SEC_READONLY
, "READONLY");
313 PF (SEC_CODE
, "CODE");
314 PF (SEC_DATA
, "DATA");
316 PF (SEC_DEBUGGING
, "DEBUGGING");
317 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
318 PF (SEC_EXCLUDE
, "EXCLUDE");
319 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
320 PF (SEC_BLOCK
, "BLOCK");
321 PF (SEC_CLINK
, "CLINK");
322 PF (SEC_SMALL_DATA
, "SMALL_DATA");
323 PF (SEC_SHARED
, "SHARED");
324 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
325 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
327 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
331 switch (section
->flags
& SEC_LINK_DUPLICATES
)
335 case SEC_LINK_DUPLICATES_DISCARD
:
336 ls
= "LINK_ONCE_DISCARD";
338 case SEC_LINK_DUPLICATES_ONE_ONLY
:
339 ls
= "LINK_ONCE_ONE_ONLY";
341 case SEC_LINK_DUPLICATES_SAME_SIZE
:
342 ls
= "LINK_ONCE_SAME_SIZE";
344 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
345 ls
= "LINK_ONCE_SAME_CONTENTS";
348 printf ("%s%s", comma
, ls
);
350 if (section
->comdat
!= NULL
)
351 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
352 section
->comdat
->symbol
);
362 dump_headers (bfd
*abfd
)
364 printf (_("Sections:\n"));
367 printf (_("Idx Name Size VMA LMA File off Algn"));
369 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
370 if (bfd_get_arch_size (abfd
) == 32)
371 printf (_("Idx Name Size VMA LMA File off Algn"));
373 printf (_("Idx Name Size VMA LMA File off Algn"));
377 printf (_(" Flags"));
378 if (abfd
->flags
& HAS_LOAD_PAGE
)
382 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
386 slurp_symtab (bfd
*abfd
)
391 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
397 storage
= bfd_get_symtab_upper_bound (abfd
);
399 bfd_fatal (bfd_get_filename (abfd
));
401 sy
= xmalloc (storage
);
403 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
405 bfd_fatal (bfd_get_filename (abfd
));
409 /* Read in the dynamic symbols. */
412 slurp_dynamic_symtab (bfd
*abfd
)
417 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
420 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
422 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
427 bfd_fatal (bfd_get_filename (abfd
));
430 sy
= xmalloc (storage
);
432 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
434 bfd_fatal (bfd_get_filename (abfd
));
438 /* Filter out (in place) symbols that are useless for disassembly.
439 COUNT is the number of elements in SYMBOLS.
440 Return the number of useful symbols. */
443 remove_useless_symbols (asymbol
**symbols
, long count
)
445 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
449 asymbol
*sym
= *in_ptr
++;
451 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
453 if (sym
->flags
& (BSF_DEBUGGING
))
455 if (bfd_is_und_section (sym
->section
)
456 || bfd_is_com_section (sym
->section
))
461 return out_ptr
- symbols
;
464 /* Sort symbols into value order. */
467 compare_symbols (const void *ap
, const void *bp
)
469 const asymbol
*a
= * (const asymbol
**) ap
;
470 const asymbol
*b
= * (const asymbol
**) bp
;
480 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
482 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
485 if (a
->section
> b
->section
)
487 else if (a
->section
< b
->section
)
490 an
= bfd_asymbol_name (a
);
491 bn
= bfd_asymbol_name (b
);
495 /* The symbols gnu_compiled and gcc2_compiled convey no real
496 information, so put them after other symbols with the same value. */
497 af
= (strstr (an
, "gnu_compiled") != NULL
498 || strstr (an
, "gcc2_compiled") != NULL
);
499 bf
= (strstr (bn
, "gnu_compiled") != NULL
500 || strstr (bn
, "gcc2_compiled") != NULL
);
507 /* We use a heuristic for the file name, to try to sort it after
508 more useful symbols. It may not work on non Unix systems, but it
509 doesn't really matter; the only difference is precisely which
510 symbol names get printed. */
512 #define file_symbol(s, sn, snl) \
513 (((s)->flags & BSF_FILE) != 0 \
514 || ((sn)[(snl) - 2] == '.' \
515 && ((sn)[(snl) - 1] == 'o' \
516 || (sn)[(snl) - 1] == 'a')))
518 af
= file_symbol (a
, an
, anl
);
519 bf
= file_symbol (b
, bn
, bnl
);
526 /* Try to sort global symbols before local symbols before function
527 symbols before debugging symbols. */
532 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
534 if ((aflags
& BSF_DEBUGGING
) != 0)
539 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
541 if ((aflags
& BSF_FUNCTION
) != 0)
546 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
548 if ((aflags
& BSF_LOCAL
) != 0)
553 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
555 if ((aflags
& BSF_GLOBAL
) != 0)
561 /* Symbols that start with '.' might be section names, so sort them
562 after symbols that don't start with '.'. */
563 if (an
[0] == '.' && bn
[0] != '.')
565 if (an
[0] != '.' && bn
[0] == '.')
568 /* Finally, if we can't distinguish them in any other way, try to
569 get consistent results by sorting the symbols by name. */
570 return strcmp (an
, bn
);
573 /* Sort relocs into address order. */
576 compare_relocs (const void *ap
, const void *bp
)
578 const arelent
*a
= * (const arelent
**) ap
;
579 const arelent
*b
= * (const arelent
**) bp
;
581 if (a
->address
> b
->address
)
583 else if (a
->address
< b
->address
)
586 /* So that associated relocations tied to the same address show up
587 in the correct order, we don't do any further sorting. */
596 /* Print an address (VMA) to the output stream in INFO.
597 If SKIP_ZEROES is TRUE, omit leading zeroes. */
600 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
601 bfd_boolean skip_zeroes
)
605 struct objdump_disasm_info
*aux
;
607 aux
= (struct objdump_disasm_info
*) info
->application_data
;
608 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
613 for (p
= buf
; *p
== '0'; ++p
)
618 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
621 /* Print the name of a symbol. */
624 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
631 name
= bfd_asymbol_name (sym
);
632 if (do_demangle
&& name
[0] != '\0')
634 /* Demangle the name. */
635 alloc
= demangle (abfd
, name
);
640 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
648 /* Locate a symbol given a bfd and a section (from INFO->application_data),
649 and a VMA. If INFO->application_data->require_sec is TRUE, then always
650 require the symbol to be in the section. Returns NULL if there is no
651 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
652 of the symbol in sorted_syms. */
655 find_symbol_for_address (bfd_vma vma
,
656 struct disassemble_info
*info
,
659 /* @@ Would it speed things up to cache the last two symbols returned,
660 and maybe their address ranges? For many processors, only one memory
661 operand can be present at a time, so the 2-entry cache wouldn't be
662 constantly churned by code doing heavy memory accesses. */
664 /* Indices in `sorted_syms'. */
666 long max
= sorted_symcount
;
668 struct objdump_disasm_info
*aux
;
673 if (sorted_symcount
< 1)
676 aux
= (struct objdump_disasm_info
*) info
->application_data
;
679 opb
= bfd_octets_per_byte (abfd
);
681 /* Perform a binary search looking for the closest symbol to the
682 required value. We are searching the range (min, max]. */
683 while (min
+ 1 < max
)
687 thisplace
= (max
+ min
) / 2;
688 sym
= sorted_syms
[thisplace
];
690 if (bfd_asymbol_value (sym
) > vma
)
692 else if (bfd_asymbol_value (sym
) < vma
)
701 /* The symbol we want is now in min, the low end of the range we
702 were searching. If there are several symbols with the same
703 value, we want the first one. */
706 && (bfd_asymbol_value (sorted_syms
[thisplace
])
707 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
710 /* If the file is relocatable, and the symbol could be from this
711 section, prefer a symbol from this section over symbols from
712 others, even if the other symbol's value might be closer.
714 Note that this may be wrong for some symbol references if the
715 sections have overlapping memory ranges, but in that case there's
716 no way to tell what's desired without looking at the relocation
718 if (sorted_syms
[thisplace
]->section
!= sec
720 || ((abfd
->flags
& HAS_RELOC
) != 0
721 && vma
>= bfd_get_section_vma (abfd
, sec
)
722 && vma
< (bfd_get_section_vma (abfd
, sec
)
723 + bfd_section_size (abfd
, sec
) / opb
))))
727 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
729 if (bfd_asymbol_value (sorted_syms
[i
])
730 != bfd_asymbol_value (sorted_syms
[thisplace
]))
738 if (sorted_syms
[i
]->section
== sec
740 || sorted_syms
[i
- 1]->section
!= sec
741 || (bfd_asymbol_value (sorted_syms
[i
])
742 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
749 if (sorted_syms
[thisplace
]->section
!= sec
)
751 /* We didn't find a good symbol with a smaller value.
752 Look for one with a larger value. */
753 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
755 if (sorted_syms
[i
]->section
== sec
)
763 if (sorted_syms
[thisplace
]->section
!= sec
765 || ((abfd
->flags
& HAS_RELOC
) != 0
766 && vma
>= bfd_get_section_vma (abfd
, sec
)
767 && vma
< (bfd_get_section_vma (abfd
, sec
)
768 + bfd_section_size (abfd
, sec
)))))
769 /* There is no suitable symbol. */
773 /* Give the target a chance to reject the symbol. */
774 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
777 if (thisplace
>= sorted_symcount
778 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
785 return sorted_syms
[thisplace
];
788 /* Print an address and the offset to the nearest symbol. */
791 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
792 bfd_vma vma
, struct disassemble_info
*info
,
793 bfd_boolean skip_zeroes
)
795 objdump_print_value (vma
, info
, skip_zeroes
);
801 (*info
->fprintf_func
) (info
->stream
, " <%s",
802 bfd_get_section_name (abfd
, sec
));
803 secaddr
= bfd_get_section_vma (abfd
, sec
);
806 (*info
->fprintf_func
) (info
->stream
, "-0x");
807 objdump_print_value (secaddr
- vma
, info
, TRUE
);
809 else if (vma
> secaddr
)
811 (*info
->fprintf_func
) (info
->stream
, "+0x");
812 objdump_print_value (vma
- secaddr
, info
, TRUE
);
814 (*info
->fprintf_func
) (info
->stream
, ">");
818 (*info
->fprintf_func
) (info
->stream
, " <");
819 objdump_print_symname (abfd
, info
, sym
);
820 if (bfd_asymbol_value (sym
) > vma
)
822 (*info
->fprintf_func
) (info
->stream
, "-0x");
823 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
825 else if (vma
> bfd_asymbol_value (sym
))
827 (*info
->fprintf_func
) (info
->stream
, "+0x");
828 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
830 (*info
->fprintf_func
) (info
->stream
, ">");
834 /* Print an address (VMA), symbolically if possible.
835 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
838 objdump_print_addr (bfd_vma vma
,
839 struct disassemble_info
*info
,
840 bfd_boolean skip_zeroes
)
842 struct objdump_disasm_info
*aux
;
845 if (sorted_symcount
< 1)
847 (*info
->fprintf_func
) (info
->stream
, "0x");
848 objdump_print_value (vma
, info
, skip_zeroes
);
852 aux
= (struct objdump_disasm_info
*) info
->application_data
;
853 sym
= find_symbol_for_address (vma
, info
, NULL
);
854 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
858 /* Print VMA to INFO. This function is passed to the disassembler
862 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
864 objdump_print_addr (vma
, info
, ! prefix_addresses
);
867 /* Determine of the given address has a symbol associated with it. */
870 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
874 sym
= find_symbol_for_address (vma
, info
, NULL
);
876 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
879 /* Hold the last function name and the last line number we displayed
882 static char *prev_functionname
;
883 static unsigned int prev_line
;
885 /* We keep a list of all files that we have seen when doing a
886 disassembly with source, so that we know how much of the file to
887 display. This can be important for inlined functions. */
889 struct print_file_list
891 struct print_file_list
*next
;
892 const char *filename
;
898 static struct print_file_list
*print_files
;
900 /* The number of preceding context lines to show when we start
901 displaying a file for the first time. */
903 #define SHOW_PRECEDING_CONTEXT_LINES (5)
905 /* Tries to open MODNAME, and if successful adds a node to print_files
906 linked list and returns that node. Returns NULL on failure. */
908 static struct print_file_list
*
909 try_print_file_open (const char *origname
, const char *modname
)
911 struct print_file_list
*p
;
914 f
= fopen (modname
, "r");
918 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
920 fclose (print_files
->f
);
921 print_files
->f
= NULL
;
924 p
= xmalloc (sizeof (struct print_file_list
));
925 p
->filename
= origname
;
926 p
->modname
= modname
;
929 p
->next
= print_files
;
934 /* If the the source file, as described in the symtab, is not found
935 try to locate it in one of the paths specified with -I
936 If found, add location to print_files linked list. */
938 static struct print_file_list
*
939 update_source_path (const char *filename
)
941 struct print_file_list
*p
;
945 if (filename
== NULL
)
948 p
= try_print_file_open (filename
, filename
);
952 if (include_path_count
== 0)
955 /* Get the name of the file. */
956 fname
= strrchr (filename
, '/');
957 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
959 /* We could have a mixed forward/back slash case. */
960 char *backslash
= strrchr (filename
, '\\');
961 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
963 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
964 fname
= filename
+ 1;
972 /* If file exists under a new path, we need to add it to the list
973 so that show_line knows about it. */
974 for (i
= 0; i
< include_path_count
; i
++)
976 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
978 p
= try_print_file_open (filename
, modname
);
988 /* Skip ahead to a given line in a file, optionally printing each
992 skip_to_line (struct print_file_list
*p
, unsigned int line
,
995 while (p
->line
< line
)
999 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1009 if (strchr (buf
, '\n') != NULL
)
1014 /* Show the line number, or the source line, in a disassembly
1018 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1020 const char *filename
;
1021 const char *functionname
;
1024 if (! with_line_numbers
&& ! with_source_code
)
1027 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1028 &functionname
, &line
))
1031 if (filename
!= NULL
&& *filename
== '\0')
1033 if (functionname
!= NULL
&& *functionname
== '\0')
1034 functionname
= NULL
;
1036 if (with_line_numbers
)
1038 if (functionname
!= NULL
1039 && (prev_functionname
== NULL
1040 || strcmp (functionname
, prev_functionname
) != 0))
1041 printf ("%s():\n", functionname
);
1042 if (line
> 0 && line
!= prev_line
)
1043 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1046 if (with_source_code
1050 struct print_file_list
**pp
, *p
;
1052 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1053 if (strcmp ((*pp
)->filename
, filename
) == 0)
1059 if (p
!= print_files
)
1063 /* We have reencountered a file name which we saw
1064 earlier. This implies that either we are dumping out
1065 code from an included file, or the same file was
1066 linked in more than once. There are two common cases
1067 of an included file: inline functions in a header
1068 file, and a bison or flex skeleton file. In the
1069 former case we want to just start printing (but we
1070 back up a few lines to give context); in the latter
1071 case we want to continue from where we left off. I
1072 can't think of a good way to distinguish the cases,
1073 so I used a heuristic based on the file name. */
1074 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1078 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1085 p
->f
= fopen (p
->modname
, "r");
1089 skip_to_line (p
, l
, FALSE
);
1091 if (print_files
->f
!= NULL
)
1093 fclose (print_files
->f
);
1094 print_files
->f
= NULL
;
1100 skip_to_line (p
, line
, TRUE
);
1102 p
->next
= print_files
;
1108 p
= update_source_path (filename
);
1114 if (file_start_context
)
1117 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1120 skip_to_line (p
, l
, FALSE
);
1122 skip_to_line (p
, line
, TRUE
);
1127 if (functionname
!= NULL
1128 && (prev_functionname
== NULL
1129 || strcmp (functionname
, prev_functionname
) != 0))
1131 if (prev_functionname
!= NULL
)
1132 free (prev_functionname
);
1133 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1134 strcpy (prev_functionname
, functionname
);
1137 if (line
> 0 && line
!= prev_line
)
1141 /* Pseudo FILE object for strings. */
1149 /* sprintf to a "stream". */
1152 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1158 va_start (args
, format
);
1160 vasprintf (&buf
, format
, args
);
1165 fatal (_("Out of virtual memory"));
1170 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1174 curroff
= f
->current
- f
->buffer
;
1176 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1177 f
->current
= f
->buffer
+ curroff
;
1180 memcpy (f
->current
, buf
, n
);
1182 f
->current
[0] = '\0';
1190 /* Returns TRUE if the specified section should be dumped. */
1193 process_section_p (asection
* section
)
1200 for (i
= 0; i
< only_used
; i
++)
1201 if (strcmp (only
[i
], section
->name
) == 0)
1208 /* The number of zeroes we want to see before we start skipping them.
1209 The number is arbitrarily chosen. */
1212 #define SKIP_ZEROES (8)
1215 /* The number of zeroes to skip at the end of a section. If the
1216 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1217 SKIP_ZEROES, they will be disassembled. If there are fewer than
1218 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1219 attempt to avoid disassembling zeroes inserted by section
1222 #ifndef SKIP_ZEROES_AT_END
1223 #define SKIP_ZEROES_AT_END (3)
1226 /* Disassemble some data in memory between given values. */
1229 disassemble_bytes (struct disassemble_info
* info
,
1230 disassembler_ftype disassemble_fn
,
1233 bfd_vma start_offset
,
1234 bfd_vma stop_offset
,
1237 arelent
** relppend
)
1239 struct objdump_disasm_info
*aux
;
1241 int octets_per_line
;
1242 bfd_boolean done_dot
;
1243 int skip_addr_chars
;
1244 bfd_vma addr_offset
;
1245 int opb
= info
->octets_per_byte
;
1247 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1251 octets_per_line
= 4;
1253 octets_per_line
= 16;
1255 /* Figure out how many characters to skip at the start of an
1256 address, to make the disassembly look nicer. We discard leading
1257 zeroes in chunks of 4, ensuring that there is always a leading
1259 skip_addr_chars
= 0;
1260 if (! prefix_addresses
)
1268 + bfd_section_size (section
->owner
, section
) / opb
));
1270 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1273 skip_addr_chars
+= 4;
1278 info
->insn_info_valid
= 0;
1281 addr_offset
= start_offset
;
1282 while (addr_offset
< stop_offset
)
1286 bfd_boolean need_nl
= FALSE
;
1288 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1290 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1293 if (! disassemble_zeroes
1294 && (info
->insn_info_valid
== 0
1295 || info
->branch_delay_insns
== 0)
1296 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1297 || (z
== stop_offset
* opb
&&
1298 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1302 /* If there are more nonzero octets to follow, we only skip
1303 zeroes in multiples of 4, to try to avoid running over
1304 the start of an instruction which happens to start with
1306 if (z
!= stop_offset
* opb
)
1307 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1309 octets
= z
- addr_offset
* opb
;
1320 if (with_line_numbers
|| with_source_code
)
1321 /* The line number tables will refer to unadjusted
1322 section VMAs, so we must undo any VMA modifications
1323 when calling show_line. */
1324 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1326 if (! prefix_addresses
)
1330 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1331 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1335 printf ("%s:\t", buf
+ skip_addr_chars
);
1339 aux
->require_sec
= TRUE
;
1340 objdump_print_address (section
->vma
+ addr_offset
, info
);
1341 aux
->require_sec
= FALSE
;
1348 sfile
.buffer
= xmalloc (sfile
.size
);
1349 sfile
.current
= sfile
.buffer
;
1350 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1351 info
->stream
= (FILE *) &sfile
;
1352 info
->bytes_per_line
= 0;
1353 info
->bytes_per_chunk
= 0;
1355 #ifdef DISASSEMBLER_NEEDS_RELOCS
1356 /* FIXME: This is wrong. It tests the number of octets
1357 in the last instruction, not the current one. */
1358 if (*relppp
< relppend
1359 && (**relppp
)->address
>= rel_offset
+ addr_offset
1360 && ((**relppp
)->address
1361 < rel_offset
+ addr_offset
+ octets
/ opb
))
1362 info
->flags
= INSN_HAS_RELOC
;
1367 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1368 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1369 info
->stream
= stdout
;
1370 if (info
->bytes_per_line
!= 0)
1371 octets_per_line
= info
->bytes_per_line
;
1374 if (sfile
.current
!= sfile
.buffer
)
1375 printf ("%s\n", sfile
.buffer
);
1376 free (sfile
.buffer
);
1384 octets
= octets_per_line
;
1385 if (addr_offset
+ octets
/ opb
> stop_offset
)
1386 octets
= (stop_offset
- addr_offset
) * opb
;
1388 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1390 if (ISPRINT (data
[j
]))
1391 buf
[j
- addr_offset
* opb
] = data
[j
];
1393 buf
[j
- addr_offset
* opb
] = '.';
1395 buf
[j
- addr_offset
* opb
] = '\0';
1398 if (prefix_addresses
1400 : show_raw_insn
>= 0)
1404 /* If ! prefix_addresses and ! wide_output, we print
1405 octets_per_line octets per line. */
1407 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1408 pb
= octets_per_line
;
1410 if (info
->bytes_per_chunk
)
1411 bpc
= info
->bytes_per_chunk
;
1415 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1418 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1420 for (k
= bpc
- 1; k
>= 0; k
--)
1421 printf ("%02x", (unsigned) data
[j
+ k
]);
1426 for (k
= 0; k
< bpc
; k
++)
1427 printf ("%02x", (unsigned) data
[j
+ k
]);
1432 for (; pb
< octets_per_line
; pb
+= bpc
)
1436 for (k
= 0; k
< bpc
; k
++)
1441 /* Separate raw data from instruction by extra space. */
1452 printf ("%s", sfile
.buffer
);
1453 free (sfile
.buffer
);
1456 if (prefix_addresses
1458 : show_raw_insn
>= 0)
1466 j
= addr_offset
* opb
+ pb
;
1468 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1469 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1473 printf ("%s:\t", buf
+ skip_addr_chars
);
1475 pb
+= octets_per_line
;
1478 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1482 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1484 for (k
= bpc
- 1; k
>= 0; k
--)
1485 printf ("%02x", (unsigned) data
[j
+ k
]);
1490 for (k
= 0; k
< bpc
; k
++)
1491 printf ("%02x", (unsigned) data
[j
+ k
]);
1504 while ((*relppp
) < relppend
1505 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1507 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1518 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1521 printf (": %s\t", q
->howto
->name
);
1523 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1524 printf ("*unknown*");
1527 const char *sym_name
;
1529 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1530 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1531 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1536 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1537 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1538 if (sym_name
== NULL
|| *sym_name
== '\0')
1539 sym_name
= "*unknown*";
1540 printf ("%s", sym_name
);
1547 objdump_print_value (q
->addend
, info
, TRUE
);
1559 addr_offset
+= octets
/ opb
;
1564 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1566 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1567 struct objdump_disasm_info
* paux
;
1568 unsigned int opb
= pinfo
->octets_per_byte
;
1569 bfd_byte
* data
= NULL
;
1570 bfd_size_type datasize
= 0;
1571 arelent
** rel_pp
= NULL
;
1572 arelent
** rel_ppstart
= NULL
;
1573 arelent
** rel_ppend
;
1574 unsigned long stop_offset
;
1575 asymbol
* sym
= NULL
;
1579 unsigned long addr_offset
;
1581 /* Sections that do not contain machine
1582 code are not normally disassembled. */
1583 if (! disassemble_all
1585 && (section
->flags
& SEC_CODE
) == 0)
1588 if (! process_section_p (section
))
1591 datasize
= bfd_get_section_size_before_reloc (section
);
1595 /* Decide which set of relocs to use. Load them if necessary. */
1596 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1597 if (paux
->dynrelbuf
)
1599 rel_pp
= paux
->dynrelbuf
;
1600 rel_count
= paux
->dynrelcount
;
1601 /* Dynamic reloc addresses are absolute, non-dynamic are section
1602 relative. REL_OFFSET specifies the reloc address corresponding
1603 to the start of this section. */
1604 rel_offset
= section
->vma
;
1612 if ((section
->flags
& SEC_RELOC
) != 0
1613 #ifndef DISASSEMBLER_NEEDS_RELOCS
1620 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1622 bfd_fatal (bfd_get_filename (abfd
));
1626 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1627 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1629 bfd_fatal (bfd_get_filename (abfd
));
1631 /* Sort the relocs by address. */
1632 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1637 rel_ppend
= rel_pp
+ rel_count
;
1639 data
= xmalloc (datasize
);
1641 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1643 paux
->sec
= section
;
1644 pinfo
->buffer
= data
;
1645 pinfo
->buffer_vma
= section
->vma
;
1646 pinfo
->buffer_length
= datasize
;
1647 pinfo
->section
= section
;
1649 if (start_address
== (bfd_vma
) -1
1650 || start_address
< pinfo
->buffer_vma
)
1653 addr_offset
= start_address
- pinfo
->buffer_vma
;
1655 if (stop_address
== (bfd_vma
) -1)
1656 stop_offset
= datasize
/ opb
;
1659 if (stop_address
< pinfo
->buffer_vma
)
1662 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1663 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1664 stop_offset
= pinfo
->buffer_length
/ opb
;
1667 /* Skip over the relocs belonging to addresses below the
1669 while (rel_pp
< rel_ppend
1670 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1673 printf (_("Disassembly of section %s:\n"), section
->name
);
1675 /* Find the nearest symbol forwards from our current position. */
1676 paux
->require_sec
= TRUE
;
1677 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1678 paux
->require_sec
= FALSE
;
1680 /* Disassemble a block of instructions up to the address associated with
1681 the symbol we have just found. Then print the symbol and find the
1682 next symbol on. Repeat until we have disassembled the entire section
1683 or we have reached the end of the address range we are interested in. */
1684 while (addr_offset
< stop_offset
)
1688 unsigned long nextstop_offset
;
1691 addr
= section
->vma
+ addr_offset
;
1693 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1698 (x
< sorted_symcount
1699 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1703 pinfo
->symbols
= sorted_syms
+ place
;
1704 pinfo
->num_symbols
= x
- place
;
1708 pinfo
->symbols
= NULL
;
1709 pinfo
->num_symbols
= 0;
1712 if (! prefix_addresses
)
1714 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1715 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1717 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1720 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1722 else if (sym
== NULL
)
1726 #define is_valid_next_sym(SYM) \
1727 ((SYM)->section == section \
1728 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1729 && pinfo->symbol_is_valid (SYM, pinfo))
1731 /* Search forward for the next appropriate symbol in
1732 SECTION. Note that all the symbols are sorted
1733 together into one big array, and that some sections
1734 may have overlapping addresses. */
1735 while (place
< sorted_symcount
1736 && ! is_valid_next_sym (sorted_syms
[place
]))
1739 if (place
>= sorted_symcount
)
1742 nextsym
= sorted_syms
[place
];
1745 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1746 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1747 else if (nextsym
== NULL
)
1748 nextstop_offset
= stop_offset
;
1750 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1752 if (nextstop_offset
> stop_offset
)
1753 nextstop_offset
= stop_offset
;
1755 /* If a symbol is explicitly marked as being an object
1756 rather than a function, just dump the bytes without
1757 disassembling them. */
1760 || bfd_asymbol_value (sym
) > addr
1761 || ((sym
->flags
& BSF_OBJECT
) == 0
1762 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1764 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1766 || (sym
->flags
& BSF_FUNCTION
) != 0)
1771 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1772 addr_offset
, nextstop_offset
,
1773 rel_offset
, &rel_pp
, rel_ppend
);
1775 addr_offset
= nextstop_offset
;
1781 if (rel_ppstart
!= NULL
)
1785 /* Disassemble the contents of an object file. */
1788 disassemble_data (bfd
*abfd
)
1790 struct disassemble_info disasm_info
;
1791 struct objdump_disasm_info aux
;
1794 prev_functionname
= NULL
;
1797 /* We make a copy of syms to sort. We don't want to sort syms
1798 because that will screw up the relocs. */
1799 sorted_syms
= xmalloc (symcount
* sizeof (asymbol
*));
1800 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1802 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1804 /* Sort the symbols into section and symbol order. */
1805 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1807 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1809 disasm_info
.application_data
= (void *) &aux
;
1811 aux
.require_sec
= FALSE
;
1812 aux
.dynrelbuf
= NULL
;
1813 aux
.dynrelcount
= 0;
1815 disasm_info
.print_address_func
= objdump_print_address
;
1816 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1818 if (machine
!= NULL
)
1820 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1823 fatal (_("Can't use supplied machine %s"), machine
);
1825 abfd
->arch_info
= info
;
1828 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1830 struct bfd_target
*xvec
;
1832 xvec
= xmalloc (sizeof (struct bfd_target
));
1833 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1834 xvec
->byteorder
= endian
;
1838 /* Use libopcodes to locate a suitable disassembler. */
1839 aux
.disassemble_fn
= disassembler (abfd
);
1840 if (!aux
.disassemble_fn
)
1842 non_fatal (_("Can't disassemble for architecture %s\n"),
1843 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1848 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1849 disasm_info
.arch
= bfd_get_arch (abfd
);
1850 disasm_info
.mach
= bfd_get_mach (abfd
);
1851 disasm_info
.disassembler_options
= disassembler_options
;
1852 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1854 if (bfd_big_endian (abfd
))
1855 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1856 else if (bfd_little_endian (abfd
))
1857 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1859 /* ??? Aborting here seems too drastic. We could default to big or little
1861 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1863 /* Allow the target to customize the info structure. */
1864 disassemble_init_for_target (& disasm_info
);
1866 /* Pre-load the dynamic relocs if we are going
1867 to be dumping them along with the disassembly. */
1868 if (dump_dynamic_reloc_info
)
1870 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1873 bfd_fatal (bfd_get_filename (abfd
));
1877 aux
.dynrelbuf
= xmalloc (relsize
);
1878 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1881 if (aux
.dynrelcount
< 0)
1882 bfd_fatal (bfd_get_filename (abfd
));
1884 /* Sort the relocs by address. */
1885 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1890 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1892 if (aux
.dynrelbuf
!= NULL
)
1893 free (aux
.dynrelbuf
);
1897 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1898 it. Return NULL on failure. */
1901 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
1907 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
1908 if (stabsect
== NULL
)
1910 printf (_("No %s section present\n\n"), sect_name
);
1914 size
= bfd_section_size (abfd
, stabsect
);
1915 contents
= xmalloc (size
);
1917 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
1919 non_fatal (_("Reading %s section of %s failed: %s"),
1920 sect_name
, bfd_get_filename (abfd
),
1921 bfd_errmsg (bfd_get_error ()));
1932 /* Stabs entries use a 12 byte format:
1933 4 byte string table index
1935 1 byte stab other field
1936 2 byte stab desc field
1938 FIXME: This will have to change for a 64 bit object format. */
1940 #define STRDXOFF (0)
1942 #define OTHEROFF (5)
1945 #define STABSIZE (12)
1947 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1948 using string table section STRSECT_NAME (in `strtab'). */
1951 print_section_stabs (bfd
*abfd
,
1952 const char *stabsect_name
,
1953 unsigned *string_offset_ptr
)
1956 unsigned file_string_table_offset
= 0;
1957 unsigned next_file_string_table_offset
= *string_offset_ptr
;
1958 bfd_byte
*stabp
, *stabs_end
;
1961 stabs_end
= stabp
+ stab_size
;
1963 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1964 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1966 /* Loop through all symbols and print them.
1968 We start the index at -1 because there is a dummy symbol on
1969 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1970 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1974 unsigned char type
, other
;
1975 unsigned short desc
;
1978 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1979 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1980 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1981 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1982 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1984 printf ("\n%-6d ", i
);
1985 /* Either print the stab name, or, if unnamed, print its number
1986 again (makes consistent formatting for tools like awk). */
1987 name
= bfd_get_stab_name (type
);
1989 printf ("%-6s", name
);
1990 else if (type
== N_UNDF
)
1993 printf ("%-6d", type
);
1994 printf (" %-6d %-6d ", other
, desc
);
1995 bfd_printf_vma (abfd
, value
);
1996 printf (" %-6lu", strx
);
1998 /* Symbols with type == 0 (N_UNDF) specify the length of the
1999 string table associated with this file. We use that info
2000 to know how to relocate the *next* file's string table indices. */
2003 file_string_table_offset
= next_file_string_table_offset
;
2004 next_file_string_table_offset
+= value
;
2008 /* Using the (possibly updated) string table offset, print the
2009 string (if any) associated with this symbol. */
2010 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2011 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2017 *string_offset_ptr
= next_file_string_table_offset
;
2022 const char * section_name
;
2023 const char * string_section_name
;
2024 unsigned string_offset
;
2029 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2032 stab_section_names
* sought
= (stab_section_names
*) names
;
2034 /* Check for section names for which stabsect_name is a prefix, to
2035 handle .stab.N, etc. */
2036 len
= strlen (sought
->section_name
);
2038 /* If the prefix matches, and the files section name ends with a
2039 nul or a digit, then we match. I.e., we want either an exact
2040 match or a section followed by a number. */
2041 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2042 && (section
->name
[len
] == 0
2043 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2046 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2051 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
);
2053 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2059 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2061 stab_section_names s
;
2063 s
.section_name
= stabsect_name
;
2064 s
.string_section_name
= strsect_name
;
2065 s
.string_offset
= 0;
2067 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2073 /* Dump the any sections containing stabs debugging information. */
2076 dump_stabs (bfd
*abfd
)
2078 dump_stabs_section (abfd
, ".stab", ".stabstr");
2079 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2080 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2081 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2085 dump_bfd_header (bfd
*abfd
)
2089 printf (_("architecture: %s, "),
2090 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2091 bfd_get_mach (abfd
)));
2092 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2094 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2095 PF (HAS_RELOC
, "HAS_RELOC");
2096 PF (EXEC_P
, "EXEC_P");
2097 PF (HAS_LINENO
, "HAS_LINENO");
2098 PF (HAS_DEBUG
, "HAS_DEBUG");
2099 PF (HAS_SYMS
, "HAS_SYMS");
2100 PF (HAS_LOCALS
, "HAS_LOCALS");
2101 PF (DYNAMIC
, "DYNAMIC");
2102 PF (WP_TEXT
, "WP_TEXT");
2103 PF (D_PAGED
, "D_PAGED");
2104 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2105 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2106 printf (_("\nstart address 0x"));
2107 bfd_printf_vma (abfd
, abfd
->start_address
);
2113 dump_bfd_private_header (bfd
*abfd
)
2115 bfd_print_private_bfd_data (abfd
, stdout
);
2119 /* Display a section in hexadecimal format with associated characters.
2120 Each line prefixed by the zero padded address. */
2123 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2126 bfd_size_type datasize
;
2127 bfd_size_type addr_offset
;
2128 bfd_size_type start_offset
;
2129 bfd_size_type stop_offset
;
2130 unsigned int opb
= bfd_octets_per_byte (abfd
);
2131 /* Bytes per line. */
2132 const int onaline
= 16;
2137 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2140 if (! process_section_p (section
))
2143 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2146 printf (_("Contents of section %s:\n"), section
->name
);
2148 data
= xmalloc (datasize
);
2150 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2152 /* Compute the address range to display. */
2153 if (start_address
== (bfd_vma
) -1
2154 || start_address
< section
->vma
)
2157 start_offset
= start_address
- section
->vma
;
2159 if (stop_address
== (bfd_vma
) -1)
2160 stop_offset
= datasize
/ opb
;
2163 if (stop_address
< section
->vma
)
2166 stop_offset
= stop_address
- section
->vma
;
2168 if (stop_offset
> datasize
/ opb
)
2169 stop_offset
= datasize
/ opb
;
2174 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2175 if (strlen (buf
) >= sizeof (buf
))
2179 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2181 count
= strlen (buf
) - count
;
2185 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2186 if (strlen (buf
) >= sizeof (buf
))
2190 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2192 count
= strlen (buf
) - count
;
2196 for (addr_offset
= start_offset
;
2197 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2201 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2202 count
= strlen (buf
);
2203 if ((size_t) count
>= sizeof (buf
))
2207 while (count
< width
)
2212 fputs (buf
+ count
- width
, stdout
);
2215 for (j
= addr_offset
* opb
;
2216 j
< addr_offset
* opb
+ onaline
; j
++)
2218 if (j
< stop_offset
* opb
)
2219 printf ("%02x", (unsigned) (data
[j
]));
2227 for (j
= addr_offset
* opb
;
2228 j
< addr_offset
* opb
+ onaline
; j
++)
2230 if (j
>= stop_offset
* opb
)
2233 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2240 /* Actually display the various requested regions. */
2243 dump_data (bfd
*abfd
)
2245 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2248 /* Should perhaps share code and display with nm? */
2251 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2261 printf ("DYNAMIC SYMBOL TABLE:\n");
2267 printf ("SYMBOL TABLE:\n");
2271 printf (_("no symbols\n"));
2273 for (count
= 0; count
< max
; count
++)
2277 if (*current
== NULL
)
2278 printf (_("no information for the %ld'th symbol"), count
);
2280 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2281 printf (_("could not determine the type of the %ld'th symbol"),
2286 const char *name
= (*current
)->name
;
2288 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2292 /* If we want to demangle the name, we demangle it
2293 here, and temporarily clobber it while calling
2294 bfd_print_symbol. FIXME: This is a gross hack. */
2295 alloc
= demangle (cur_bfd
, name
);
2296 (*current
)->name
= alloc
;
2297 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2298 bfd_print_symbol_all
);
2299 (*current
)->name
= name
;
2303 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2304 bfd_print_symbol_all
);
2314 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2317 char *last_filename
, *last_functionname
;
2318 unsigned int last_line
;
2320 /* Get column headers lined up reasonably. */
2328 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2329 width
= strlen (buf
) - 7;
2331 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2334 last_filename
= NULL
;
2335 last_functionname
= NULL
;
2338 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2341 const char *filename
, *functionname
;
2343 const char *sym_name
;
2344 const char *section_name
;
2346 if (start_address
!= (bfd_vma
) -1
2347 && q
->address
< start_address
)
2349 if (stop_address
!= (bfd_vma
) -1
2350 && q
->address
> stop_address
)
2353 if (with_line_numbers
2355 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2356 &filename
, &functionname
, &line
))
2358 if (functionname
!= NULL
2359 && (last_functionname
== NULL
2360 || strcmp (functionname
, last_functionname
) != 0))
2362 printf ("%s():\n", functionname
);
2363 if (last_functionname
!= NULL
)
2364 free (last_functionname
);
2365 last_functionname
= xstrdup (functionname
);
2369 && (line
!= last_line
2370 || (filename
!= NULL
2371 && last_filename
!= NULL
2372 && strcmp (filename
, last_filename
) != 0)))
2374 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2376 if (last_filename
!= NULL
)
2377 free (last_filename
);
2378 if (filename
== NULL
)
2379 last_filename
= NULL
;
2381 last_filename
= xstrdup (filename
);
2385 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2387 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2388 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2393 section_name
= NULL
;
2398 bfd_printf_vma (abfd
, q
->address
);
2400 printf (" %-16s ", q
->howto
->name
);
2402 printf (" %-16d ", q
->howto
->type
);
2403 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2407 if (section_name
== NULL
)
2408 section_name
= "*unknown*";
2409 bfd_printf_vma (abfd
, q
->address
);
2410 printf (" %-16s [%s]",
2418 bfd_printf_vma (abfd
, q
->addend
);
2426 dump_relocs_in_section (bfd
*abfd
,
2428 void *dummy ATTRIBUTE_UNUSED
)
2434 if ( bfd_is_abs_section (section
)
2435 || bfd_is_und_section (section
)
2436 || bfd_is_com_section (section
)
2437 || (! process_section_p (section
))
2438 || ((section
->flags
& SEC_RELOC
) == 0))
2441 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2443 bfd_fatal (bfd_get_filename (abfd
));
2445 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2449 printf (" (none)\n\n");
2453 relpp
= xmalloc (relsize
);
2454 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2457 bfd_fatal (bfd_get_filename (abfd
));
2458 else if (relcount
== 0)
2459 printf (" (none)\n\n");
2463 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2470 dump_relocs (bfd
*abfd
)
2472 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2476 dump_dynamic_relocs (bfd
*abfd
)
2482 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2484 bfd_fatal (bfd_get_filename (abfd
));
2486 printf ("DYNAMIC RELOCATION RECORDS");
2489 printf (" (none)\n\n");
2492 relpp
= xmalloc (relsize
);
2493 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2496 bfd_fatal (bfd_get_filename (abfd
));
2497 else if (relcount
== 0)
2498 printf (" (none)\n\n");
2502 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2509 /* Creates a table of paths, to search for source files. */
2512 add_include_path (const char *path
)
2516 include_path_count
++;
2517 include_paths
= xrealloc (include_paths
,
2518 include_path_count
* sizeof (*include_paths
));
2519 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2520 if (path
[1] == ':' && path
[2] == 0)
2521 path
= concat (path
, ".", (const char *) 0);
2523 include_paths
[include_path_count
- 1] = path
;
2527 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2529 void *dummy ATTRIBUTE_UNUSED
)
2531 section
->vma
+= adjust_section_vma
;
2532 section
->lma
+= adjust_section_vma
;
2535 /* Dump selected contents of ABFD. */
2538 dump_bfd (bfd
*abfd
)
2540 /* If we are adjusting section VMA's, change them all now. Changing
2541 the BFD information is a hack. However, we must do it, or
2542 bfd_find_nearest_line will not do the right thing. */
2543 if (adjust_section_vma
!= 0)
2544 bfd_map_over_sections (abfd
, adjust_addresses
, NULL
);
2546 if (! dump_debugging_tags
)
2547 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2550 print_arelt_descr (stdout
, abfd
, TRUE
);
2551 if (dump_file_header
)
2552 dump_bfd_header (abfd
);
2553 if (dump_private_headers
)
2554 dump_bfd_private_header (abfd
);
2555 if (! dump_debugging_tags
)
2557 if (dump_section_headers
)
2558 dump_headers (abfd
);
2560 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2561 syms
= slurp_symtab (abfd
);
2562 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2563 dynsyms
= slurp_dynamic_symtab (abfd
);
2566 dump_symbols (abfd
, FALSE
);
2567 if (dump_dynamic_symtab
)
2568 dump_symbols (abfd
, TRUE
);
2569 if (dump_stab_section_info
)
2571 if (dump_reloc_info
&& ! disassemble
)
2573 if (dump_dynamic_reloc_info
&& ! disassemble
)
2574 dump_dynamic_relocs (abfd
);
2575 if (dump_section_contents
)
2578 disassemble_data (abfd
);
2584 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2585 if (dhandle
!= NULL
)
2587 if (! print_debugging_info (stdout
, dhandle
, abfd
, syms
, demangle
,
2588 dump_debugging_tags
? TRUE
: FALSE
))
2590 non_fatal (_("%s: printing debugging information failed"),
2591 bfd_get_filename (abfd
));
2611 display_bfd (bfd
*abfd
)
2615 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2621 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2623 nonfatal (bfd_get_filename (abfd
));
2624 list_matching_formats (matching
);
2629 if (bfd_get_error () != bfd_error_file_not_recognized
)
2631 nonfatal (bfd_get_filename (abfd
));
2635 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2641 nonfatal (bfd_get_filename (abfd
));
2643 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2645 list_matching_formats (matching
);
2651 display_file (char *filename
, char *target
)
2656 if (get_file_size (filename
) < 1)
2659 file
= bfd_openr (filename
, target
);
2662 nonfatal (filename
);
2666 /* If the file is an archive, process all of its elements. */
2667 if (bfd_check_format (file
, bfd_archive
))
2669 bfd
*last_arfile
= NULL
;
2671 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2674 bfd_set_error (bfd_error_no_error
);
2676 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2679 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2680 nonfatal (bfd_get_filename (file
));
2684 display_bfd (arfile
);
2686 if (last_arfile
!= NULL
)
2687 bfd_close (last_arfile
);
2688 last_arfile
= arfile
;
2691 if (last_arfile
!= NULL
)
2692 bfd_close (last_arfile
);
2701 main (int argc
, char **argv
)
2704 char *target
= default_target
;
2705 bfd_boolean seenflag
= FALSE
;
2707 #if defined (HAVE_SETLOCALE)
2708 #if defined (HAVE_LC_MESSAGES)
2709 setlocale (LC_MESSAGES
, "");
2711 setlocale (LC_CTYPE
, "");
2714 bindtextdomain (PACKAGE
, LOCALEDIR
);
2715 textdomain (PACKAGE
);
2717 program_name
= *argv
;
2718 xmalloc_set_program_name (program_name
);
2720 START_PROGRESS (program_name
, 0);
2723 set_default_bfd_target ();
2725 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2726 long_options
, (int *) 0))
2732 break; /* We've been given a long option. */
2737 if (disassembler_options
)
2738 /* Ignore potential memory leak for now. */
2739 disassembler_options
= concat (disassembler_options
, ",",
2742 disassembler_options
= optarg
;
2745 if (only_used
== only_size
)
2748 only
= xrealloc (only
, only_size
* sizeof (char *));
2750 only
[only_used
++] = optarg
;
2753 with_line_numbers
= TRUE
;
2762 enum demangling_styles style
;
2764 style
= cplus_demangle_name_to_style (optarg
);
2765 if (style
== unknown_demangling
)
2766 fatal (_("unknown demangling style `%s'"),
2769 cplus_demangle_set_style (style
);
2775 case OPTION_ADJUST_VMA
:
2776 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2778 case OPTION_START_ADDRESS
:
2779 start_address
= parse_vma (optarg
, "--start-address");
2781 case OPTION_STOP_ADDRESS
:
2782 stop_address
= parse_vma (optarg
, "--stop-address");
2785 if (strcmp (optarg
, "B") == 0)
2786 endian
= BFD_ENDIAN_BIG
;
2787 else if (strcmp (optarg
, "L") == 0)
2788 endian
= BFD_ENDIAN_LITTLE
;
2791 non_fatal (_("unrecognized -E option"));
2796 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2797 endian
= BFD_ENDIAN_BIG
;
2798 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2799 endian
= BFD_ENDIAN_LITTLE
;
2802 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2808 dump_file_header
= TRUE
;
2812 formats_info
= TRUE
;
2816 add_include_path (optarg
);
2819 dump_private_headers
= TRUE
;
2823 dump_private_headers
= TRUE
;
2825 dump_reloc_info
= TRUE
;
2826 dump_file_header
= TRUE
;
2827 dump_ar_hdrs
= TRUE
;
2828 dump_section_headers
= TRUE
;
2836 dump_dynamic_symtab
= TRUE
;
2844 disassemble_zeroes
= TRUE
;
2848 disassemble_all
= TRUE
;
2853 with_source_code
= TRUE
;
2862 dump_debugging_tags
= 1;
2867 dump_stab_section_info
= TRUE
;
2871 dump_section_contents
= TRUE
;
2875 dump_reloc_info
= TRUE
;
2879 dump_dynamic_reloc_info
= TRUE
;
2883 dump_ar_hdrs
= TRUE
;
2887 dump_section_headers
= TRUE
;
2895 show_version
= TRUE
;
2905 print_version ("objdump");
2911 exit_status
= display_info ();
2915 display_file ("a.out", target
);
2917 for (; optind
< argc
;)
2918 display_file (argv
[optind
++], target
);
2921 END_PROGRESS (program_name
);