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, 2006, 2007
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 3, 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, 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
59 #include "safe-ctype.h"
61 #include "libiberty.h"
72 /* Internal headers for the ELF .stab-dump code - sorry. */
73 #define BYTES_IN_WORD 32
74 #include "aout/aout64.h"
77 static int exit_status
= 0;
79 static char *default_target
= NULL
; /* Default at runtime. */
81 /* The following variables are set based on arguments passed on the
83 static int show_version
= 0; /* Show the version number. */
84 static int dump_section_contents
; /* -s */
85 static int dump_section_headers
; /* -h */
86 static bfd_boolean dump_file_header
; /* -f */
87 static int dump_symtab
; /* -t */
88 static int dump_dynamic_symtab
; /* -T */
89 static int dump_reloc_info
; /* -r */
90 static int dump_dynamic_reloc_info
; /* -R */
91 static int dump_ar_hdrs
; /* -a */
92 static int dump_private_headers
; /* -p */
93 static int prefix_addresses
; /* --prefix-addresses */
94 static int with_line_numbers
; /* -l */
95 static bfd_boolean with_source_code
; /* -S */
96 static int show_raw_insn
; /* --show-raw-insn */
97 static int dump_dwarf_section_info
; /* --dwarf */
98 static int dump_stab_section_info
; /* --stabs */
99 static int do_demangle
; /* -C, --demangle */
100 static bfd_boolean disassemble
; /* -d */
101 static bfd_boolean disassemble_all
; /* -D */
102 static int disassemble_zeroes
; /* --disassemble-zeroes */
103 static bfd_boolean formats_info
; /* -i */
104 static int wide_output
; /* -w */
105 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
106 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
107 static int dump_debugging
; /* --debugging */
108 static int dump_debugging_tags
; /* --debugging-tags */
109 static int dump_special_syms
= 0; /* --special-syms */
110 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
111 static int file_start_context
= 0; /* --file-start-context */
113 /* Pointer to an array of section names provided by
114 one or more "-j secname" command line options. */
116 /* The total number of slots in the only[] array. */
117 static size_t only_size
= 0;
118 /* The number of occupied slots in the only[] array. */
119 static size_t only_used
= 0;
121 /* Variables for handling include file path table. */
122 static const char **include_paths
;
123 static int include_path_count
;
125 /* Extra info to pass to the section disassembler and address printing
127 struct objdump_disasm_info
131 bfd_boolean require_sec
;
132 arelent
** dynrelbuf
;
134 disassembler_ftype disassemble_fn
;
138 /* Architecture to disassemble for, or default if NULL. */
139 static char *machine
= NULL
;
141 /* Target specific options to the disassembler. */
142 static char *disassembler_options
= NULL
;
144 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
145 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
147 /* The symbol table. */
148 static asymbol
**syms
;
150 /* Number of symbols in `syms'. */
151 static long symcount
= 0;
153 /* The sorted symbol table. */
154 static asymbol
**sorted_syms
;
156 /* Number of symbols in `sorted_syms'. */
157 static long sorted_symcount
= 0;
159 /* The dynamic symbol table. */
160 static asymbol
**dynsyms
;
162 /* The synthetic symbol table. */
163 static asymbol
*synthsyms
;
164 static long synthcount
= 0;
166 /* Number of symbols in `dynsyms'. */
167 static long dynsymcount
= 0;
169 static bfd_byte
*stabs
;
170 static bfd_size_type stab_size
;
173 static bfd_size_type stabstr_size
;
175 static bfd_boolean is_relocatable
= FALSE
;
178 usage (FILE *stream
, int status
)
180 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
181 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
182 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
183 fprintf (stream
, _("\
184 -a, --archive-headers Display archive header information\n\
185 -f, --file-headers Display the contents of the overall file header\n\
186 -p, --private-headers Display object format specific file header contents\n\
187 -h, --[section-]headers Display the contents of the section headers\n\
188 -x, --all-headers Display the contents of all headers\n\
189 -d, --disassemble Display assembler contents of executable sections\n\
190 -D, --disassemble-all Display assembler contents of all sections\n\
191 -S, --source Intermix source code with disassembly\n\
192 -s, --full-contents Display the full contents of all sections requested\n\
193 -g, --debugging Display debug information in object file\n\
194 -e, --debugging-tags Display debug information using ctags style\n\
195 -G, --stabs Display (in raw form) any STABS info in the file\n\
196 -W, --dwarf Display DWARF info in the file\n\
197 -t, --syms Display the contents of the symbol table(s)\n\
198 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
199 -r, --reloc Display the relocation entries in the file\n\
200 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
201 @<file> Read options from <file>\n\
202 -v, --version Display this program's version number\n\
203 -i, --info List object formats and architectures supported\n\
204 -H, --help Display this information\n\
208 fprintf (stream
, _("\n The following switches are optional:\n"));
209 fprintf (stream
, _("\
210 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
211 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
212 -j, --section=NAME Only display information for section NAME\n\
213 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
214 -EB --endian=big Assume big endian format when disassembling\n\
215 -EL --endian=little Assume little endian format when disassembling\n\
216 --file-start-context Include context from start of file (with -S)\n\
217 -I, --include=DIR Add DIR to search list for source files\n\
218 -l, --line-numbers Include line numbers and filenames in output\n\
219 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
220 The STYLE, if specified, can be `auto', `gnu',\n\
221 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
223 -w, --wide Format output for more than 80 columns\n\
224 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
225 --start-address=ADDR Only process data whose address is >= ADDR\n\
226 --stop-address=ADDR Only process data whose address is <= ADDR\n\
227 --prefix-addresses Print complete address alongside disassembly\n\
228 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
229 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
230 --special-syms Include special symbols in symbol dumps\n\
232 list_supported_targets (program_name
, stream
);
233 list_supported_architectures (program_name
, stream
);
235 disassembler_usage (stream
);
237 if (REPORT_BUGS_TO
[0] && status
== 0)
238 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
242 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
246 OPTION_START_ADDRESS
,
251 static struct option long_options
[]=
253 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
254 {"all-headers", no_argument
, NULL
, 'x'},
255 {"private-headers", no_argument
, NULL
, 'p'},
256 {"architecture", required_argument
, NULL
, 'm'},
257 {"archive-headers", no_argument
, NULL
, 'a'},
258 {"debugging", no_argument
, NULL
, 'g'},
259 {"debugging-tags", no_argument
, NULL
, 'e'},
260 {"demangle", optional_argument
, NULL
, 'C'},
261 {"disassemble", no_argument
, NULL
, 'd'},
262 {"disassemble-all", no_argument
, NULL
, 'D'},
263 {"disassembler-options", required_argument
, NULL
, 'M'},
264 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
265 {"dynamic-reloc", no_argument
, NULL
, 'R'},
266 {"dynamic-syms", no_argument
, NULL
, 'T'},
267 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
268 {"file-headers", no_argument
, NULL
, 'f'},
269 {"file-start-context", no_argument
, &file_start_context
, 1},
270 {"full-contents", no_argument
, NULL
, 's'},
271 {"headers", no_argument
, NULL
, 'h'},
272 {"help", no_argument
, NULL
, 'H'},
273 {"info", no_argument
, NULL
, 'i'},
274 {"line-numbers", no_argument
, NULL
, 'l'},
275 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
276 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
277 {"reloc", no_argument
, NULL
, 'r'},
278 {"section", required_argument
, NULL
, 'j'},
279 {"section-headers", no_argument
, NULL
, 'h'},
280 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
281 {"source", no_argument
, NULL
, 'S'},
282 {"special-syms", no_argument
, &dump_special_syms
, 1},
283 {"include", required_argument
, NULL
, 'I'},
284 {"dwarf", no_argument
, NULL
, 'W'},
285 {"stabs", no_argument
, NULL
, 'G'},
286 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
287 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
288 {"syms", no_argument
, NULL
, 't'},
289 {"target", required_argument
, NULL
, 'b'},
290 {"version", no_argument
, NULL
, 'V'},
291 {"wide", no_argument
, NULL
, 'w'},
292 {0, no_argument
, 0, 0}
296 nonfatal (const char *msg
)
303 dump_section_header (bfd
*abfd
, asection
*section
,
304 void *ignored ATTRIBUTE_UNUSED
)
307 unsigned int opb
= bfd_octets_per_byte (abfd
);
309 /* Ignore linker created section. See elfNN_ia64_object_p in
311 if (section
->flags
& SEC_LINKER_CREATED
)
314 printf ("%3d %-13s %08lx ", section
->index
,
315 bfd_get_section_name (abfd
, section
),
316 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
317 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
319 bfd_printf_vma (abfd
, section
->lma
);
320 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
321 bfd_get_section_alignment (abfd
, section
));
327 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
329 PF (SEC_HAS_CONTENTS
, "CONTENTS");
330 PF (SEC_ALLOC
, "ALLOC");
331 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
332 PF (SEC_LOAD
, "LOAD");
333 PF (SEC_RELOC
, "RELOC");
334 PF (SEC_READONLY
, "READONLY");
335 PF (SEC_CODE
, "CODE");
336 PF (SEC_DATA
, "DATA");
338 PF (SEC_DEBUGGING
, "DEBUGGING");
339 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
340 PF (SEC_EXCLUDE
, "EXCLUDE");
341 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
342 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
344 PF (SEC_TIC54X_BLOCK
, "BLOCK");
345 PF (SEC_TIC54X_CLINK
, "CLINK");
347 PF (SEC_SMALL_DATA
, "SMALL_DATA");
348 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
349 PF (SEC_COFF_SHARED
, "SHARED");
350 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
351 PF (SEC_GROUP
, "GROUP");
353 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
356 struct coff_comdat_info
*comdat
;
358 switch (section
->flags
& SEC_LINK_DUPLICATES
)
362 case SEC_LINK_DUPLICATES_DISCARD
:
363 ls
= "LINK_ONCE_DISCARD";
365 case SEC_LINK_DUPLICATES_ONE_ONLY
:
366 ls
= "LINK_ONCE_ONE_ONLY";
368 case SEC_LINK_DUPLICATES_SAME_SIZE
:
369 ls
= "LINK_ONCE_SAME_SIZE";
371 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
372 ls
= "LINK_ONCE_SAME_CONTENTS";
375 printf ("%s%s", comma
, ls
);
377 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
379 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
389 dump_headers (bfd
*abfd
)
391 printf (_("Sections:\n"));
394 printf (_("Idx Name Size VMA LMA File off Algn"));
396 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
397 if (bfd_get_arch_size (abfd
) == 32)
398 printf (_("Idx Name Size VMA LMA File off Algn"));
400 printf (_("Idx Name Size VMA LMA File off Algn"));
404 printf (_(" Flags"));
405 if (abfd
->flags
& HAS_LOAD_PAGE
)
409 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
413 slurp_symtab (bfd
*abfd
)
418 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
424 storage
= bfd_get_symtab_upper_bound (abfd
);
426 bfd_fatal (bfd_get_filename (abfd
));
428 sy
= xmalloc (storage
);
430 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
432 bfd_fatal (bfd_get_filename (abfd
));
436 /* Read in the dynamic symbols. */
439 slurp_dynamic_symtab (bfd
*abfd
)
444 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
447 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
449 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
454 bfd_fatal (bfd_get_filename (abfd
));
457 sy
= xmalloc (storage
);
459 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
461 bfd_fatal (bfd_get_filename (abfd
));
465 /* Filter out (in place) symbols that are useless for disassembly.
466 COUNT is the number of elements in SYMBOLS.
467 Return the number of useful symbols. */
470 remove_useless_symbols (asymbol
**symbols
, long count
)
472 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
476 asymbol
*sym
= *in_ptr
++;
478 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
480 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
482 if (bfd_is_und_section (sym
->section
)
483 || bfd_is_com_section (sym
->section
))
488 return out_ptr
- symbols
;
491 /* Sort symbols into value order. */
494 compare_symbols (const void *ap
, const void *bp
)
496 const asymbol
*a
= * (const asymbol
**) ap
;
497 const asymbol
*b
= * (const asymbol
**) bp
;
507 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
509 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
512 if (a
->section
> b
->section
)
514 else if (a
->section
< b
->section
)
517 an
= bfd_asymbol_name (a
);
518 bn
= bfd_asymbol_name (b
);
522 /* The symbols gnu_compiled and gcc2_compiled convey no real
523 information, so put them after other symbols with the same value. */
524 af
= (strstr (an
, "gnu_compiled") != NULL
525 || strstr (an
, "gcc2_compiled") != NULL
);
526 bf
= (strstr (bn
, "gnu_compiled") != NULL
527 || strstr (bn
, "gcc2_compiled") != NULL
);
534 /* We use a heuristic for the file name, to try to sort it after
535 more useful symbols. It may not work on non Unix systems, but it
536 doesn't really matter; the only difference is precisely which
537 symbol names get printed. */
539 #define file_symbol(s, sn, snl) \
540 (((s)->flags & BSF_FILE) != 0 \
541 || ((sn)[(snl) - 2] == '.' \
542 && ((sn)[(snl) - 1] == 'o' \
543 || (sn)[(snl) - 1] == 'a')))
545 af
= file_symbol (a
, an
, anl
);
546 bf
= file_symbol (b
, bn
, bnl
);
553 /* Try to sort global symbols before local symbols before function
554 symbols before debugging symbols. */
559 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
561 if ((aflags
& BSF_DEBUGGING
) != 0)
566 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
568 if ((aflags
& BSF_FUNCTION
) != 0)
573 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
575 if ((aflags
& BSF_LOCAL
) != 0)
580 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
582 if ((aflags
& BSF_GLOBAL
) != 0)
588 /* Symbols that start with '.' might be section names, so sort them
589 after symbols that don't start with '.'. */
590 if (an
[0] == '.' && bn
[0] != '.')
592 if (an
[0] != '.' && bn
[0] == '.')
595 /* Finally, if we can't distinguish them in any other way, try to
596 get consistent results by sorting the symbols by name. */
597 return strcmp (an
, bn
);
600 /* Sort relocs into address order. */
603 compare_relocs (const void *ap
, const void *bp
)
605 const arelent
*a
= * (const arelent
**) ap
;
606 const arelent
*b
= * (const arelent
**) bp
;
608 if (a
->address
> b
->address
)
610 else if (a
->address
< b
->address
)
613 /* So that associated relocations tied to the same address show up
614 in the correct order, we don't do any further sorting. */
623 /* Print an address (VMA) to the output stream in INFO.
624 If SKIP_ZEROES is TRUE, omit leading zeroes. */
627 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
628 bfd_boolean skip_zeroes
)
632 struct objdump_disasm_info
*aux
;
634 aux
= (struct objdump_disasm_info
*) info
->application_data
;
635 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
640 for (p
= buf
; *p
== '0'; ++p
)
645 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
648 /* Print the name of a symbol. */
651 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
658 name
= bfd_asymbol_name (sym
);
659 if (do_demangle
&& name
[0] != '\0')
661 /* Demangle the name. */
662 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
668 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
676 /* Locate a symbol given a bfd and a section (from INFO->application_data),
677 and a VMA. If INFO->application_data->require_sec is TRUE, then always
678 require the symbol to be in the section. Returns NULL if there is no
679 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
680 of the symbol in sorted_syms. */
683 find_symbol_for_address (bfd_vma vma
,
684 struct disassemble_info
*info
,
687 /* @@ Would it speed things up to cache the last two symbols returned,
688 and maybe their address ranges? For many processors, only one memory
689 operand can be present at a time, so the 2-entry cache wouldn't be
690 constantly churned by code doing heavy memory accesses. */
692 /* Indices in `sorted_syms'. */
694 long max
= sorted_symcount
;
696 struct objdump_disasm_info
*aux
;
700 bfd_boolean want_section
;
702 if (sorted_symcount
< 1)
705 aux
= (struct objdump_disasm_info
*) info
->application_data
;
708 opb
= bfd_octets_per_byte (abfd
);
710 /* Perform a binary search looking for the closest symbol to the
711 required value. We are searching the range (min, max]. */
712 while (min
+ 1 < max
)
716 thisplace
= (max
+ min
) / 2;
717 sym
= sorted_syms
[thisplace
];
719 if (bfd_asymbol_value (sym
) > vma
)
721 else if (bfd_asymbol_value (sym
) < vma
)
730 /* The symbol we want is now in min, the low end of the range we
731 were searching. If there are several symbols with the same
732 value, we want the first one. */
735 && (bfd_asymbol_value (sorted_syms
[thisplace
])
736 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
739 /* If the file is relocatable, and the symbol could be from this
740 section, prefer a symbol from this section over symbols from
741 others, even if the other symbol's value might be closer.
743 Note that this may be wrong for some symbol references if the
744 sections have overlapping memory ranges, but in that case there's
745 no way to tell what's desired without looking at the relocation
748 Also give the target a chance to reject symbols. */
749 want_section
= (aux
->require_sec
750 || ((abfd
->flags
& HAS_RELOC
) != 0
751 && vma
>= bfd_get_section_vma (abfd
, sec
)
752 && vma
< (bfd_get_section_vma (abfd
, sec
)
753 + bfd_section_size (abfd
, sec
) / opb
)));
754 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
755 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
760 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
762 if (bfd_asymbol_value (sorted_syms
[i
])
763 != bfd_asymbol_value (sorted_syms
[thisplace
]))
768 newplace
= sorted_symcount
;
772 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
773 && info
->symbol_is_valid (sorted_syms
[i
], info
))
775 if (newplace
== sorted_symcount
)
778 if (bfd_asymbol_value (sorted_syms
[i
])
779 != bfd_asymbol_value (sorted_syms
[newplace
]))
782 /* Remember this symbol and keep searching until we reach
783 an earlier address. */
788 if (newplace
!= sorted_symcount
)
789 thisplace
= newplace
;
792 /* We didn't find a good symbol with a smaller value.
793 Look for one with a larger value. */
794 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
796 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
797 && info
->symbol_is_valid (sorted_syms
[i
], info
))
805 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
806 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
807 /* There is no suitable symbol. */
814 return sorted_syms
[thisplace
];
817 /* Print an address and the offset to the nearest symbol. */
820 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
821 bfd_vma vma
, struct disassemble_info
*info
,
822 bfd_boolean skip_zeroes
)
824 objdump_print_value (vma
, info
, skip_zeroes
);
830 (*info
->fprintf_func
) (info
->stream
, " <%s",
831 bfd_get_section_name (abfd
, sec
));
832 secaddr
= bfd_get_section_vma (abfd
, sec
);
835 (*info
->fprintf_func
) (info
->stream
, "-0x");
836 objdump_print_value (secaddr
- vma
, info
, TRUE
);
838 else if (vma
> secaddr
)
840 (*info
->fprintf_func
) (info
->stream
, "+0x");
841 objdump_print_value (vma
- secaddr
, info
, TRUE
);
843 (*info
->fprintf_func
) (info
->stream
, ">");
847 (*info
->fprintf_func
) (info
->stream
, " <");
848 objdump_print_symname (abfd
, info
, sym
);
849 if (bfd_asymbol_value (sym
) > vma
)
851 (*info
->fprintf_func
) (info
->stream
, "-0x");
852 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
854 else if (vma
> bfd_asymbol_value (sym
))
856 (*info
->fprintf_func
) (info
->stream
, "+0x");
857 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
859 (*info
->fprintf_func
) (info
->stream
, ">");
863 /* Print an address (VMA), symbolically if possible.
864 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
867 objdump_print_addr (bfd_vma vma
,
868 struct disassemble_info
*info
,
869 bfd_boolean skip_zeroes
)
871 struct objdump_disasm_info
*aux
;
872 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
873 bfd_boolean skip_find
= FALSE
;
875 if (sorted_symcount
< 1)
877 (*info
->fprintf_func
) (info
->stream
, "0x");
878 objdump_print_value (vma
, info
, skip_zeroes
);
882 aux
= (struct objdump_disasm_info
*) info
->application_data
;
884 if (aux
->reloc
!= NULL
885 && aux
->reloc
->sym_ptr_ptr
!= NULL
886 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
888 sym
= * aux
->reloc
->sym_ptr_ptr
;
890 /* Adjust the vma to the reloc. */
891 vma
+= bfd_asymbol_value (sym
);
893 if (bfd_is_und_section (bfd_get_section (sym
)))
898 sym
= find_symbol_for_address (vma
, info
, NULL
);
900 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
904 /* Print VMA to INFO. This function is passed to the disassembler
908 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
910 objdump_print_addr (vma
, info
, ! prefix_addresses
);
913 /* Determine if the given address has a symbol associated with it. */
916 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
920 sym
= find_symbol_for_address (vma
, info
, NULL
);
922 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
925 /* Hold the last function name and the last line number we displayed
928 static char *prev_functionname
;
929 static unsigned int prev_line
;
931 /* We keep a list of all files that we have seen when doing a
932 disassembly with source, so that we know how much of the file to
933 display. This can be important for inlined functions. */
935 struct print_file_list
937 struct print_file_list
*next
;
938 const char *filename
;
942 const char **linemap
;
948 static struct print_file_list
*print_files
;
950 /* The number of preceding context lines to show when we start
951 displaying a file for the first time. */
953 #define SHOW_PRECEDING_CONTEXT_LINES (5)
955 /* Read a complete file into memory. */
958 slurp_file (const char *fn
, size_t *size
)
961 int ps
= getpagesize ();
966 int fd
= open (fn
, O_RDONLY
);
970 if (fstat (fd
, &st
) < 0)
974 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
975 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
976 if (map
!= (char *)-1L)
982 map
= malloc (*size
);
983 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
992 #define line_map_decrease 5
994 /* Precompute array of lines for a mapped file. */
997 index_file (const char *map
, size_t size
, unsigned int *maxline
)
999 const char *p
, *lstart
, *end
;
1000 int chars_per_line
= 45; /* First iteration will use 40. */
1001 unsigned int lineno
;
1002 const char **linemap
= NULL
;
1003 unsigned long line_map_size
= 0;
1009 for (p
= map
; p
< end
; p
++)
1013 if (p
+ 1 < end
&& p
[1] == '\r')
1016 else if (*p
== '\r')
1018 if (p
+ 1 < end
&& p
[1] == '\n')
1024 /* End of line found. */
1026 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1028 unsigned long newsize
;
1030 chars_per_line
-= line_map_decrease
;
1031 if (chars_per_line
<= 1)
1033 line_map_size
= size
/ chars_per_line
+ 1;
1034 if (line_map_size
< lineno
+ 1)
1035 line_map_size
= lineno
+ 1;
1036 newsize
= line_map_size
* sizeof (char *);
1037 linemap
= xrealloc (linemap
, newsize
);
1040 linemap
[lineno
++] = lstart
;
1048 /* Tries to open MODNAME, and if successful adds a node to print_files
1049 linked list and returns that node. Returns NULL on failure. */
1051 static struct print_file_list
*
1052 try_print_file_open (const char *origname
, const char *modname
)
1054 struct print_file_list
*p
;
1056 p
= xmalloc (sizeof (struct print_file_list
));
1058 p
->map
= slurp_file (modname
, &p
->mapsize
);
1065 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1067 p
->filename
= origname
;
1068 p
->modname
= modname
;
1069 p
->next
= print_files
;
1075 /* If the the source file, as described in the symtab, is not found
1076 try to locate it in one of the paths specified with -I
1077 If found, add location to print_files linked list. */
1079 static struct print_file_list
*
1080 update_source_path (const char *filename
)
1082 struct print_file_list
*p
;
1086 if (filename
== NULL
)
1089 p
= try_print_file_open (filename
, filename
);
1093 if (include_path_count
== 0)
1096 /* Get the name of the file. */
1097 fname
= strrchr (filename
, '/');
1098 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1100 /* We could have a mixed forward/back slash case. */
1101 char *backslash
= strrchr (filename
, '\\');
1102 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1104 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1105 fname
= filename
+ 1;
1113 /* If file exists under a new path, we need to add it to the list
1114 so that show_line knows about it. */
1115 for (i
= 0; i
< include_path_count
; i
++)
1117 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1119 p
= try_print_file_open (filename
, modname
);
1129 /* Print a source file line. */
1132 print_line (struct print_file_list
*p
, unsigned int line
)
1138 if (line
>= p
->maxline
)
1140 l
= p
->linemap
[line
];
1141 /* Test fwrite return value to quiet glibc warning. */
1142 len
= strcspn (l
, "\n\r");
1143 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1147 /* Print a range of source code lines. */
1150 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1154 while (start
<= end
)
1156 print_line (p
, start
);
1161 /* Show the line number, or the source line, in a disassembly
1165 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1167 const char *filename
;
1168 const char *functionname
;
1171 if (! with_line_numbers
&& ! with_source_code
)
1174 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1175 &functionname
, &line
))
1178 if (filename
!= NULL
&& *filename
== '\0')
1180 if (functionname
!= NULL
&& *functionname
== '\0')
1181 functionname
= NULL
;
1183 if (with_line_numbers
)
1185 if (functionname
!= NULL
1186 && (prev_functionname
== NULL
1187 || strcmp (functionname
, prev_functionname
) != 0))
1188 printf ("%s():\n", functionname
);
1189 if (line
> 0 && line
!= prev_line
)
1190 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1193 if (with_source_code
1197 struct print_file_list
**pp
, *p
;
1200 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1201 if (strcmp ((*pp
)->filename
, filename
) == 0)
1206 p
= update_source_path (filename
);
1208 if (p
!= NULL
&& line
!= p
->last_line
)
1210 if (file_start_context
&& p
->first
)
1214 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1217 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1218 l
= p
->last_line
+ 1;
1220 dump_lines (p
, l
, line
);
1221 p
->last_line
= line
;
1226 if (functionname
!= NULL
1227 && (prev_functionname
== NULL
1228 || strcmp (functionname
, prev_functionname
) != 0))
1230 if (prev_functionname
!= NULL
)
1231 free (prev_functionname
);
1232 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1233 strcpy (prev_functionname
, functionname
);
1236 if (line
> 0 && line
!= prev_line
)
1240 /* Pseudo FILE object for strings. */
1248 /* sprintf to a "stream". */
1250 static int ATTRIBUTE_PRINTF_2
1251 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1258 size_t space
= f
->alloc
- f
->pos
;
1260 va_start (args
, format
);
1261 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1267 f
->alloc
= (f
->alloc
+ n
) * 2;
1268 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1275 /* Returns TRUE if the specified section should be dumped. */
1278 process_section_p (asection
* section
)
1285 for (i
= 0; i
< only_used
; i
++)
1286 if (strcmp (only
[i
], section
->name
) == 0)
1293 /* The number of zeroes we want to see before we start skipping them.
1294 The number is arbitrarily chosen. */
1296 #define DEFAULT_SKIP_ZEROES 8
1298 /* The number of zeroes to skip at the end of a section. If the
1299 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1300 SKIP_ZEROES, they will be disassembled. If there are fewer than
1301 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1302 attempt to avoid disassembling zeroes inserted by section
1305 #define DEFAULT_SKIP_ZEROES_AT_END 3
1307 /* Disassemble some data in memory between given values. */
1310 disassemble_bytes (struct disassemble_info
* info
,
1311 disassembler_ftype disassemble_fn
,
1314 bfd_vma start_offset
,
1315 bfd_vma stop_offset
,
1318 arelent
** relppend
)
1320 struct objdump_disasm_info
*aux
;
1322 int octets_per_line
;
1323 bfd_boolean done_dot
;
1324 int skip_addr_chars
;
1325 bfd_vma addr_offset
;
1326 unsigned int opb
= info
->octets_per_byte
;
1327 unsigned int skip_zeroes
= info
->skip_zeroes
;
1328 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1332 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1336 sfile
.buffer
= xmalloc (sfile
.alloc
);
1340 octets_per_line
= 4;
1342 octets_per_line
= 16;
1344 /* Figure out how many characters to skip at the start of an
1345 address, to make the disassembly look nicer. We discard leading
1346 zeroes in chunks of 4, ensuring that there is always a leading
1348 skip_addr_chars
= 0;
1349 if (! prefix_addresses
)
1357 + bfd_section_size (section
->owner
, section
) / opb
));
1359 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1362 skip_addr_chars
+= 4;
1367 info
->insn_info_valid
= 0;
1370 addr_offset
= start_offset
;
1371 while (addr_offset
< stop_offset
)
1374 bfd_boolean need_nl
= FALSE
;
1375 int previous_octets
;
1377 /* Remember the length of the previous instruction. */
1378 previous_octets
= octets
;
1381 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1383 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1386 if (! disassemble_zeroes
1387 && (info
->insn_info_valid
== 0
1388 || info
->branch_delay_insns
== 0)
1389 && (z
- addr_offset
* opb
>= skip_zeroes
1390 || (z
== stop_offset
* opb
&&
1391 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1395 /* If there are more nonzero octets to follow, we only skip
1396 zeroes in multiples of 4, to try to avoid running over
1397 the start of an instruction which happens to start with
1399 if (z
!= stop_offset
* opb
)
1400 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1402 octets
= z
- addr_offset
* opb
;
1412 if (with_line_numbers
|| with_source_code
)
1413 show_line (aux
->abfd
, section
, addr_offset
);
1415 if (! prefix_addresses
)
1419 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1420 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1424 printf ("%s:\t", buf
+ skip_addr_chars
);
1428 aux
->require_sec
= TRUE
;
1429 objdump_print_address (section
->vma
+ addr_offset
, info
);
1430 aux
->require_sec
= FALSE
;
1437 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1438 info
->stream
= &sfile
;
1439 info
->bytes_per_line
= 0;
1440 info
->bytes_per_chunk
= 0;
1443 if (info
->disassembler_needs_relocs
1444 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1445 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1446 && *relppp
< relppend
)
1448 bfd_signed_vma distance_to_rel
;
1450 distance_to_rel
= (**relppp
)->address
1451 - (rel_offset
+ addr_offset
);
1453 /* Check to see if the current reloc is associated with
1454 the instruction that we are about to disassemble. */
1455 if (distance_to_rel
== 0
1456 /* FIXME: This is wrong. We are trying to catch
1457 relocs that are addressed part way through the
1458 current instruction, as might happen with a packed
1459 VLIW instruction. Unfortunately we do not know the
1460 length of the current instruction since we have not
1461 disassembled it yet. Instead we take a guess based
1462 upon the length of the previous instruction. The
1463 proper solution is to have a new target-specific
1464 disassembler function which just returns the length
1465 of an instruction at a given address without trying
1466 to display its disassembly. */
1467 || (distance_to_rel
> 0
1468 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1470 info
->flags
= INSN_HAS_RELOC
;
1471 aux
->reloc
= **relppp
;
1477 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1478 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1479 info
->stream
= stdout
;
1480 if (info
->bytes_per_line
!= 0)
1481 octets_per_line
= info
->bytes_per_line
;
1485 printf ("%s\n", sfile
.buffer
);
1493 octets
= octets_per_line
;
1494 if (addr_offset
+ octets
/ opb
> stop_offset
)
1495 octets
= (stop_offset
- addr_offset
) * opb
;
1497 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1499 if (ISPRINT (data
[j
]))
1500 buf
[j
- addr_offset
* opb
] = data
[j
];
1502 buf
[j
- addr_offset
* opb
] = '.';
1504 buf
[j
- addr_offset
* opb
] = '\0';
1507 if (prefix_addresses
1509 : show_raw_insn
>= 0)
1513 /* If ! prefix_addresses and ! wide_output, we print
1514 octets_per_line octets per line. */
1516 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1517 pb
= octets_per_line
;
1519 if (info
->bytes_per_chunk
)
1520 bpc
= info
->bytes_per_chunk
;
1524 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1528 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1530 for (k
= bpc
- 1; k
>= 0; k
--)
1531 printf ("%02x", (unsigned) data
[j
+ k
]);
1536 for (k
= 0; k
< bpc
; k
++)
1537 printf ("%02x", (unsigned) data
[j
+ k
]);
1542 for (; pb
< octets_per_line
; pb
+= bpc
)
1546 for (k
= 0; k
< bpc
; k
++)
1551 /* Separate raw data from instruction by extra space. */
1561 printf ("%s", sfile
.buffer
);
1563 if (prefix_addresses
1565 : show_raw_insn
>= 0)
1573 j
= addr_offset
* opb
+ pb
;
1575 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1576 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1580 printf ("%s:\t", buf
+ skip_addr_chars
);
1582 pb
+= octets_per_line
;
1585 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1589 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1591 for (k
= bpc
- 1; k
>= 0; k
--)
1592 printf ("%02x", (unsigned) data
[j
+ k
]);
1597 for (k
= 0; k
< bpc
; k
++)
1598 printf ("%02x", (unsigned) data
[j
+ k
]);
1611 while ((*relppp
) < relppend
1612 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1614 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1625 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1628 if (q
->howto
== NULL
)
1629 printf (": *unknown*\t");
1630 else if (q
->howto
->name
)
1631 printf (": %s\t", q
->howto
->name
);
1633 printf (": %d\t", q
->howto
->type
);
1635 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1636 printf ("*unknown*");
1639 const char *sym_name
;
1641 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1642 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1643 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1648 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1649 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1650 if (sym_name
== NULL
|| *sym_name
== '\0')
1651 sym_name
= "*unknown*";
1652 printf ("%s", sym_name
);
1659 objdump_print_value (q
->addend
, info
, TRUE
);
1671 addr_offset
+= octets
/ opb
;
1674 free (sfile
.buffer
);
1678 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1680 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1681 struct objdump_disasm_info
* paux
;
1682 unsigned int opb
= pinfo
->octets_per_byte
;
1683 bfd_byte
* data
= NULL
;
1684 bfd_size_type datasize
= 0;
1685 arelent
** rel_pp
= NULL
;
1686 arelent
** rel_ppstart
= NULL
;
1687 arelent
** rel_ppend
;
1688 unsigned long stop_offset
;
1689 asymbol
* sym
= NULL
;
1693 unsigned long addr_offset
;
1695 /* Sections that do not contain machine
1696 code are not normally disassembled. */
1697 if (! disassemble_all
1699 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1700 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1703 if (! process_section_p (section
))
1706 datasize
= bfd_get_section_size (section
);
1710 /* Decide which set of relocs to use. Load them if necessary. */
1711 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1712 if (paux
->dynrelbuf
)
1714 rel_pp
= paux
->dynrelbuf
;
1715 rel_count
= paux
->dynrelcount
;
1716 /* Dynamic reloc addresses are absolute, non-dynamic are section
1717 relative. REL_OFFSET specifies the reloc address corresponding
1718 to the start of this section. */
1719 rel_offset
= section
->vma
;
1727 if ((section
->flags
& SEC_RELOC
) != 0
1728 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1732 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1734 bfd_fatal (bfd_get_filename (abfd
));
1738 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1739 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1741 bfd_fatal (bfd_get_filename (abfd
));
1743 /* Sort the relocs by address. */
1744 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1749 rel_ppend
= rel_pp
+ rel_count
;
1751 data
= xmalloc (datasize
);
1753 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1755 paux
->sec
= section
;
1756 pinfo
->buffer
= data
;
1757 pinfo
->buffer_vma
= section
->vma
;
1758 pinfo
->buffer_length
= datasize
;
1759 pinfo
->section
= section
;
1761 if (start_address
== (bfd_vma
) -1
1762 || start_address
< pinfo
->buffer_vma
)
1765 addr_offset
= start_address
- pinfo
->buffer_vma
;
1767 if (stop_address
== (bfd_vma
) -1)
1768 stop_offset
= datasize
/ opb
;
1771 if (stop_address
< pinfo
->buffer_vma
)
1774 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1775 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1776 stop_offset
= pinfo
->buffer_length
/ opb
;
1779 /* Skip over the relocs belonging to addresses below the
1781 while (rel_pp
< rel_ppend
1782 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1785 printf (_("Disassembly of section %s:\n"), section
->name
);
1787 /* Find the nearest symbol forwards from our current position. */
1788 paux
->require_sec
= TRUE
;
1789 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1790 paux
->require_sec
= FALSE
;
1792 /* Disassemble a block of instructions up to the address associated with
1793 the symbol we have just found. Then print the symbol and find the
1794 next symbol on. Repeat until we have disassembled the entire section
1795 or we have reached the end of the address range we are interested in. */
1796 while (addr_offset
< stop_offset
)
1800 unsigned long nextstop_offset
;
1803 addr
= section
->vma
+ addr_offset
;
1805 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1810 (x
< sorted_symcount
1811 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1815 pinfo
->symbols
= sorted_syms
+ place
;
1816 pinfo
->num_symbols
= x
- place
;
1817 pinfo
->symtab_pos
= place
;
1821 pinfo
->symbols
= NULL
;
1822 pinfo
->num_symbols
= 0;
1823 pinfo
->symtab_pos
= -1;
1826 if (! prefix_addresses
)
1828 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1829 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1831 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1834 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1836 else if (sym
== NULL
)
1840 #define is_valid_next_sym(SYM) \
1841 ((SYM)->section == section \
1842 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1843 && pinfo->symbol_is_valid (SYM, pinfo))
1845 /* Search forward for the next appropriate symbol in
1846 SECTION. Note that all the symbols are sorted
1847 together into one big array, and that some sections
1848 may have overlapping addresses. */
1849 while (place
< sorted_symcount
1850 && ! is_valid_next_sym (sorted_syms
[place
]))
1853 if (place
>= sorted_symcount
)
1856 nextsym
= sorted_syms
[place
];
1859 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1860 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1861 else if (nextsym
== NULL
)
1862 nextstop_offset
= stop_offset
;
1864 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1866 if (nextstop_offset
> stop_offset
)
1867 nextstop_offset
= stop_offset
;
1869 /* If a symbol is explicitly marked as being an object
1870 rather than a function, just dump the bytes without
1871 disassembling them. */
1874 || bfd_asymbol_value (sym
) > addr
1875 || ((sym
->flags
& BSF_OBJECT
) == 0
1876 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1878 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1880 || (sym
->flags
& BSF_FUNCTION
) != 0)
1885 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1886 addr_offset
, nextstop_offset
,
1887 rel_offset
, &rel_pp
, rel_ppend
);
1889 addr_offset
= nextstop_offset
;
1895 if (rel_ppstart
!= NULL
)
1899 /* Disassemble the contents of an object file. */
1902 disassemble_data (bfd
*abfd
)
1904 struct disassemble_info disasm_info
;
1905 struct objdump_disasm_info aux
;
1909 prev_functionname
= NULL
;
1912 /* We make a copy of syms to sort. We don't want to sort syms
1913 because that will screw up the relocs. */
1914 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1915 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1916 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1917 sorted_symcount
* sizeof (asymbol
*));
1919 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1921 for (i
= 0; i
< synthcount
; ++i
)
1923 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1927 /* Sort the symbols into section and symbol order. */
1928 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1930 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1932 disasm_info
.application_data
= (void *) &aux
;
1934 aux
.require_sec
= FALSE
;
1935 aux
.dynrelbuf
= NULL
;
1936 aux
.dynrelcount
= 0;
1939 disasm_info
.print_address_func
= objdump_print_address
;
1940 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1942 if (machine
!= NULL
)
1944 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1947 fatal (_("Can't use supplied machine %s"), machine
);
1949 abfd
->arch_info
= info
;
1952 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1954 struct bfd_target
*xvec
;
1956 xvec
= xmalloc (sizeof (struct bfd_target
));
1957 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1958 xvec
->byteorder
= endian
;
1962 /* Use libopcodes to locate a suitable disassembler. */
1963 aux
.disassemble_fn
= disassembler (abfd
);
1964 if (!aux
.disassemble_fn
)
1966 non_fatal (_("Can't disassemble for architecture %s\n"),
1967 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1972 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1973 disasm_info
.arch
= bfd_get_arch (abfd
);
1974 disasm_info
.mach
= bfd_get_mach (abfd
);
1975 disasm_info
.disassembler_options
= disassembler_options
;
1976 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1977 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1978 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1979 disasm_info
.disassembler_needs_relocs
= FALSE
;
1981 if (bfd_big_endian (abfd
))
1982 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1983 else if (bfd_little_endian (abfd
))
1984 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1986 /* ??? Aborting here seems too drastic. We could default to big or little
1988 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1990 /* Allow the target to customize the info structure. */
1991 disassemble_init_for_target (& disasm_info
);
1993 /* Pre-load the dynamic relocs if we are going
1994 to be dumping them along with the disassembly. */
1995 if (dump_dynamic_reloc_info
)
1997 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2000 bfd_fatal (bfd_get_filename (abfd
));
2004 aux
.dynrelbuf
= xmalloc (relsize
);
2005 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2008 if (aux
.dynrelcount
< 0)
2009 bfd_fatal (bfd_get_filename (abfd
));
2011 /* Sort the relocs by address. */
2012 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2016 disasm_info
.symtab
= sorted_syms
;
2017 disasm_info
.symtab_size
= sorted_symcount
;
2019 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2021 if (aux
.dynrelbuf
!= NULL
)
2022 free (aux
.dynrelbuf
);
2027 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2029 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2034 /* If it is already loaded, do nothing. */
2035 if (section
->start
!= NULL
)
2038 /* Locate the debug section. */
2039 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2043 /* Compute a bias to be added to offsets found within the DWARF debug
2044 information. These offsets are meant to be relative to the start of
2045 the dwarf section, and hence the bias should be 0. For MACH-O however
2046 a dwarf section is really just a region of a much larger section and so
2047 the bias is the address of the start of that area within the larger
2048 section. This test is important for PE and COFF based targets which
2049 use DWARF debug information, since unlike ELF, they do not allow the
2050 dwarf sections to be placed at address 0. */
2051 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2052 section
->address
= bfd_get_section_vma (abfd
, sec
);
2054 section
->address
= 0;
2056 section
->size
= bfd_get_section_size (sec
);
2057 section
->start
= xmalloc (section
->size
);
2059 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2060 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2065 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2070 free_debug_section (debug
);
2071 printf (_("\nCan't get contents for section '%s'.\n"),
2079 free_debug_section (enum dwarf_section_display_enum debug
)
2081 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2083 if (section
->start
== NULL
)
2086 free ((char *) section
->start
);
2087 section
->start
= NULL
;
2088 section
->address
= 0;
2093 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2094 void *arg ATTRIBUTE_UNUSED
)
2096 const char *name
= bfd_get_section_name (abfd
, section
);
2098 enum dwarf_section_display_enum i
;
2100 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2101 match
= ".debug_info";
2105 for (i
= 0; i
< max
; i
++)
2106 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2108 if (!debug_displays
[i
].eh_frame
)
2110 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2112 if (load_debug_section (i
, abfd
))
2114 debug_displays
[i
].display (sec
, abfd
);
2116 if (i
!= info
&& i
!= abbrev
)
2117 free_debug_section (i
);
2124 static const char *mach_o_dwarf_sections
[] = {
2125 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2126 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2127 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2128 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2129 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2130 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2131 ".eh_frame", /* .eh_frame */
2132 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2133 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2134 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2135 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2136 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2137 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2138 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2139 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2140 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2143 static const char *generic_dwarf_sections
[max
];
2146 check_mach_o_dwarf (bfd
*abfd
)
2148 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2149 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2150 enum dwarf_section_display_enum i
;
2152 if (generic_dwarf_sections
[0] == NULL
)
2153 for (i
= 0; i
< max
; i
++)
2154 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2156 if (old_flavour
!= current_flavour
)
2158 if (current_flavour
== bfd_target_mach_o_flavour
)
2159 for (i
= 0; i
< max
; i
++)
2160 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2161 else if (old_flavour
== bfd_target_mach_o_flavour
)
2162 for (i
= 0; i
< max
; i
++)
2163 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2165 old_flavour
= current_flavour
;
2169 /* Dump the dwarf debugging information. */
2172 dump_dwarf (bfd
*abfd
)
2174 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2176 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2177 targets will return 64. */
2178 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2180 if (bfd_big_endian (abfd
))
2181 byte_get
= byte_get_big_endian
;
2182 else if (bfd_little_endian (abfd
))
2183 byte_get
= byte_get_little_endian
;
2187 check_mach_o_dwarf (abfd
);
2189 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2191 free_debug_memory ();
2194 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2195 it. Return NULL on failure. */
2198 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2204 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2205 if (stabsect
== NULL
)
2207 printf (_("No %s section present\n\n"), sect_name
);
2211 size
= bfd_section_size (abfd
, stabsect
);
2212 contents
= xmalloc (size
);
2214 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2216 non_fatal (_("Reading %s section of %s failed: %s"),
2217 sect_name
, bfd_get_filename (abfd
),
2218 bfd_errmsg (bfd_get_error ()));
2229 /* Stabs entries use a 12 byte format:
2230 4 byte string table index
2232 1 byte stab other field
2233 2 byte stab desc field
2235 FIXME: This will have to change for a 64 bit object format. */
2237 #define STRDXOFF (0)
2239 #define OTHEROFF (5)
2242 #define STABSIZE (12)
2244 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2245 using string table section STRSECT_NAME (in `strtab'). */
2248 print_section_stabs (bfd
*abfd
,
2249 const char *stabsect_name
,
2250 unsigned *string_offset_ptr
)
2253 unsigned file_string_table_offset
= 0;
2254 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2255 bfd_byte
*stabp
, *stabs_end
;
2258 stabs_end
= stabp
+ stab_size
;
2260 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2261 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2263 /* Loop through all symbols and print them.
2265 We start the index at -1 because there is a dummy symbol on
2266 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2267 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2271 unsigned char type
, other
;
2272 unsigned short desc
;
2275 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2276 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2277 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2278 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2279 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2281 printf ("\n%-6d ", i
);
2282 /* Either print the stab name, or, if unnamed, print its number
2283 again (makes consistent formatting for tools like awk). */
2284 name
= bfd_get_stab_name (type
);
2286 printf ("%-6s", name
);
2287 else if (type
== N_UNDF
)
2290 printf ("%-6d", type
);
2291 printf (" %-6d %-6d ", other
, desc
);
2292 bfd_printf_vma (abfd
, value
);
2293 printf (" %-6lu", strx
);
2295 /* Symbols with type == 0 (N_UNDF) specify the length of the
2296 string table associated with this file. We use that info
2297 to know how to relocate the *next* file's string table indices. */
2300 file_string_table_offset
= next_file_string_table_offset
;
2301 next_file_string_table_offset
+= value
;
2305 /* Using the (possibly updated) string table offset, print the
2306 string (if any) associated with this symbol. */
2307 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2308 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2314 *string_offset_ptr
= next_file_string_table_offset
;
2319 const char * section_name
;
2320 const char * string_section_name
;
2321 unsigned string_offset
;
2326 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2329 stab_section_names
* sought
= (stab_section_names
*) names
;
2331 /* Check for section names for which stabsect_name is a prefix, to
2332 handle .stab.N, etc. */
2333 len
= strlen (sought
->section_name
);
2335 /* If the prefix matches, and the files section name ends with a
2336 nul or a digit, then we match. I.e., we want either an exact
2337 match or a section followed by a number. */
2338 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2339 && (section
->name
[len
] == 0
2340 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2343 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2348 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2351 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2357 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2359 stab_section_names s
;
2361 s
.section_name
= stabsect_name
;
2362 s
.string_section_name
= strsect_name
;
2363 s
.string_offset
= 0;
2365 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2371 /* Dump the any sections containing stabs debugging information. */
2374 dump_stabs (bfd
*abfd
)
2376 dump_stabs_section (abfd
, ".stab", ".stabstr");
2377 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2378 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2379 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2383 dump_bfd_header (bfd
*abfd
)
2387 printf (_("architecture: %s, "),
2388 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2389 bfd_get_mach (abfd
)));
2390 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2392 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2393 PF (HAS_RELOC
, "HAS_RELOC");
2394 PF (EXEC_P
, "EXEC_P");
2395 PF (HAS_LINENO
, "HAS_LINENO");
2396 PF (HAS_DEBUG
, "HAS_DEBUG");
2397 PF (HAS_SYMS
, "HAS_SYMS");
2398 PF (HAS_LOCALS
, "HAS_LOCALS");
2399 PF (DYNAMIC
, "DYNAMIC");
2400 PF (WP_TEXT
, "WP_TEXT");
2401 PF (D_PAGED
, "D_PAGED");
2402 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2403 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2404 printf (_("\nstart address 0x"));
2405 bfd_printf_vma (abfd
, abfd
->start_address
);
2411 dump_bfd_private_header (bfd
*abfd
)
2413 bfd_print_private_bfd_data (abfd
, stdout
);
2417 /* Display a section in hexadecimal format with associated characters.
2418 Each line prefixed by the zero padded address. */
2421 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2424 bfd_size_type datasize
;
2425 bfd_size_type addr_offset
;
2426 bfd_size_type start_offset
;
2427 bfd_size_type stop_offset
;
2428 unsigned int opb
= bfd_octets_per_byte (abfd
);
2429 /* Bytes per line. */
2430 const int onaline
= 16;
2435 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2438 if (! process_section_p (section
))
2441 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2444 printf (_("Contents of section %s:\n"), section
->name
);
2446 data
= xmalloc (datasize
);
2448 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2450 /* Compute the address range to display. */
2451 if (start_address
== (bfd_vma
) -1
2452 || start_address
< section
->vma
)
2455 start_offset
= start_address
- section
->vma
;
2457 if (stop_address
== (bfd_vma
) -1)
2458 stop_offset
= datasize
/ opb
;
2461 if (stop_address
< section
->vma
)
2464 stop_offset
= stop_address
- section
->vma
;
2466 if (stop_offset
> datasize
/ opb
)
2467 stop_offset
= datasize
/ opb
;
2472 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2473 if (strlen (buf
) >= sizeof (buf
))
2477 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2479 count
= strlen (buf
) - count
;
2483 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2484 if (strlen (buf
) >= sizeof (buf
))
2488 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2490 count
= strlen (buf
) - count
;
2494 for (addr_offset
= start_offset
;
2495 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2499 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2500 count
= strlen (buf
);
2501 if ((size_t) count
>= sizeof (buf
))
2505 while (count
< width
)
2510 fputs (buf
+ count
- width
, stdout
);
2513 for (j
= addr_offset
* opb
;
2514 j
< addr_offset
* opb
+ onaline
; j
++)
2516 if (j
< stop_offset
* opb
)
2517 printf ("%02x", (unsigned) (data
[j
]));
2525 for (j
= addr_offset
* opb
;
2526 j
< addr_offset
* opb
+ onaline
; j
++)
2528 if (j
>= stop_offset
* opb
)
2531 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2538 /* Actually display the various requested regions. */
2541 dump_data (bfd
*abfd
)
2543 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2546 /* Should perhaps share code and display with nm? */
2549 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2559 printf ("DYNAMIC SYMBOL TABLE:\n");
2565 printf ("SYMBOL TABLE:\n");
2569 printf (_("no symbols\n"));
2571 for (count
= 0; count
< max
; count
++)
2575 if (*current
== NULL
)
2576 printf (_("no information for symbol number %ld\n"), count
);
2578 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2579 printf (_("could not determine the type of symbol number %ld\n"),
2582 else if (process_section_p ((* current
)->section
)
2583 && (dump_special_syms
2584 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2586 const char *name
= (*current
)->name
;
2588 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2592 /* If we want to demangle the name, we demangle it
2593 here, and temporarily clobber it while calling
2594 bfd_print_symbol. FIXME: This is a gross hack. */
2595 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2597 (*current
)->name
= alloc
;
2598 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2599 bfd_print_symbol_all
);
2602 (*current
)->name
= name
;
2607 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2608 bfd_print_symbol_all
);
2618 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2621 char *last_filename
, *last_functionname
;
2622 unsigned int last_line
;
2624 /* Get column headers lined up reasonably. */
2632 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2633 width
= strlen (buf
) - 7;
2635 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2638 last_filename
= NULL
;
2639 last_functionname
= NULL
;
2642 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2645 const char *filename
, *functionname
;
2647 const char *sym_name
;
2648 const char *section_name
;
2650 if (start_address
!= (bfd_vma
) -1
2651 && q
->address
< start_address
)
2653 if (stop_address
!= (bfd_vma
) -1
2654 && q
->address
> stop_address
)
2657 if (with_line_numbers
2659 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2660 &filename
, &functionname
, &line
))
2662 if (functionname
!= NULL
2663 && (last_functionname
== NULL
2664 || strcmp (functionname
, last_functionname
) != 0))
2666 printf ("%s():\n", functionname
);
2667 if (last_functionname
!= NULL
)
2668 free (last_functionname
);
2669 last_functionname
= xstrdup (functionname
);
2673 && (line
!= last_line
2674 || (filename
!= NULL
2675 && last_filename
!= NULL
2676 && strcmp (filename
, last_filename
) != 0)))
2678 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2680 if (last_filename
!= NULL
)
2681 free (last_filename
);
2682 if (filename
== NULL
)
2683 last_filename
= NULL
;
2685 last_filename
= xstrdup (filename
);
2689 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2691 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2692 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2697 section_name
= NULL
;
2700 bfd_printf_vma (abfd
, q
->address
);
2701 if (q
->howto
== NULL
)
2702 printf (" *unknown* ");
2703 else if (q
->howto
->name
)
2704 printf (" %-16s ", q
->howto
->name
);
2706 printf (" %-16d ", q
->howto
->type
);
2708 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2711 if (section_name
== NULL
)
2712 section_name
= "*unknown*";
2713 printf ("[%s]", section_name
);
2719 bfd_printf_vma (abfd
, q
->addend
);
2727 dump_relocs_in_section (bfd
*abfd
,
2729 void *dummy ATTRIBUTE_UNUSED
)
2735 if ( bfd_is_abs_section (section
)
2736 || bfd_is_und_section (section
)
2737 || bfd_is_com_section (section
)
2738 || (! process_section_p (section
))
2739 || ((section
->flags
& SEC_RELOC
) == 0))
2742 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2744 bfd_fatal (bfd_get_filename (abfd
));
2746 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2750 printf (" (none)\n\n");
2754 relpp
= xmalloc (relsize
);
2755 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2758 bfd_fatal (bfd_get_filename (abfd
));
2759 else if (relcount
== 0)
2760 printf (" (none)\n\n");
2764 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2771 dump_relocs (bfd
*abfd
)
2773 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2777 dump_dynamic_relocs (bfd
*abfd
)
2783 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2785 bfd_fatal (bfd_get_filename (abfd
));
2787 printf ("DYNAMIC RELOCATION RECORDS");
2790 printf (" (none)\n\n");
2793 relpp
= xmalloc (relsize
);
2794 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2797 bfd_fatal (bfd_get_filename (abfd
));
2798 else if (relcount
== 0)
2799 printf (" (none)\n\n");
2803 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2810 /* Creates a table of paths, to search for source files. */
2813 add_include_path (const char *path
)
2817 include_path_count
++;
2818 include_paths
= xrealloc (include_paths
,
2819 include_path_count
* sizeof (*include_paths
));
2820 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2821 if (path
[1] == ':' && path
[2] == 0)
2822 path
= concat (path
, ".", (const char *) 0);
2824 include_paths
[include_path_count
- 1] = path
;
2828 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2832 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2834 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2835 section
->vma
+= adjust_section_vma
;
2837 section
->lma
+= adjust_section_vma
;
2841 /* Dump selected contents of ABFD. */
2844 dump_bfd (bfd
*abfd
)
2846 /* If we are adjusting section VMA's, change them all now. Changing
2847 the BFD information is a hack. However, we must do it, or
2848 bfd_find_nearest_line will not do the right thing. */
2849 if (adjust_section_vma
!= 0)
2851 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2852 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2855 if (! dump_debugging_tags
)
2856 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2859 print_arelt_descr (stdout
, abfd
, TRUE
);
2860 if (dump_file_header
)
2861 dump_bfd_header (abfd
);
2862 if (dump_private_headers
)
2863 dump_bfd_private_header (abfd
);
2864 if (! dump_debugging_tags
)
2866 if (dump_section_headers
)
2867 dump_headers (abfd
);
2873 || dump_dwarf_section_info
)
2874 syms
= slurp_symtab (abfd
);
2875 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2876 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2877 dynsyms
= slurp_dynamic_symtab (abfd
);
2880 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2881 dynsymcount
, dynsyms
, &synthsyms
);
2887 dump_symbols (abfd
, FALSE
);
2888 if (dump_dynamic_symtab
)
2889 dump_symbols (abfd
, TRUE
);
2890 if (dump_dwarf_section_info
)
2892 if (dump_stab_section_info
)
2894 if (dump_reloc_info
&& ! disassemble
)
2896 if (dump_dynamic_reloc_info
&& ! disassemble
)
2897 dump_dynamic_relocs (abfd
);
2898 if (dump_section_contents
)
2901 disassemble_data (abfd
);
2907 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2908 if (dhandle
!= NULL
)
2910 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2912 dump_debugging_tags
? TRUE
: FALSE
))
2914 non_fatal (_("%s: printing debugging information failed"),
2915 bfd_get_filename (abfd
));
2945 display_bfd (bfd
*abfd
)
2949 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2955 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2957 nonfatal (bfd_get_filename (abfd
));
2958 list_matching_formats (matching
);
2963 if (bfd_get_error () != bfd_error_file_not_recognized
)
2965 nonfatal (bfd_get_filename (abfd
));
2969 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2975 nonfatal (bfd_get_filename (abfd
));
2977 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2979 list_matching_formats (matching
);
2985 display_file (char *filename
, char *target
)
2990 if (get_file_size (filename
) < 1)
2996 file
= bfd_openr (filename
, target
);
2999 nonfatal (filename
);
3003 /* If the file is an archive, process all of its elements. */
3004 if (bfd_check_format (file
, bfd_archive
))
3006 bfd
*last_arfile
= NULL
;
3008 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3011 bfd_set_error (bfd_error_no_error
);
3013 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3016 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3017 nonfatal (bfd_get_filename (file
));
3021 display_bfd (arfile
);
3023 if (last_arfile
!= NULL
)
3024 bfd_close (last_arfile
);
3025 last_arfile
= arfile
;
3028 if (last_arfile
!= NULL
)
3029 bfd_close (last_arfile
);
3038 main (int argc
, char **argv
)
3041 char *target
= default_target
;
3042 bfd_boolean seenflag
= FALSE
;
3044 #if defined (HAVE_SETLOCALE)
3045 #if defined (HAVE_LC_MESSAGES)
3046 setlocale (LC_MESSAGES
, "");
3048 setlocale (LC_CTYPE
, "");
3051 bindtextdomain (PACKAGE
, LOCALEDIR
);
3052 textdomain (PACKAGE
);
3054 program_name
= *argv
;
3055 xmalloc_set_program_name (program_name
);
3057 START_PROGRESS (program_name
, 0);
3059 expandargv (&argc
, &argv
);
3062 set_default_bfd_target ();
3064 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3065 long_options
, (int *) 0))
3071 break; /* We've been given a long option. */
3076 if (disassembler_options
)
3077 /* Ignore potential memory leak for now. */
3078 disassembler_options
= concat (disassembler_options
, ",",
3081 disassembler_options
= optarg
;
3084 if (only_used
== only_size
)
3087 only
= xrealloc (only
, only_size
* sizeof (char *));
3089 only
[only_used
++] = optarg
;
3092 with_line_numbers
= TRUE
;
3101 enum demangling_styles style
;
3103 style
= cplus_demangle_name_to_style (optarg
);
3104 if (style
== unknown_demangling
)
3105 fatal (_("unknown demangling style `%s'"),
3108 cplus_demangle_set_style (style
);
3114 case OPTION_ADJUST_VMA
:
3115 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3117 case OPTION_START_ADDRESS
:
3118 start_address
= parse_vma (optarg
, "--start-address");
3120 case OPTION_STOP_ADDRESS
:
3121 stop_address
= parse_vma (optarg
, "--stop-address");
3124 if (strcmp (optarg
, "B") == 0)
3125 endian
= BFD_ENDIAN_BIG
;
3126 else if (strcmp (optarg
, "L") == 0)
3127 endian
= BFD_ENDIAN_LITTLE
;
3130 non_fatal (_("unrecognized -E option"));
3135 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3136 endian
= BFD_ENDIAN_BIG
;
3137 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3138 endian
= BFD_ENDIAN_LITTLE
;
3141 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3147 dump_file_header
= TRUE
;
3151 formats_info
= TRUE
;
3155 add_include_path (optarg
);
3158 dump_private_headers
= TRUE
;
3162 dump_private_headers
= TRUE
;
3164 dump_reloc_info
= TRUE
;
3165 dump_file_header
= TRUE
;
3166 dump_ar_hdrs
= TRUE
;
3167 dump_section_headers
= TRUE
;
3175 dump_dynamic_symtab
= TRUE
;
3183 disassemble_zeroes
= TRUE
;
3187 disassemble_all
= TRUE
;
3192 with_source_code
= TRUE
;
3201 dump_debugging_tags
= 1;
3206 dump_dwarf_section_info
= TRUE
;
3209 do_debug_abbrevs
= 1;
3211 do_debug_pubnames
= 1;
3212 do_debug_aranges
= 1;
3213 do_debug_ranges
= 1;
3214 do_debug_frames
= 1;
3215 do_debug_macinfo
= 1;
3220 dump_stab_section_info
= TRUE
;
3224 dump_section_contents
= TRUE
;
3228 dump_reloc_info
= TRUE
;
3232 dump_dynamic_reloc_info
= TRUE
;
3236 dump_ar_hdrs
= TRUE
;
3240 dump_section_headers
= TRUE
;
3248 show_version
= TRUE
;
3258 print_version ("objdump");
3264 exit_status
= display_info ();
3268 display_file ("a.out", target
);
3270 for (; optind
< argc
;)
3271 display_file (argv
[optind
++], target
);
3274 END_PROGRESS (program_name
);