1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005
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 int dump_special_syms
= 0; /* --special-syms */
106 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
107 static int file_start_context
= 0; /* --file-start-context */
109 /* Pointer to an array of section names provided by
110 one or more "-j secname" command line options. */
112 /* The total number of slots in the only[] array. */
113 static size_t only_size
= 0;
114 /* The number of occupied slots in the only[] array. */
115 static size_t only_used
= 0;
117 /* Variables for handling include file path table. */
118 static const char **include_paths
;
119 static int include_path_count
;
121 /* Extra info to pass to the section disassembler and address printing
123 struct objdump_disasm_info
127 bfd_boolean require_sec
;
128 arelent
** dynrelbuf
;
130 disassembler_ftype disassemble_fn
;
131 #ifdef DISASSEMBLER_NEEDS_RELOCS
136 /* Architecture to disassemble for, or default if NULL. */
137 static char *machine
= NULL
;
139 /* Target specific options to the disassembler. */
140 static char *disassembler_options
= NULL
;
142 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
143 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
145 /* The symbol table. */
146 static asymbol
**syms
;
148 /* Number of symbols in `syms'. */
149 static long symcount
= 0;
151 /* The sorted symbol table. */
152 static asymbol
**sorted_syms
;
154 /* Number of symbols in `sorted_syms'. */
155 static long sorted_symcount
= 0;
157 /* The dynamic symbol table. */
158 static asymbol
**dynsyms
;
160 /* The synthetic symbol table. */
161 static asymbol
*synthsyms
;
162 static long synthcount
= 0;
164 /* Number of symbols in `dynsyms'. */
165 static long dynsymcount
= 0;
167 static bfd_byte
*stabs
;
168 static bfd_size_type stab_size
;
171 static bfd_size_type stabstr_size
;
174 usage (FILE *stream
, int status
)
176 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
177 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
178 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
179 fprintf (stream
, _("\
180 -a, --archive-headers Display archive header information\n\
181 -f, --file-headers Display the contents of the overall file header\n\
182 -p, --private-headers Display object format specific file header contents\n\
183 -h, --[section-]headers Display the contents of the section headers\n\
184 -x, --all-headers Display the contents of all headers\n\
185 -d, --disassemble Display assembler contents of executable sections\n\
186 -D, --disassemble-all Display assembler contents of all sections\n\
187 -S, --source Intermix source code with disassembly\n\
188 -s, --full-contents Display the full contents of all sections requested\n\
189 -g, --debugging Display debug information in object file\n\
190 -e, --debugging-tags Display debug information using ctags style\n\
191 -G, --stabs Display (in raw form) any STABS info in the file\n\
192 -t, --syms Display the contents of the symbol table(s)\n\
193 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
194 -r, --reloc Display the relocation entries in the file\n\
195 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
196 -v, --version Display this program's version number\n\
197 -i, --info List object formats and architectures supported\n\
198 -H, --help Display this information\n\
202 fprintf (stream
, _("\n The following switches are optional:\n"));
203 fprintf (stream
, _("\
204 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
205 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
206 -j, --section=NAME Only display information for section NAME\n\
207 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
208 -EB --endian=big Assume big endian format when disassembling\n\
209 -EL --endian=little Assume little endian format when disassembling\n\
210 --file-start-context Include context from start of file (with -S)\n\
211 -I, --include=DIR Add DIR to search list for source files\n\
212 -l, --line-numbers Include line numbers and filenames in output\n\
213 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
214 The STYLE, if specified, can be `auto', `gnu',\n\
215 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
217 -w, --wide Format output for more than 80 columns\n\
218 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
219 --start-address=ADDR Only process data whose address is >= ADDR\n\
220 --stop-address=ADDR Only process data whose address is <= ADDR\n\
221 --prefix-addresses Print complete address alongside disassembly\n\
222 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
223 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
224 --special-syms Include special symbols in symbol dumps\n\
226 list_supported_targets (program_name
, stream
);
227 list_supported_architectures (program_name
, stream
);
229 disassembler_usage (stream
);
232 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
236 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
240 OPTION_START_ADDRESS
,
245 static struct option long_options
[]=
247 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
248 {"all-headers", no_argument
, NULL
, 'x'},
249 {"private-headers", no_argument
, NULL
, 'p'},
250 {"architecture", required_argument
, NULL
, 'm'},
251 {"archive-headers", no_argument
, NULL
, 'a'},
252 {"debugging", no_argument
, NULL
, 'g'},
253 {"debugging-tags", no_argument
, NULL
, 'e'},
254 {"demangle", optional_argument
, NULL
, 'C'},
255 {"disassemble", no_argument
, NULL
, 'd'},
256 {"disassemble-all", no_argument
, NULL
, 'D'},
257 {"disassembler-options", required_argument
, NULL
, 'M'},
258 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
259 {"dynamic-reloc", no_argument
, NULL
, 'R'},
260 {"dynamic-syms", no_argument
, NULL
, 'T'},
261 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
262 {"file-headers", no_argument
, NULL
, 'f'},
263 {"file-start-context", no_argument
, &file_start_context
, 1},
264 {"full-contents", no_argument
, NULL
, 's'},
265 {"headers", no_argument
, NULL
, 'h'},
266 {"help", no_argument
, NULL
, 'H'},
267 {"info", no_argument
, NULL
, 'i'},
268 {"line-numbers", no_argument
, NULL
, 'l'},
269 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
270 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
271 {"reloc", no_argument
, NULL
, 'r'},
272 {"section", required_argument
, NULL
, 'j'},
273 {"section-headers", no_argument
, NULL
, 'h'},
274 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
275 {"source", no_argument
, NULL
, 'S'},
276 {"special-syms", no_argument
, &dump_special_syms
, 1},
277 {"include", required_argument
, NULL
, 'I'},
278 {"stabs", no_argument
, NULL
, 'G'},
279 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
280 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
281 {"syms", no_argument
, NULL
, 't'},
282 {"target", required_argument
, NULL
, 'b'},
283 {"version", no_argument
, NULL
, 'V'},
284 {"wide", no_argument
, NULL
, 'w'},
285 {0, no_argument
, 0, 0}
289 nonfatal (const char *msg
)
296 dump_section_header (bfd
*abfd
, asection
*section
,
297 void *ignored ATTRIBUTE_UNUSED
)
300 unsigned int opb
= bfd_octets_per_byte (abfd
);
302 printf ("%3d %-13s %08lx ", section
->index
,
303 bfd_get_section_name (abfd
, section
),
304 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
305 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
307 bfd_printf_vma (abfd
, section
->lma
);
308 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
309 bfd_get_section_alignment (abfd
, section
));
315 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
317 PF (SEC_HAS_CONTENTS
, "CONTENTS");
318 PF (SEC_ALLOC
, "ALLOC");
319 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
320 PF (SEC_LOAD
, "LOAD");
321 PF (SEC_RELOC
, "RELOC");
322 PF (SEC_READONLY
, "READONLY");
323 PF (SEC_CODE
, "CODE");
324 PF (SEC_DATA
, "DATA");
326 PF (SEC_DEBUGGING
, "DEBUGGING");
327 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
328 PF (SEC_EXCLUDE
, "EXCLUDE");
329 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
330 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
332 PF (SEC_TIC54X_BLOCK
, "BLOCK");
333 PF (SEC_TIC54X_CLINK
, "CLINK");
335 PF (SEC_SMALL_DATA
, "SMALL_DATA");
336 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
337 PF (SEC_COFF_SHARED
, "SHARED");
338 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
339 PF (SEC_GROUP
, "GROUP");
341 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
344 struct coff_comdat_info
*comdat
;
346 switch (section
->flags
& SEC_LINK_DUPLICATES
)
350 case SEC_LINK_DUPLICATES_DISCARD
:
351 ls
= "LINK_ONCE_DISCARD";
353 case SEC_LINK_DUPLICATES_ONE_ONLY
:
354 ls
= "LINK_ONCE_ONE_ONLY";
356 case SEC_LINK_DUPLICATES_SAME_SIZE
:
357 ls
= "LINK_ONCE_SAME_SIZE";
359 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
360 ls
= "LINK_ONCE_SAME_CONTENTS";
363 printf ("%s%s", comma
, ls
);
365 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
367 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
377 dump_headers (bfd
*abfd
)
379 printf (_("Sections:\n"));
382 printf (_("Idx Name Size VMA LMA File off Algn"));
384 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
385 if (bfd_get_arch_size (abfd
) == 32)
386 printf (_("Idx Name Size VMA LMA File off Algn"));
388 printf (_("Idx Name Size VMA LMA File off Algn"));
392 printf (_(" Flags"));
393 if (abfd
->flags
& HAS_LOAD_PAGE
)
397 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
401 slurp_symtab (bfd
*abfd
)
406 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
412 storage
= bfd_get_symtab_upper_bound (abfd
);
414 bfd_fatal (bfd_get_filename (abfd
));
416 sy
= xmalloc (storage
);
418 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
420 bfd_fatal (bfd_get_filename (abfd
));
424 /* Read in the dynamic symbols. */
427 slurp_dynamic_symtab (bfd
*abfd
)
432 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
435 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
437 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
442 bfd_fatal (bfd_get_filename (abfd
));
445 sy
= xmalloc (storage
);
447 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
449 bfd_fatal (bfd_get_filename (abfd
));
453 /* Filter out (in place) symbols that are useless for disassembly.
454 COUNT is the number of elements in SYMBOLS.
455 Return the number of useful symbols. */
458 remove_useless_symbols (asymbol
**symbols
, long count
)
460 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
464 asymbol
*sym
= *in_ptr
++;
466 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
468 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
470 if (bfd_is_und_section (sym
->section
)
471 || bfd_is_com_section (sym
->section
))
476 return out_ptr
- symbols
;
479 /* Sort symbols into value order. */
482 compare_symbols (const void *ap
, const void *bp
)
484 const asymbol
*a
= * (const asymbol
**) ap
;
485 const asymbol
*b
= * (const asymbol
**) bp
;
495 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
497 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
500 if (a
->section
> b
->section
)
502 else if (a
->section
< b
->section
)
505 an
= bfd_asymbol_name (a
);
506 bn
= bfd_asymbol_name (b
);
510 /* The symbols gnu_compiled and gcc2_compiled convey no real
511 information, so put them after other symbols with the same value. */
512 af
= (strstr (an
, "gnu_compiled") != NULL
513 || strstr (an
, "gcc2_compiled") != NULL
);
514 bf
= (strstr (bn
, "gnu_compiled") != NULL
515 || strstr (bn
, "gcc2_compiled") != NULL
);
522 /* We use a heuristic for the file name, to try to sort it after
523 more useful symbols. It may not work on non Unix systems, but it
524 doesn't really matter; the only difference is precisely which
525 symbol names get printed. */
527 #define file_symbol(s, sn, snl) \
528 (((s)->flags & BSF_FILE) != 0 \
529 || ((sn)[(snl) - 2] == '.' \
530 && ((sn)[(snl) - 1] == 'o' \
531 || (sn)[(snl) - 1] == 'a')))
533 af
= file_symbol (a
, an
, anl
);
534 bf
= file_symbol (b
, bn
, bnl
);
541 /* Try to sort global symbols before local symbols before function
542 symbols before debugging symbols. */
547 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
549 if ((aflags
& BSF_DEBUGGING
) != 0)
554 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
556 if ((aflags
& BSF_FUNCTION
) != 0)
561 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
563 if ((aflags
& BSF_LOCAL
) != 0)
568 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
570 if ((aflags
& BSF_GLOBAL
) != 0)
576 /* Symbols that start with '.' might be section names, so sort them
577 after symbols that don't start with '.'. */
578 if (an
[0] == '.' && bn
[0] != '.')
580 if (an
[0] != '.' && bn
[0] == '.')
583 /* Finally, if we can't distinguish them in any other way, try to
584 get consistent results by sorting the symbols by name. */
585 return strcmp (an
, bn
);
588 /* Sort relocs into address order. */
591 compare_relocs (const void *ap
, const void *bp
)
593 const arelent
*a
= * (const arelent
**) ap
;
594 const arelent
*b
= * (const arelent
**) bp
;
596 if (a
->address
> b
->address
)
598 else if (a
->address
< b
->address
)
601 /* So that associated relocations tied to the same address show up
602 in the correct order, we don't do any further sorting. */
611 /* Print an address (VMA) to the output stream in INFO.
612 If SKIP_ZEROES is TRUE, omit leading zeroes. */
615 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
616 bfd_boolean skip_zeroes
)
620 struct objdump_disasm_info
*aux
;
622 aux
= (struct objdump_disasm_info
*) info
->application_data
;
623 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
628 for (p
= buf
; *p
== '0'; ++p
)
633 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
636 /* Print the name of a symbol. */
639 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
646 name
= bfd_asymbol_name (sym
);
647 if (do_demangle
&& name
[0] != '\0')
649 /* Demangle the name. */
650 alloc
= demangle (abfd
, name
);
655 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
663 /* Locate a symbol given a bfd and a section (from INFO->application_data),
664 and a VMA. If INFO->application_data->require_sec is TRUE, then always
665 require the symbol to be in the section. Returns NULL if there is no
666 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
667 of the symbol in sorted_syms. */
670 find_symbol_for_address (bfd_vma vma
,
671 struct disassemble_info
*info
,
674 /* @@ Would it speed things up to cache the last two symbols returned,
675 and maybe their address ranges? For many processors, only one memory
676 operand can be present at a time, so the 2-entry cache wouldn't be
677 constantly churned by code doing heavy memory accesses. */
679 /* Indices in `sorted_syms'. */
681 long max
= sorted_symcount
;
683 struct objdump_disasm_info
*aux
;
688 if (sorted_symcount
< 1)
691 aux
= (struct objdump_disasm_info
*) info
->application_data
;
694 opb
= bfd_octets_per_byte (abfd
);
696 /* Perform a binary search looking for the closest symbol to the
697 required value. We are searching the range (min, max]. */
698 while (min
+ 1 < max
)
702 thisplace
= (max
+ min
) / 2;
703 sym
= sorted_syms
[thisplace
];
705 if (bfd_asymbol_value (sym
) > vma
)
707 else if (bfd_asymbol_value (sym
) < vma
)
716 /* The symbol we want is now in min, the low end of the range we
717 were searching. If there are several symbols with the same
718 value, we want the first one. */
721 && (bfd_asymbol_value (sorted_syms
[thisplace
])
722 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
725 /* If the file is relocatable, and the symbol could be from this
726 section, prefer a symbol from this section over symbols from
727 others, even if the other symbol's value might be closer.
729 Note that this may be wrong for some symbol references if the
730 sections have overlapping memory ranges, but in that case there's
731 no way to tell what's desired without looking at the relocation
733 if (sorted_syms
[thisplace
]->section
!= sec
735 || ((abfd
->flags
& HAS_RELOC
) != 0
736 && vma
>= bfd_get_section_vma (abfd
, sec
)
737 && vma
< (bfd_get_section_vma (abfd
, sec
)
738 + bfd_section_size (abfd
, sec
) / opb
))))
742 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
744 if (bfd_asymbol_value (sorted_syms
[i
])
745 != bfd_asymbol_value (sorted_syms
[thisplace
]))
753 if (sorted_syms
[i
]->section
== sec
755 || sorted_syms
[i
- 1]->section
!= sec
756 || (bfd_asymbol_value (sorted_syms
[i
])
757 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
764 if (sorted_syms
[thisplace
]->section
!= sec
)
766 /* We didn't find a good symbol with a smaller value.
767 Look for one with a larger value. */
768 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
770 if (sorted_syms
[i
]->section
== sec
)
778 if (sorted_syms
[thisplace
]->section
!= sec
780 || ((abfd
->flags
& HAS_RELOC
) != 0
781 && vma
>= bfd_get_section_vma (abfd
, sec
)
782 && vma
< (bfd_get_section_vma (abfd
, sec
)
783 + bfd_section_size (abfd
, sec
)))))
784 /* There is no suitable symbol. */
788 /* Give the target a chance to reject the symbol. */
789 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
792 if (thisplace
>= sorted_symcount
793 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
800 return sorted_syms
[thisplace
];
803 /* Print an address and the offset to the nearest symbol. */
806 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
807 bfd_vma vma
, struct disassemble_info
*info
,
808 bfd_boolean skip_zeroes
)
810 objdump_print_value (vma
, info
, skip_zeroes
);
816 (*info
->fprintf_func
) (info
->stream
, " <%s",
817 bfd_get_section_name (abfd
, sec
));
818 secaddr
= bfd_get_section_vma (abfd
, sec
);
821 (*info
->fprintf_func
) (info
->stream
, "-0x");
822 objdump_print_value (secaddr
- vma
, info
, TRUE
);
824 else if (vma
> secaddr
)
826 (*info
->fprintf_func
) (info
->stream
, "+0x");
827 objdump_print_value (vma
- secaddr
, info
, TRUE
);
829 (*info
->fprintf_func
) (info
->stream
, ">");
833 (*info
->fprintf_func
) (info
->stream
, " <");
834 objdump_print_symname (abfd
, info
, sym
);
835 if (bfd_asymbol_value (sym
) > vma
)
837 (*info
->fprintf_func
) (info
->stream
, "-0x");
838 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
840 else if (vma
> bfd_asymbol_value (sym
))
842 (*info
->fprintf_func
) (info
->stream
, "+0x");
843 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
845 (*info
->fprintf_func
) (info
->stream
, ">");
849 /* Print an address (VMA), symbolically if possible.
850 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
853 objdump_print_addr (bfd_vma vma
,
854 struct disassemble_info
*info
,
855 bfd_boolean skip_zeroes
)
857 struct objdump_disasm_info
*aux
;
858 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
859 #ifdef DISASSEMBLER_NEEDS_RELOCS
860 bfd_boolean skip_find
= FALSE
;
863 if (sorted_symcount
< 1)
865 (*info
->fprintf_func
) (info
->stream
, "0x");
866 objdump_print_value (vma
, info
, skip_zeroes
);
870 aux
= (struct objdump_disasm_info
*) info
->application_data
;
872 #ifdef DISASSEMBLER_NEEDS_RELOCS
873 if (aux
->reloc
!= NULL
874 && aux
->reloc
->sym_ptr_ptr
!= NULL
875 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
877 sym
= * aux
->reloc
->sym_ptr_ptr
;
879 /* Adjust the vma to the reloc. */
880 vma
+= bfd_asymbol_value (sym
);
882 if (bfd_is_und_section (bfd_get_section (sym
)))
888 sym
= find_symbol_for_address (vma
, info
, NULL
);
890 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
894 /* Print VMA to INFO. This function is passed to the disassembler
898 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
900 objdump_print_addr (vma
, info
, ! prefix_addresses
);
903 /* Determine of the given address has a symbol associated with it. */
906 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
910 sym
= find_symbol_for_address (vma
, info
, NULL
);
912 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
915 /* Hold the last function name and the last line number we displayed
918 static char *prev_functionname
;
919 static unsigned int prev_line
;
921 /* We keep a list of all files that we have seen when doing a
922 disassembly with source, so that we know how much of the file to
923 display. This can be important for inlined functions. */
925 struct print_file_list
927 struct print_file_list
*next
;
928 const char *filename
;
934 static struct print_file_list
*print_files
;
936 /* The number of preceding context lines to show when we start
937 displaying a file for the first time. */
939 #define SHOW_PRECEDING_CONTEXT_LINES (5)
941 /* Tries to open MODNAME, and if successful adds a node to print_files
942 linked list and returns that node. Returns NULL on failure. */
944 static struct print_file_list
*
945 try_print_file_open (const char *origname
, const char *modname
)
947 struct print_file_list
*p
;
950 f
= fopen (modname
, "r");
954 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
956 fclose (print_files
->f
);
957 print_files
->f
= NULL
;
960 p
= xmalloc (sizeof (struct print_file_list
));
961 p
->filename
= origname
;
962 p
->modname
= modname
;
965 p
->next
= print_files
;
970 /* If the the source file, as described in the symtab, is not found
971 try to locate it in one of the paths specified with -I
972 If found, add location to print_files linked list. */
974 static struct print_file_list
*
975 update_source_path (const char *filename
)
977 struct print_file_list
*p
;
981 if (filename
== NULL
)
984 p
= try_print_file_open (filename
, filename
);
988 if (include_path_count
== 0)
991 /* Get the name of the file. */
992 fname
= strrchr (filename
, '/');
993 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
995 /* We could have a mixed forward/back slash case. */
996 char *backslash
= strrchr (filename
, '\\');
997 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
999 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1000 fname
= filename
+ 1;
1008 /* If file exists under a new path, we need to add it to the list
1009 so that show_line knows about it. */
1010 for (i
= 0; i
< include_path_count
; i
++)
1012 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1014 p
= try_print_file_open (filename
, modname
);
1024 /* Skip ahead to a given line in a file, optionally printing each
1028 skip_to_line (struct print_file_list
*p
, unsigned int line
,
1031 while (p
->line
< line
)
1035 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1045 if (strchr (buf
, '\n') != NULL
)
1050 /* Show the line number, or the source line, in a disassembly
1054 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1056 const char *filename
;
1057 const char *functionname
;
1060 if (! with_line_numbers
&& ! with_source_code
)
1063 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1064 &functionname
, &line
))
1067 if (filename
!= NULL
&& *filename
== '\0')
1069 if (functionname
!= NULL
&& *functionname
== '\0')
1070 functionname
= NULL
;
1072 if (with_line_numbers
)
1074 if (functionname
!= NULL
1075 && (prev_functionname
== NULL
1076 || strcmp (functionname
, prev_functionname
) != 0))
1077 printf ("%s():\n", functionname
);
1078 if (line
> 0 && line
!= prev_line
)
1079 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1082 if (with_source_code
1086 struct print_file_list
**pp
, *p
;
1088 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1089 if (strcmp ((*pp
)->filename
, filename
) == 0)
1095 if (p
!= print_files
)
1099 /* We have reencountered a file name which we saw
1100 earlier. This implies that either we are dumping out
1101 code from an included file, or the same file was
1102 linked in more than once. There are two common cases
1103 of an included file: inline functions in a header
1104 file, and a bison or flex skeleton file. In the
1105 former case we want to just start printing (but we
1106 back up a few lines to give context); in the latter
1107 case we want to continue from where we left off. I
1108 can't think of a good way to distinguish the cases,
1109 so I used a heuristic based on the file name. */
1110 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1114 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1121 p
->f
= fopen (p
->modname
, "r");
1125 skip_to_line (p
, l
, FALSE
);
1127 if (print_files
->f
!= NULL
)
1129 fclose (print_files
->f
);
1130 print_files
->f
= NULL
;
1136 skip_to_line (p
, line
, TRUE
);
1138 p
->next
= print_files
;
1144 p
= update_source_path (filename
);
1150 if (file_start_context
)
1153 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1156 skip_to_line (p
, l
, FALSE
);
1158 skip_to_line (p
, line
, TRUE
);
1163 if (functionname
!= NULL
1164 && (prev_functionname
== NULL
1165 || strcmp (functionname
, prev_functionname
) != 0))
1167 if (prev_functionname
!= NULL
)
1168 free (prev_functionname
);
1169 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1170 strcpy (prev_functionname
, functionname
);
1173 if (line
> 0 && line
!= prev_line
)
1177 /* Pseudo FILE object for strings. */
1185 /* sprintf to a "stream". */
1188 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1195 size_t space
= f
->alloc
- f
->pos
;
1197 va_start (args
, format
);
1198 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1204 f
->alloc
= (f
->alloc
+ n
) * 2;
1205 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1212 /* Returns TRUE if the specified section should be dumped. */
1215 process_section_p (asection
* section
)
1222 for (i
= 0; i
< only_used
; i
++)
1223 if (strcmp (only
[i
], section
->name
) == 0)
1230 /* The number of zeroes we want to see before we start skipping them.
1231 The number is arbitrarily chosen. */
1233 #define DEFAULT_SKIP_ZEROES 8
1235 /* The number of zeroes to skip at the end of a section. If the
1236 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1237 SKIP_ZEROES, they will be disassembled. If there are fewer than
1238 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1239 attempt to avoid disassembling zeroes inserted by section
1242 #define DEFAULT_SKIP_ZEROES_AT_END 3
1244 /* Disassemble some data in memory between given values. */
1247 disassemble_bytes (struct disassemble_info
* info
,
1248 disassembler_ftype disassemble_fn
,
1251 bfd_vma start_offset
,
1252 bfd_vma stop_offset
,
1255 arelent
** relppend
)
1257 struct objdump_disasm_info
*aux
;
1259 int octets_per_line
;
1260 bfd_boolean done_dot
;
1261 int skip_addr_chars
;
1262 bfd_vma addr_offset
;
1263 unsigned int opb
= info
->octets_per_byte
;
1264 unsigned int skip_zeroes
= info
->skip_zeroes
;
1265 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1269 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1273 sfile
.buffer
= xmalloc (sfile
.alloc
);
1277 octets_per_line
= 4;
1279 octets_per_line
= 16;
1281 /* Figure out how many characters to skip at the start of an
1282 address, to make the disassembly look nicer. We discard leading
1283 zeroes in chunks of 4, ensuring that there is always a leading
1285 skip_addr_chars
= 0;
1286 if (! prefix_addresses
)
1294 + bfd_section_size (section
->owner
, section
) / opb
));
1296 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1299 skip_addr_chars
+= 4;
1304 info
->insn_info_valid
= 0;
1307 addr_offset
= start_offset
;
1308 while (addr_offset
< stop_offset
)
1311 bfd_boolean need_nl
= FALSE
;
1312 #ifdef DISASSEMBLER_NEEDS_RELOCS
1313 int previous_octets
;
1315 /* Remember the length of the previous instruction. */
1316 previous_octets
= octets
;
1320 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1322 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1325 if (! disassemble_zeroes
1326 && (info
->insn_info_valid
== 0
1327 || info
->branch_delay_insns
== 0)
1328 && (z
- addr_offset
* opb
>= skip_zeroes
1329 || (z
== stop_offset
* opb
&&
1330 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1334 /* If there are more nonzero octets to follow, we only skip
1335 zeroes in multiples of 4, to try to avoid running over
1336 the start of an instruction which happens to start with
1338 if (z
!= stop_offset
* opb
)
1339 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1341 octets
= z
- addr_offset
* opb
;
1351 if (with_line_numbers
|| with_source_code
)
1352 /* The line number tables will refer to unadjusted
1353 section VMAs, so we must undo any VMA modifications
1354 when calling show_line. */
1355 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1357 if (! prefix_addresses
)
1361 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1362 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1366 printf ("%s:\t", buf
+ skip_addr_chars
);
1370 aux
->require_sec
= TRUE
;
1371 objdump_print_address (section
->vma
+ addr_offset
, info
);
1372 aux
->require_sec
= FALSE
;
1379 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1380 info
->stream
= &sfile
;
1381 info
->bytes_per_line
= 0;
1382 info
->bytes_per_chunk
= 0;
1385 #ifdef DISASSEMBLER_NEEDS_RELOCS
1386 if (*relppp
< relppend
)
1388 bfd_signed_vma distance_to_rel
;
1390 distance_to_rel
= (**relppp
)->address
1391 - (rel_offset
+ addr_offset
);
1393 /* Check to see if the current reloc is associated with
1394 the instruction that we are about to disassemble. */
1395 if (distance_to_rel
== 0
1396 /* FIXME: This is wrong. We are trying to catch
1397 relocs that are addressed part way through the
1398 current instruction, as might happen with a packed
1399 VLIW instruction. Unfortunately we do not know the
1400 length of the current instruction since we have not
1401 disassembled it yet. Instead we take a guess based
1402 upon the length of the previous instruction. The
1403 proper solution is to have a new target-specific
1404 disassembler function which just returns the length
1405 of an instruction at a given address without trying
1406 to display its disassembly. */
1407 || (distance_to_rel
> 0
1408 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1410 info
->flags
= INSN_HAS_RELOC
;
1411 aux
->reloc
= **relppp
;
1417 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1418 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1419 info
->stream
= stdout
;
1420 if (info
->bytes_per_line
!= 0)
1421 octets_per_line
= info
->bytes_per_line
;
1425 printf ("%s\n", sfile
.buffer
);
1433 octets
= octets_per_line
;
1434 if (addr_offset
+ octets
/ opb
> stop_offset
)
1435 octets
= (stop_offset
- addr_offset
) * opb
;
1437 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1439 if (ISPRINT (data
[j
]))
1440 buf
[j
- addr_offset
* opb
] = data
[j
];
1442 buf
[j
- addr_offset
* opb
] = '.';
1444 buf
[j
- addr_offset
* opb
] = '\0';
1447 if (prefix_addresses
1449 : show_raw_insn
>= 0)
1453 /* If ! prefix_addresses and ! wide_output, we print
1454 octets_per_line octets per line. */
1456 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1457 pb
= octets_per_line
;
1459 if (info
->bytes_per_chunk
)
1460 bpc
= info
->bytes_per_chunk
;
1464 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1468 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1470 for (k
= bpc
- 1; k
>= 0; k
--)
1471 printf ("%02x", (unsigned) data
[j
+ k
]);
1476 for (k
= 0; k
< bpc
; k
++)
1477 printf ("%02x", (unsigned) data
[j
+ k
]);
1482 for (; pb
< octets_per_line
; pb
+= bpc
)
1486 for (k
= 0; k
< bpc
; k
++)
1491 /* Separate raw data from instruction by extra space. */
1501 printf ("%s", sfile
.buffer
);
1503 if (prefix_addresses
1505 : show_raw_insn
>= 0)
1513 j
= addr_offset
* opb
+ pb
;
1515 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1516 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1520 printf ("%s:\t", buf
+ skip_addr_chars
);
1522 pb
+= octets_per_line
;
1525 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1529 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1531 for (k
= bpc
- 1; k
>= 0; k
--)
1532 printf ("%02x", (unsigned) data
[j
+ k
]);
1537 for (k
= 0; k
< bpc
; k
++)
1538 printf ("%02x", (unsigned) data
[j
+ k
]);
1551 while ((*relppp
) < relppend
1552 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1554 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1565 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1568 printf (": %s\t", q
->howto
->name
);
1570 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1571 printf ("*unknown*");
1574 const char *sym_name
;
1576 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1577 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1578 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1583 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1584 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1585 if (sym_name
== NULL
|| *sym_name
== '\0')
1586 sym_name
= "*unknown*";
1587 printf ("%s", sym_name
);
1594 objdump_print_value (q
->addend
, info
, TRUE
);
1606 addr_offset
+= octets
/ opb
;
1609 free (sfile
.buffer
);
1613 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1615 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1616 struct objdump_disasm_info
* paux
;
1617 unsigned int opb
= pinfo
->octets_per_byte
;
1618 bfd_byte
* data
= NULL
;
1619 bfd_size_type datasize
= 0;
1620 arelent
** rel_pp
= NULL
;
1621 arelent
** rel_ppstart
= NULL
;
1622 arelent
** rel_ppend
;
1623 unsigned long stop_offset
;
1624 asymbol
* sym
= NULL
;
1628 unsigned long addr_offset
;
1630 /* Sections that do not contain machine
1631 code are not normally disassembled. */
1632 if (! disassemble_all
1634 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1635 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1638 if (! process_section_p (section
))
1641 datasize
= bfd_get_section_size (section
);
1645 /* Decide which set of relocs to use. Load them if necessary. */
1646 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1647 if (paux
->dynrelbuf
)
1649 rel_pp
= paux
->dynrelbuf
;
1650 rel_count
= paux
->dynrelcount
;
1651 /* Dynamic reloc addresses are absolute, non-dynamic are section
1652 relative. REL_OFFSET specifies the reloc address corresponding
1653 to the start of this section. */
1654 rel_offset
= section
->vma
;
1662 if ((section
->flags
& SEC_RELOC
) != 0
1663 #ifndef DISASSEMBLER_NEEDS_RELOCS
1670 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1672 bfd_fatal (bfd_get_filename (abfd
));
1676 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1677 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1679 bfd_fatal (bfd_get_filename (abfd
));
1681 /* Sort the relocs by address. */
1682 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1687 rel_ppend
= rel_pp
+ rel_count
;
1689 data
= xmalloc (datasize
);
1691 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1693 paux
->sec
= section
;
1694 pinfo
->buffer
= data
;
1695 pinfo
->buffer_vma
= section
->vma
;
1696 pinfo
->buffer_length
= datasize
;
1697 pinfo
->section
= section
;
1699 if (start_address
== (bfd_vma
) -1
1700 || start_address
< pinfo
->buffer_vma
)
1703 addr_offset
= start_address
- pinfo
->buffer_vma
;
1705 if (stop_address
== (bfd_vma
) -1)
1706 stop_offset
= datasize
/ opb
;
1709 if (stop_address
< pinfo
->buffer_vma
)
1712 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1713 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1714 stop_offset
= pinfo
->buffer_length
/ opb
;
1717 /* Skip over the relocs belonging to addresses below the
1719 while (rel_pp
< rel_ppend
1720 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1723 printf (_("Disassembly of section %s:\n"), section
->name
);
1725 /* Find the nearest symbol forwards from our current position. */
1726 paux
->require_sec
= TRUE
;
1727 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1728 paux
->require_sec
= FALSE
;
1730 /* Disassemble a block of instructions up to the address associated with
1731 the symbol we have just found. Then print the symbol and find the
1732 next symbol on. Repeat until we have disassembled the entire section
1733 or we have reached the end of the address range we are interested in. */
1734 while (addr_offset
< stop_offset
)
1738 unsigned long nextstop_offset
;
1741 addr
= section
->vma
+ addr_offset
;
1743 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1748 (x
< sorted_symcount
1749 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1753 pinfo
->symbols
= sorted_syms
+ place
;
1754 pinfo
->num_symbols
= x
- place
;
1758 pinfo
->symbols
= NULL
;
1759 pinfo
->num_symbols
= 0;
1762 if (! prefix_addresses
)
1764 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1765 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1767 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1770 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1772 else if (sym
== NULL
)
1776 #define is_valid_next_sym(SYM) \
1777 ((SYM)->section == section \
1778 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1779 && pinfo->symbol_is_valid (SYM, pinfo))
1781 /* Search forward for the next appropriate symbol in
1782 SECTION. Note that all the symbols are sorted
1783 together into one big array, and that some sections
1784 may have overlapping addresses. */
1785 while (place
< sorted_symcount
1786 && ! is_valid_next_sym (sorted_syms
[place
]))
1789 if (place
>= sorted_symcount
)
1792 nextsym
= sorted_syms
[place
];
1795 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1796 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1797 else if (nextsym
== NULL
)
1798 nextstop_offset
= stop_offset
;
1800 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1802 if (nextstop_offset
> stop_offset
)
1803 nextstop_offset
= stop_offset
;
1805 /* If a symbol is explicitly marked as being an object
1806 rather than a function, just dump the bytes without
1807 disassembling them. */
1810 || bfd_asymbol_value (sym
) > addr
1811 || ((sym
->flags
& BSF_OBJECT
) == 0
1812 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1814 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1816 || (sym
->flags
& BSF_FUNCTION
) != 0)
1821 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1822 addr_offset
, nextstop_offset
,
1823 rel_offset
, &rel_pp
, rel_ppend
);
1825 addr_offset
= nextstop_offset
;
1831 if (rel_ppstart
!= NULL
)
1835 /* Disassemble the contents of an object file. */
1838 disassemble_data (bfd
*abfd
)
1840 struct disassemble_info disasm_info
;
1841 struct objdump_disasm_info aux
;
1845 prev_functionname
= NULL
;
1848 /* We make a copy of syms to sort. We don't want to sort syms
1849 because that will screw up the relocs. */
1850 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1851 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1852 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1853 sorted_symcount
* sizeof (asymbol
*));
1855 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1857 for (i
= 0; i
< synthcount
; ++i
)
1859 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1863 /* Sort the symbols into section and symbol order. */
1864 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1866 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1868 disasm_info
.application_data
= (void *) &aux
;
1870 aux
.require_sec
= FALSE
;
1871 aux
.dynrelbuf
= NULL
;
1872 aux
.dynrelcount
= 0;
1873 #ifdef DISASSEMBLER_NEEDS_RELOCS
1877 disasm_info
.print_address_func
= objdump_print_address
;
1878 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1880 if (machine
!= NULL
)
1882 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1885 fatal (_("Can't use supplied machine %s"), machine
);
1887 abfd
->arch_info
= info
;
1890 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1892 struct bfd_target
*xvec
;
1894 xvec
= xmalloc (sizeof (struct bfd_target
));
1895 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1896 xvec
->byteorder
= endian
;
1900 /* Use libopcodes to locate a suitable disassembler. */
1901 aux
.disassemble_fn
= disassembler (abfd
);
1902 if (!aux
.disassemble_fn
)
1904 non_fatal (_("Can't disassemble for architecture %s\n"),
1905 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1910 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1911 disasm_info
.arch
= bfd_get_arch (abfd
);
1912 disasm_info
.mach
= bfd_get_mach (abfd
);
1913 disasm_info
.disassembler_options
= disassembler_options
;
1914 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1915 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1916 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1918 if (bfd_big_endian (abfd
))
1919 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1920 else if (bfd_little_endian (abfd
))
1921 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1923 /* ??? Aborting here seems too drastic. We could default to big or little
1925 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1927 /* Allow the target to customize the info structure. */
1928 disassemble_init_for_target (& disasm_info
);
1930 /* Pre-load the dynamic relocs if we are going
1931 to be dumping them along with the disassembly. */
1932 if (dump_dynamic_reloc_info
)
1934 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1937 bfd_fatal (bfd_get_filename (abfd
));
1941 aux
.dynrelbuf
= xmalloc (relsize
);
1942 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1945 if (aux
.dynrelcount
< 0)
1946 bfd_fatal (bfd_get_filename (abfd
));
1948 /* Sort the relocs by address. */
1949 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1954 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1956 if (aux
.dynrelbuf
!= NULL
)
1957 free (aux
.dynrelbuf
);
1961 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1962 it. Return NULL on failure. */
1965 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
1971 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
1972 if (stabsect
== NULL
)
1974 printf (_("No %s section present\n\n"), sect_name
);
1978 size
= bfd_section_size (abfd
, stabsect
);
1979 contents
= xmalloc (size
);
1981 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
1983 non_fatal (_("Reading %s section of %s failed: %s"),
1984 sect_name
, bfd_get_filename (abfd
),
1985 bfd_errmsg (bfd_get_error ()));
1996 /* Stabs entries use a 12 byte format:
1997 4 byte string table index
1999 1 byte stab other field
2000 2 byte stab desc field
2002 FIXME: This will have to change for a 64 bit object format. */
2004 #define STRDXOFF (0)
2006 #define OTHEROFF (5)
2009 #define STABSIZE (12)
2011 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2012 using string table section STRSECT_NAME (in `strtab'). */
2015 print_section_stabs (bfd
*abfd
,
2016 const char *stabsect_name
,
2017 unsigned *string_offset_ptr
)
2020 unsigned file_string_table_offset
= 0;
2021 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2022 bfd_byte
*stabp
, *stabs_end
;
2025 stabs_end
= stabp
+ stab_size
;
2027 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2028 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2030 /* Loop through all symbols and print them.
2032 We start the index at -1 because there is a dummy symbol on
2033 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2034 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2038 unsigned char type
, other
;
2039 unsigned short desc
;
2042 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2043 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2044 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2045 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2046 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2048 printf ("\n%-6d ", i
);
2049 /* Either print the stab name, or, if unnamed, print its number
2050 again (makes consistent formatting for tools like awk). */
2051 name
= bfd_get_stab_name (type
);
2053 printf ("%-6s", name
);
2054 else if (type
== N_UNDF
)
2057 printf ("%-6d", type
);
2058 printf (" %-6d %-6d ", other
, desc
);
2059 bfd_printf_vma (abfd
, value
);
2060 printf (" %-6lu", strx
);
2062 /* Symbols with type == 0 (N_UNDF) specify the length of the
2063 string table associated with this file. We use that info
2064 to know how to relocate the *next* file's string table indices. */
2067 file_string_table_offset
= next_file_string_table_offset
;
2068 next_file_string_table_offset
+= value
;
2072 /* Using the (possibly updated) string table offset, print the
2073 string (if any) associated with this symbol. */
2074 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2075 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2081 *string_offset_ptr
= next_file_string_table_offset
;
2086 const char * section_name
;
2087 const char * string_section_name
;
2088 unsigned string_offset
;
2093 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2096 stab_section_names
* sought
= (stab_section_names
*) names
;
2098 /* Check for section names for which stabsect_name is a prefix, to
2099 handle .stab.N, etc. */
2100 len
= strlen (sought
->section_name
);
2102 /* If the prefix matches, and the files section name ends with a
2103 nul or a digit, then we match. I.e., we want either an exact
2104 match or a section followed by a number. */
2105 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2106 && (section
->name
[len
] == 0
2107 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2110 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2115 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2118 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2124 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2126 stab_section_names s
;
2128 s
.section_name
= stabsect_name
;
2129 s
.string_section_name
= strsect_name
;
2130 s
.string_offset
= 0;
2132 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2138 /* Dump the any sections containing stabs debugging information. */
2141 dump_stabs (bfd
*abfd
)
2143 dump_stabs_section (abfd
, ".stab", ".stabstr");
2144 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2145 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2146 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2150 dump_bfd_header (bfd
*abfd
)
2154 printf (_("architecture: %s, "),
2155 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2156 bfd_get_mach (abfd
)));
2157 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2159 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2160 PF (HAS_RELOC
, "HAS_RELOC");
2161 PF (EXEC_P
, "EXEC_P");
2162 PF (HAS_LINENO
, "HAS_LINENO");
2163 PF (HAS_DEBUG
, "HAS_DEBUG");
2164 PF (HAS_SYMS
, "HAS_SYMS");
2165 PF (HAS_LOCALS
, "HAS_LOCALS");
2166 PF (DYNAMIC
, "DYNAMIC");
2167 PF (WP_TEXT
, "WP_TEXT");
2168 PF (D_PAGED
, "D_PAGED");
2169 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2170 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2171 printf (_("\nstart address 0x"));
2172 bfd_printf_vma (abfd
, abfd
->start_address
);
2178 dump_bfd_private_header (bfd
*abfd
)
2180 bfd_print_private_bfd_data (abfd
, stdout
);
2184 /* Display a section in hexadecimal format with associated characters.
2185 Each line prefixed by the zero padded address. */
2188 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2191 bfd_size_type datasize
;
2192 bfd_size_type addr_offset
;
2193 bfd_size_type start_offset
;
2194 bfd_size_type stop_offset
;
2195 unsigned int opb
= bfd_octets_per_byte (abfd
);
2196 /* Bytes per line. */
2197 const int onaline
= 16;
2202 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2205 if (! process_section_p (section
))
2208 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2211 printf (_("Contents of section %s:\n"), section
->name
);
2213 data
= xmalloc (datasize
);
2215 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2217 /* Compute the address range to display. */
2218 if (start_address
== (bfd_vma
) -1
2219 || start_address
< section
->vma
)
2222 start_offset
= start_address
- section
->vma
;
2224 if (stop_address
== (bfd_vma
) -1)
2225 stop_offset
= datasize
/ opb
;
2228 if (stop_address
< section
->vma
)
2231 stop_offset
= stop_address
- section
->vma
;
2233 if (stop_offset
> datasize
/ opb
)
2234 stop_offset
= datasize
/ opb
;
2239 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2240 if (strlen (buf
) >= sizeof (buf
))
2244 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2246 count
= strlen (buf
) - count
;
2250 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2251 if (strlen (buf
) >= sizeof (buf
))
2255 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2257 count
= strlen (buf
) - count
;
2261 for (addr_offset
= start_offset
;
2262 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2266 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2267 count
= strlen (buf
);
2268 if ((size_t) count
>= sizeof (buf
))
2272 while (count
< width
)
2277 fputs (buf
+ count
- width
, stdout
);
2280 for (j
= addr_offset
* opb
;
2281 j
< addr_offset
* opb
+ onaline
; j
++)
2283 if (j
< stop_offset
* opb
)
2284 printf ("%02x", (unsigned) (data
[j
]));
2292 for (j
= addr_offset
* opb
;
2293 j
< addr_offset
* opb
+ onaline
; j
++)
2295 if (j
>= stop_offset
* opb
)
2298 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2305 /* Actually display the various requested regions. */
2308 dump_data (bfd
*abfd
)
2310 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2313 /* Should perhaps share code and display with nm? */
2316 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2326 printf ("DYNAMIC SYMBOL TABLE:\n");
2332 printf ("SYMBOL TABLE:\n");
2336 printf (_("no symbols\n"));
2338 for (count
= 0; count
< max
; count
++)
2342 if (*current
== NULL
)
2343 printf (_("no information for symbol number %ld\n"), count
);
2345 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2346 printf (_("could not determine the type of symbol number %ld\n"),
2349 else if (process_section_p ((* current
)->section
)
2350 && (dump_special_syms
2351 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2353 const char *name
= (*current
)->name
;
2355 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2359 /* If we want to demangle the name, we demangle it
2360 here, and temporarily clobber it while calling
2361 bfd_print_symbol. FIXME: This is a gross hack. */
2362 alloc
= demangle (cur_bfd
, name
);
2363 (*current
)->name
= alloc
;
2364 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2365 bfd_print_symbol_all
);
2366 (*current
)->name
= name
;
2370 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2371 bfd_print_symbol_all
);
2381 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2384 char *last_filename
, *last_functionname
;
2385 unsigned int last_line
;
2387 /* Get column headers lined up reasonably. */
2395 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2396 width
= strlen (buf
) - 7;
2398 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2401 last_filename
= NULL
;
2402 last_functionname
= NULL
;
2405 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2408 const char *filename
, *functionname
;
2410 const char *sym_name
;
2411 const char *section_name
;
2413 if (start_address
!= (bfd_vma
) -1
2414 && q
->address
< start_address
)
2416 if (stop_address
!= (bfd_vma
) -1
2417 && q
->address
> stop_address
)
2420 if (with_line_numbers
2422 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2423 &filename
, &functionname
, &line
))
2425 if (functionname
!= NULL
2426 && (last_functionname
== NULL
2427 || strcmp (functionname
, last_functionname
) != 0))
2429 printf ("%s():\n", functionname
);
2430 if (last_functionname
!= NULL
)
2431 free (last_functionname
);
2432 last_functionname
= xstrdup (functionname
);
2436 && (line
!= last_line
2437 || (filename
!= NULL
2438 && last_filename
!= NULL
2439 && strcmp (filename
, last_filename
) != 0)))
2441 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2443 if (last_filename
!= NULL
)
2444 free (last_filename
);
2445 if (filename
== NULL
)
2446 last_filename
= NULL
;
2448 last_filename
= xstrdup (filename
);
2452 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2454 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2455 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2460 section_name
= NULL
;
2465 bfd_printf_vma (abfd
, q
->address
);
2467 printf (" %-16s ", q
->howto
->name
);
2469 printf (" %-16d ", q
->howto
->type
);
2470 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2474 if (section_name
== NULL
)
2475 section_name
= "*unknown*";
2476 bfd_printf_vma (abfd
, q
->address
);
2477 printf (" %-16s [%s]",
2485 bfd_printf_vma (abfd
, q
->addend
);
2493 dump_relocs_in_section (bfd
*abfd
,
2495 void *dummy ATTRIBUTE_UNUSED
)
2501 if ( bfd_is_abs_section (section
)
2502 || bfd_is_und_section (section
)
2503 || bfd_is_com_section (section
)
2504 || (! process_section_p (section
))
2505 || ((section
->flags
& SEC_RELOC
) == 0))
2508 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2510 bfd_fatal (bfd_get_filename (abfd
));
2512 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2516 printf (" (none)\n\n");
2520 relpp
= xmalloc (relsize
);
2521 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2524 bfd_fatal (bfd_get_filename (abfd
));
2525 else if (relcount
== 0)
2526 printf (" (none)\n\n");
2530 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2537 dump_relocs (bfd
*abfd
)
2539 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2543 dump_dynamic_relocs (bfd
*abfd
)
2549 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2551 bfd_fatal (bfd_get_filename (abfd
));
2553 printf ("DYNAMIC RELOCATION RECORDS");
2556 printf (" (none)\n\n");
2559 relpp
= xmalloc (relsize
);
2560 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2563 bfd_fatal (bfd_get_filename (abfd
));
2564 else if (relcount
== 0)
2565 printf (" (none)\n\n");
2569 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2576 /* Creates a table of paths, to search for source files. */
2579 add_include_path (const char *path
)
2583 include_path_count
++;
2584 include_paths
= xrealloc (include_paths
,
2585 include_path_count
* sizeof (*include_paths
));
2586 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2587 if (path
[1] == ':' && path
[2] == 0)
2588 path
= concat (path
, ".", (const char *) 0);
2590 include_paths
[include_path_count
- 1] = path
;
2594 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2596 void *dummy ATTRIBUTE_UNUSED
)
2598 section
->vma
+= adjust_section_vma
;
2599 section
->lma
+= adjust_section_vma
;
2602 /* Dump selected contents of ABFD. */
2605 dump_bfd (bfd
*abfd
)
2607 /* If we are adjusting section VMA's, change them all now. Changing
2608 the BFD information is a hack. However, we must do it, or
2609 bfd_find_nearest_line will not do the right thing. */
2610 if (adjust_section_vma
!= 0)
2611 bfd_map_over_sections (abfd
, adjust_addresses
, NULL
);
2613 if (! dump_debugging_tags
)
2614 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2617 print_arelt_descr (stdout
, abfd
, TRUE
);
2618 if (dump_file_header
)
2619 dump_bfd_header (abfd
);
2620 if (dump_private_headers
)
2621 dump_bfd_private_header (abfd
);
2622 if (! dump_debugging_tags
)
2624 if (dump_section_headers
)
2625 dump_headers (abfd
);
2627 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2628 syms
= slurp_symtab (abfd
);
2629 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2630 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2631 dynsyms
= slurp_dynamic_symtab (abfd
);
2634 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2635 dynsymcount
, dynsyms
, &synthsyms
);
2641 dump_symbols (abfd
, FALSE
);
2642 if (dump_dynamic_symtab
)
2643 dump_symbols (abfd
, TRUE
);
2644 if (dump_stab_section_info
)
2646 if (dump_reloc_info
&& ! disassemble
)
2648 if (dump_dynamic_reloc_info
&& ! disassemble
)
2649 dump_dynamic_relocs (abfd
);
2650 if (dump_section_contents
)
2653 disassemble_data (abfd
);
2659 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2660 if (dhandle
!= NULL
)
2662 if (! print_debugging_info (stdout
, dhandle
, abfd
, syms
, demangle
,
2663 dump_debugging_tags
? TRUE
: FALSE
))
2665 non_fatal (_("%s: printing debugging information failed"),
2666 bfd_get_filename (abfd
));
2696 display_bfd (bfd
*abfd
)
2700 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2706 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2708 nonfatal (bfd_get_filename (abfd
));
2709 list_matching_formats (matching
);
2714 if (bfd_get_error () != bfd_error_file_not_recognized
)
2716 nonfatal (bfd_get_filename (abfd
));
2720 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2726 nonfatal (bfd_get_filename (abfd
));
2728 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2730 list_matching_formats (matching
);
2736 display_file (char *filename
, char *target
)
2741 if (get_file_size (filename
) < 1)
2744 file
= bfd_openr (filename
, target
);
2747 nonfatal (filename
);
2751 /* If the file is an archive, process all of its elements. */
2752 if (bfd_check_format (file
, bfd_archive
))
2754 bfd
*last_arfile
= NULL
;
2756 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2759 bfd_set_error (bfd_error_no_error
);
2761 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2764 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2765 nonfatal (bfd_get_filename (file
));
2769 display_bfd (arfile
);
2771 if (last_arfile
!= NULL
)
2772 bfd_close (last_arfile
);
2773 last_arfile
= arfile
;
2776 if (last_arfile
!= NULL
)
2777 bfd_close (last_arfile
);
2786 main (int argc
, char **argv
)
2789 char *target
= default_target
;
2790 bfd_boolean seenflag
= FALSE
;
2792 #if defined (HAVE_SETLOCALE)
2793 #if defined (HAVE_LC_MESSAGES)
2794 setlocale (LC_MESSAGES
, "");
2796 setlocale (LC_CTYPE
, "");
2799 bindtextdomain (PACKAGE
, LOCALEDIR
);
2800 textdomain (PACKAGE
);
2802 program_name
= *argv
;
2803 xmalloc_set_program_name (program_name
);
2805 START_PROGRESS (program_name
, 0);
2808 set_default_bfd_target ();
2810 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2811 long_options
, (int *) 0))
2817 break; /* We've been given a long option. */
2822 if (disassembler_options
)
2823 /* Ignore potential memory leak for now. */
2824 disassembler_options
= concat (disassembler_options
, ",",
2827 disassembler_options
= optarg
;
2830 if (only_used
== only_size
)
2833 only
= xrealloc (only
, only_size
* sizeof (char *));
2835 only
[only_used
++] = optarg
;
2838 with_line_numbers
= TRUE
;
2847 enum demangling_styles style
;
2849 style
= cplus_demangle_name_to_style (optarg
);
2850 if (style
== unknown_demangling
)
2851 fatal (_("unknown demangling style `%s'"),
2854 cplus_demangle_set_style (style
);
2860 case OPTION_ADJUST_VMA
:
2861 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2863 case OPTION_START_ADDRESS
:
2864 start_address
= parse_vma (optarg
, "--start-address");
2866 case OPTION_STOP_ADDRESS
:
2867 stop_address
= parse_vma (optarg
, "--stop-address");
2870 if (strcmp (optarg
, "B") == 0)
2871 endian
= BFD_ENDIAN_BIG
;
2872 else if (strcmp (optarg
, "L") == 0)
2873 endian
= BFD_ENDIAN_LITTLE
;
2876 non_fatal (_("unrecognized -E option"));
2881 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2882 endian
= BFD_ENDIAN_BIG
;
2883 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2884 endian
= BFD_ENDIAN_LITTLE
;
2887 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2893 dump_file_header
= TRUE
;
2897 formats_info
= TRUE
;
2901 add_include_path (optarg
);
2904 dump_private_headers
= TRUE
;
2908 dump_private_headers
= TRUE
;
2910 dump_reloc_info
= TRUE
;
2911 dump_file_header
= TRUE
;
2912 dump_ar_hdrs
= TRUE
;
2913 dump_section_headers
= TRUE
;
2921 dump_dynamic_symtab
= TRUE
;
2929 disassemble_zeroes
= TRUE
;
2933 disassemble_all
= TRUE
;
2938 with_source_code
= TRUE
;
2947 dump_debugging_tags
= 1;
2952 dump_stab_section_info
= TRUE
;
2956 dump_section_contents
= TRUE
;
2960 dump_reloc_info
= TRUE
;
2964 dump_dynamic_reloc_info
= TRUE
;
2968 dump_ar_hdrs
= TRUE
;
2972 dump_section_headers
= TRUE
;
2980 show_version
= TRUE
;
2990 print_version ("objdump");
2996 exit_status
= display_info ();
3000 display_file ("a.out", target
);
3002 for (; optind
< argc
;)
3003 display_file (argv
[optind
++], target
);
3006 END_PROGRESS (program_name
);