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
;
176 usage (FILE *stream
, int status
)
178 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
179 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
180 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
181 fprintf (stream
, _("\
182 -a, --archive-headers Display archive header information\n\
183 -f, --file-headers Display the contents of the overall file header\n\
184 -p, --private-headers Display object format specific file header contents\n\
185 -h, --[section-]headers Display the contents of the section headers\n\
186 -x, --all-headers Display the contents of all headers\n\
187 -d, --disassemble Display assembler contents of executable sections\n\
188 -D, --disassemble-all Display assembler contents of all sections\n\
189 -S, --source Intermix source code with disassembly\n\
190 -s, --full-contents Display the full contents of all sections requested\n\
191 -g, --debugging Display debug information in object file\n\
192 -e, --debugging-tags Display debug information using ctags style\n\
193 -G, --stabs Display (in raw form) any STABS info in the file\n\
194 -W, --dwarf Display DWARF info in the file\n\
195 -t, --syms Display the contents of the symbol table(s)\n\
196 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
197 -r, --reloc Display the relocation entries in the file\n\
198 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
199 @<file> Read options from <file>\n\
200 -v, --version Display this program's version number\n\
201 -i, --info List object formats and architectures supported\n\
202 -H, --help Display this information\n\
206 fprintf (stream
, _("\n The following switches are optional:\n"));
207 fprintf (stream
, _("\
208 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
209 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
210 -j, --section=NAME Only display information for section NAME\n\
211 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
212 -EB --endian=big Assume big endian format when disassembling\n\
213 -EL --endian=little Assume little endian format when disassembling\n\
214 --file-start-context Include context from start of file (with -S)\n\
215 -I, --include=DIR Add DIR to search list for source files\n\
216 -l, --line-numbers Include line numbers and filenames in output\n\
217 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
218 The STYLE, if specified, can be `auto', `gnu',\n\
219 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
221 -w, --wide Format output for more than 80 columns\n\
222 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
223 --start-address=ADDR Only process data whose address is >= ADDR\n\
224 --stop-address=ADDR Only process data whose address is <= ADDR\n\
225 --prefix-addresses Print complete address alongside disassembly\n\
226 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
227 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
228 --special-syms Include special symbols in symbol dumps\n\
230 list_supported_targets (program_name
, stream
);
231 list_supported_architectures (program_name
, stream
);
233 disassembler_usage (stream
);
235 if (REPORT_BUGS_TO
[0] && status
== 0)
236 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
240 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
244 OPTION_START_ADDRESS
,
249 static struct option long_options
[]=
251 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
252 {"all-headers", no_argument
, NULL
, 'x'},
253 {"private-headers", no_argument
, NULL
, 'p'},
254 {"architecture", required_argument
, NULL
, 'm'},
255 {"archive-headers", no_argument
, NULL
, 'a'},
256 {"debugging", no_argument
, NULL
, 'g'},
257 {"debugging-tags", no_argument
, NULL
, 'e'},
258 {"demangle", optional_argument
, NULL
, 'C'},
259 {"disassemble", no_argument
, NULL
, 'd'},
260 {"disassemble-all", no_argument
, NULL
, 'D'},
261 {"disassembler-options", required_argument
, NULL
, 'M'},
262 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
263 {"dynamic-reloc", no_argument
, NULL
, 'R'},
264 {"dynamic-syms", no_argument
, NULL
, 'T'},
265 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
266 {"file-headers", no_argument
, NULL
, 'f'},
267 {"file-start-context", no_argument
, &file_start_context
, 1},
268 {"full-contents", no_argument
, NULL
, 's'},
269 {"headers", no_argument
, NULL
, 'h'},
270 {"help", no_argument
, NULL
, 'H'},
271 {"info", no_argument
, NULL
, 'i'},
272 {"line-numbers", no_argument
, NULL
, 'l'},
273 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
274 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
275 {"reloc", no_argument
, NULL
, 'r'},
276 {"section", required_argument
, NULL
, 'j'},
277 {"section-headers", no_argument
, NULL
, 'h'},
278 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
279 {"source", no_argument
, NULL
, 'S'},
280 {"special-syms", no_argument
, &dump_special_syms
, 1},
281 {"include", required_argument
, NULL
, 'I'},
282 {"dwarf", no_argument
, NULL
, 'W'},
283 {"stabs", no_argument
, NULL
, 'G'},
284 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
285 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
286 {"syms", no_argument
, NULL
, 't'},
287 {"target", required_argument
, NULL
, 'b'},
288 {"version", no_argument
, NULL
, 'V'},
289 {"wide", no_argument
, NULL
, 'w'},
290 {0, no_argument
, 0, 0}
294 nonfatal (const char *msg
)
301 dump_section_header (bfd
*abfd
, asection
*section
,
302 void *ignored ATTRIBUTE_UNUSED
)
305 unsigned int opb
= bfd_octets_per_byte (abfd
);
307 /* Ignore linker created section. See elfNN_ia64_object_p in
309 if (section
->flags
& SEC_LINKER_CREATED
)
312 printf ("%3d %-13s %08lx ", section
->index
,
313 bfd_get_section_name (abfd
, section
),
314 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
315 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
317 bfd_printf_vma (abfd
, section
->lma
);
318 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
319 bfd_get_section_alignment (abfd
, section
));
325 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
327 PF (SEC_HAS_CONTENTS
, "CONTENTS");
328 PF (SEC_ALLOC
, "ALLOC");
329 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
330 PF (SEC_LOAD
, "LOAD");
331 PF (SEC_RELOC
, "RELOC");
332 PF (SEC_READONLY
, "READONLY");
333 PF (SEC_CODE
, "CODE");
334 PF (SEC_DATA
, "DATA");
336 PF (SEC_DEBUGGING
, "DEBUGGING");
337 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
338 PF (SEC_EXCLUDE
, "EXCLUDE");
339 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
340 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
342 PF (SEC_TIC54X_BLOCK
, "BLOCK");
343 PF (SEC_TIC54X_CLINK
, "CLINK");
345 PF (SEC_SMALL_DATA
, "SMALL_DATA");
346 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
347 PF (SEC_COFF_SHARED
, "SHARED");
348 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
349 PF (SEC_GROUP
, "GROUP");
351 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
354 struct coff_comdat_info
*comdat
;
356 switch (section
->flags
& SEC_LINK_DUPLICATES
)
360 case SEC_LINK_DUPLICATES_DISCARD
:
361 ls
= "LINK_ONCE_DISCARD";
363 case SEC_LINK_DUPLICATES_ONE_ONLY
:
364 ls
= "LINK_ONCE_ONE_ONLY";
366 case SEC_LINK_DUPLICATES_SAME_SIZE
:
367 ls
= "LINK_ONCE_SAME_SIZE";
369 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
370 ls
= "LINK_ONCE_SAME_CONTENTS";
373 printf ("%s%s", comma
, ls
);
375 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
377 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
387 dump_headers (bfd
*abfd
)
389 printf (_("Sections:\n"));
392 printf (_("Idx Name Size VMA LMA File off Algn"));
394 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
395 if (bfd_get_arch_size (abfd
) == 32)
396 printf (_("Idx Name Size VMA LMA File off Algn"));
398 printf (_("Idx Name Size VMA LMA File off Algn"));
402 printf (_(" Flags"));
403 if (abfd
->flags
& HAS_LOAD_PAGE
)
407 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
411 slurp_symtab (bfd
*abfd
)
416 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
422 storage
= bfd_get_symtab_upper_bound (abfd
);
424 bfd_fatal (bfd_get_filename (abfd
));
426 sy
= xmalloc (storage
);
428 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
430 bfd_fatal (bfd_get_filename (abfd
));
434 /* Read in the dynamic symbols. */
437 slurp_dynamic_symtab (bfd
*abfd
)
442 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
445 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
447 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
452 bfd_fatal (bfd_get_filename (abfd
));
455 sy
= xmalloc (storage
);
457 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
459 bfd_fatal (bfd_get_filename (abfd
));
463 /* Filter out (in place) symbols that are useless for disassembly.
464 COUNT is the number of elements in SYMBOLS.
465 Return the number of useful symbols. */
468 remove_useless_symbols (asymbol
**symbols
, long count
)
470 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
474 asymbol
*sym
= *in_ptr
++;
476 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
478 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
480 if (bfd_is_und_section (sym
->section
)
481 || bfd_is_com_section (sym
->section
))
486 return out_ptr
- symbols
;
489 /* Sort symbols into value order. */
492 compare_symbols (const void *ap
, const void *bp
)
494 const asymbol
*a
= * (const asymbol
**) ap
;
495 const asymbol
*b
= * (const asymbol
**) bp
;
505 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
507 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
510 if (a
->section
> b
->section
)
512 else if (a
->section
< b
->section
)
515 an
= bfd_asymbol_name (a
);
516 bn
= bfd_asymbol_name (b
);
520 /* The symbols gnu_compiled and gcc2_compiled convey no real
521 information, so put them after other symbols with the same value. */
522 af
= (strstr (an
, "gnu_compiled") != NULL
523 || strstr (an
, "gcc2_compiled") != NULL
);
524 bf
= (strstr (bn
, "gnu_compiled") != NULL
525 || strstr (bn
, "gcc2_compiled") != NULL
);
532 /* We use a heuristic for the file name, to try to sort it after
533 more useful symbols. It may not work on non Unix systems, but it
534 doesn't really matter; the only difference is precisely which
535 symbol names get printed. */
537 #define file_symbol(s, sn, snl) \
538 (((s)->flags & BSF_FILE) != 0 \
539 || ((sn)[(snl) - 2] == '.' \
540 && ((sn)[(snl) - 1] == 'o' \
541 || (sn)[(snl) - 1] == 'a')))
543 af
= file_symbol (a
, an
, anl
);
544 bf
= file_symbol (b
, bn
, bnl
);
551 /* Try to sort global symbols before local symbols before function
552 symbols before debugging symbols. */
557 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
559 if ((aflags
& BSF_DEBUGGING
) != 0)
564 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
566 if ((aflags
& BSF_FUNCTION
) != 0)
571 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
573 if ((aflags
& BSF_LOCAL
) != 0)
578 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
580 if ((aflags
& BSF_GLOBAL
) != 0)
586 /* Symbols that start with '.' might be section names, so sort them
587 after symbols that don't start with '.'. */
588 if (an
[0] == '.' && bn
[0] != '.')
590 if (an
[0] != '.' && bn
[0] == '.')
593 /* Finally, if we can't distinguish them in any other way, try to
594 get consistent results by sorting the symbols by name. */
595 return strcmp (an
, bn
);
598 /* Sort relocs into address order. */
601 compare_relocs (const void *ap
, const void *bp
)
603 const arelent
*a
= * (const arelent
**) ap
;
604 const arelent
*b
= * (const arelent
**) bp
;
606 if (a
->address
> b
->address
)
608 else if (a
->address
< b
->address
)
611 /* So that associated relocations tied to the same address show up
612 in the correct order, we don't do any further sorting. */
621 /* Print an address (VMA) to the output stream in INFO.
622 If SKIP_ZEROES is TRUE, omit leading zeroes. */
625 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
626 bfd_boolean skip_zeroes
)
630 struct objdump_disasm_info
*aux
;
632 aux
= (struct objdump_disasm_info
*) info
->application_data
;
633 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
638 for (p
= buf
; *p
== '0'; ++p
)
643 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
646 /* Print the name of a symbol. */
649 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
656 name
= bfd_asymbol_name (sym
);
657 if (do_demangle
&& name
[0] != '\0')
659 /* Demangle the name. */
660 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
666 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
674 /* Locate a symbol given a bfd and a section (from INFO->application_data),
675 and a VMA. If INFO->application_data->require_sec is TRUE, then always
676 require the symbol to be in the section. Returns NULL if there is no
677 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
678 of the symbol in sorted_syms. */
681 find_symbol_for_address (bfd_vma vma
,
682 struct disassemble_info
*info
,
685 /* @@ Would it speed things up to cache the last two symbols returned,
686 and maybe their address ranges? For many processors, only one memory
687 operand can be present at a time, so the 2-entry cache wouldn't be
688 constantly churned by code doing heavy memory accesses. */
690 /* Indices in `sorted_syms'. */
692 long max
= sorted_symcount
;
694 struct objdump_disasm_info
*aux
;
698 bfd_boolean want_section
;
700 if (sorted_symcount
< 1)
703 aux
= (struct objdump_disasm_info
*) info
->application_data
;
706 opb
= bfd_octets_per_byte (abfd
);
708 /* Perform a binary search looking for the closest symbol to the
709 required value. We are searching the range (min, max]. */
710 while (min
+ 1 < max
)
714 thisplace
= (max
+ min
) / 2;
715 sym
= sorted_syms
[thisplace
];
717 if (bfd_asymbol_value (sym
) > vma
)
719 else if (bfd_asymbol_value (sym
) < vma
)
728 /* The symbol we want is now in min, the low end of the range we
729 were searching. If there are several symbols with the same
730 value, we want the first one. */
733 && (bfd_asymbol_value (sorted_syms
[thisplace
])
734 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
737 /* If the file is relocatable, and the symbol could be from this
738 section, prefer a symbol from this section over symbols from
739 others, even if the other symbol's value might be closer.
741 Note that this may be wrong for some symbol references if the
742 sections have overlapping memory ranges, but in that case there's
743 no way to tell what's desired without looking at the relocation
746 Also give the target a chance to reject symbols. */
747 want_section
= (aux
->require_sec
748 || ((abfd
->flags
& HAS_RELOC
) != 0
749 && vma
>= bfd_get_section_vma (abfd
, sec
)
750 && vma
< (bfd_get_section_vma (abfd
, sec
)
751 + bfd_section_size (abfd
, sec
) / opb
)));
752 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
753 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
758 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
760 if (bfd_asymbol_value (sorted_syms
[i
])
761 != bfd_asymbol_value (sorted_syms
[thisplace
]))
766 newplace
= sorted_symcount
;
770 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
771 && info
->symbol_is_valid (sorted_syms
[i
], info
))
773 if (newplace
== sorted_symcount
)
776 if (bfd_asymbol_value (sorted_syms
[i
])
777 != bfd_asymbol_value (sorted_syms
[newplace
]))
780 /* Remember this symbol and keep searching until we reach
781 an earlier address. */
786 if (newplace
!= sorted_symcount
)
787 thisplace
= newplace
;
790 /* We didn't find a good symbol with a smaller value.
791 Look for one with a larger value. */
792 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
794 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
795 && info
->symbol_is_valid (sorted_syms
[i
], info
))
803 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
804 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
805 /* There is no suitable symbol. */
812 return sorted_syms
[thisplace
];
815 /* Print an address and the offset to the nearest symbol. */
818 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
819 bfd_vma vma
, struct disassemble_info
*info
,
820 bfd_boolean skip_zeroes
)
822 objdump_print_value (vma
, info
, skip_zeroes
);
828 (*info
->fprintf_func
) (info
->stream
, " <%s",
829 bfd_get_section_name (abfd
, sec
));
830 secaddr
= bfd_get_section_vma (abfd
, sec
);
833 (*info
->fprintf_func
) (info
->stream
, "-0x");
834 objdump_print_value (secaddr
- vma
, info
, TRUE
);
836 else if (vma
> secaddr
)
838 (*info
->fprintf_func
) (info
->stream
, "+0x");
839 objdump_print_value (vma
- secaddr
, info
, TRUE
);
841 (*info
->fprintf_func
) (info
->stream
, ">");
845 (*info
->fprintf_func
) (info
->stream
, " <");
846 objdump_print_symname (abfd
, info
, sym
);
847 if (bfd_asymbol_value (sym
) > vma
)
849 (*info
->fprintf_func
) (info
->stream
, "-0x");
850 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
852 else if (vma
> bfd_asymbol_value (sym
))
854 (*info
->fprintf_func
) (info
->stream
, "+0x");
855 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
857 (*info
->fprintf_func
) (info
->stream
, ">");
861 /* Print an address (VMA), symbolically if possible.
862 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
865 objdump_print_addr (bfd_vma vma
,
866 struct disassemble_info
*info
,
867 bfd_boolean skip_zeroes
)
869 struct objdump_disasm_info
*aux
;
870 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
871 bfd_boolean skip_find
= FALSE
;
873 if (sorted_symcount
< 1)
875 (*info
->fprintf_func
) (info
->stream
, "0x");
876 objdump_print_value (vma
, info
, skip_zeroes
);
880 aux
= (struct objdump_disasm_info
*) info
->application_data
;
882 if (aux
->reloc
!= NULL
883 && aux
->reloc
->sym_ptr_ptr
!= NULL
884 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
886 sym
= * aux
->reloc
->sym_ptr_ptr
;
888 /* Adjust the vma to the reloc. */
889 vma
+= bfd_asymbol_value (sym
);
891 if (bfd_is_und_section (bfd_get_section (sym
)))
896 sym
= find_symbol_for_address (vma
, info
, NULL
);
898 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
902 /* Print VMA to INFO. This function is passed to the disassembler
906 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
908 objdump_print_addr (vma
, info
, ! prefix_addresses
);
911 /* Determine if the given address has a symbol associated with it. */
914 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
918 sym
= find_symbol_for_address (vma
, info
, NULL
);
920 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
923 /* Hold the last function name and the last line number we displayed
926 static char *prev_functionname
;
927 static unsigned int prev_line
;
929 /* We keep a list of all files that we have seen when doing a
930 disassembly with source, so that we know how much of the file to
931 display. This can be important for inlined functions. */
933 struct print_file_list
935 struct print_file_list
*next
;
936 const char *filename
;
940 const char **linemap
;
946 static struct print_file_list
*print_files
;
948 /* The number of preceding context lines to show when we start
949 displaying a file for the first time. */
951 #define SHOW_PRECEDING_CONTEXT_LINES (5)
953 /* Read a complete file into memory. */
956 slurp_file (const char *fn
, size_t *size
)
959 int ps
= getpagesize ();
964 int fd
= open (fn
, O_RDONLY
);
968 if (fstat (fd
, &st
) < 0)
972 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
973 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
974 if (map
!= (char *)-1L)
980 map
= malloc (*size
);
981 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
990 #define line_map_decrease 5
992 /* Precompute array of lines for a mapped file. */
995 index_file (const char *map
, size_t size
, unsigned int *maxline
)
997 const char *p
, *lstart
, *end
;
998 int chars_per_line
= 45; /* First iteration will use 40. */
1000 const char **linemap
= NULL
;
1001 unsigned long line_map_size
= 0;
1007 for (p
= map
; p
< end
; p
++)
1011 if (p
+ 1 < end
&& p
[1] == '\r')
1014 else if (*p
== '\r')
1016 if (p
+ 1 < end
&& p
[1] == '\n')
1022 /* End of line found. */
1024 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1026 unsigned long newsize
;
1028 chars_per_line
-= line_map_decrease
;
1029 if (chars_per_line
<= 1)
1031 line_map_size
= size
/ chars_per_line
+ 1;
1032 if (line_map_size
< lineno
+ 1)
1033 line_map_size
= lineno
+ 1;
1034 newsize
= line_map_size
* sizeof (char *);
1035 linemap
= xrealloc (linemap
, newsize
);
1038 linemap
[lineno
++] = lstart
;
1046 /* Tries to open MODNAME, and if successful adds a node to print_files
1047 linked list and returns that node. Returns NULL on failure. */
1049 static struct print_file_list
*
1050 try_print_file_open (const char *origname
, const char *modname
)
1052 struct print_file_list
*p
;
1054 p
= xmalloc (sizeof (struct print_file_list
));
1056 p
->map
= slurp_file (modname
, &p
->mapsize
);
1063 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1065 p
->filename
= origname
;
1066 p
->modname
= modname
;
1067 p
->next
= print_files
;
1073 /* If the the source file, as described in the symtab, is not found
1074 try to locate it in one of the paths specified with -I
1075 If found, add location to print_files linked list. */
1077 static struct print_file_list
*
1078 update_source_path (const char *filename
)
1080 struct print_file_list
*p
;
1084 if (filename
== NULL
)
1087 p
= try_print_file_open (filename
, filename
);
1091 if (include_path_count
== 0)
1094 /* Get the name of the file. */
1095 fname
= strrchr (filename
, '/');
1096 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1098 /* We could have a mixed forward/back slash case. */
1099 char *backslash
= strrchr (filename
, '\\');
1100 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1102 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1103 fname
= filename
+ 1;
1111 /* If file exists under a new path, we need to add it to the list
1112 so that show_line knows about it. */
1113 for (i
= 0; i
< include_path_count
; i
++)
1115 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1117 p
= try_print_file_open (filename
, modname
);
1127 /* Print a source file line. */
1130 print_line (struct print_file_list
*p
, unsigned int line
)
1136 if (line
>= p
->maxline
)
1138 l
= p
->linemap
[line
];
1139 /* Test fwrite return value to quiet glibc warning. */
1140 len
= strcspn (l
, "\n\r");
1141 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1145 /* Print a range of source code lines. */
1148 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1152 while (start
<= end
)
1154 print_line (p
, start
);
1159 /* Show the line number, or the source line, in a disassembly
1163 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1165 const char *filename
;
1166 const char *functionname
;
1169 if (! with_line_numbers
&& ! with_source_code
)
1172 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1173 &functionname
, &line
))
1176 if (filename
!= NULL
&& *filename
== '\0')
1178 if (functionname
!= NULL
&& *functionname
== '\0')
1179 functionname
= NULL
;
1181 if (with_line_numbers
)
1183 if (functionname
!= NULL
1184 && (prev_functionname
== NULL
1185 || strcmp (functionname
, prev_functionname
) != 0))
1186 printf ("%s():\n", functionname
);
1187 if (line
> 0 && line
!= prev_line
)
1188 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1191 if (with_source_code
1195 struct print_file_list
**pp
, *p
;
1198 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1199 if (strcmp ((*pp
)->filename
, filename
) == 0)
1204 p
= update_source_path (filename
);
1206 if (p
!= NULL
&& line
!= p
->last_line
)
1208 if (file_start_context
&& p
->first
)
1212 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1215 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1216 l
= p
->last_line
+ 1;
1218 dump_lines (p
, l
, line
);
1219 p
->last_line
= line
;
1224 if (functionname
!= NULL
1225 && (prev_functionname
== NULL
1226 || strcmp (functionname
, prev_functionname
) != 0))
1228 if (prev_functionname
!= NULL
)
1229 free (prev_functionname
);
1230 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1231 strcpy (prev_functionname
, functionname
);
1234 if (line
> 0 && line
!= prev_line
)
1238 /* Pseudo FILE object for strings. */
1246 /* sprintf to a "stream". */
1248 static int ATTRIBUTE_PRINTF_2
1249 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1256 size_t space
= f
->alloc
- f
->pos
;
1258 va_start (args
, format
);
1259 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1265 f
->alloc
= (f
->alloc
+ n
) * 2;
1266 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1273 /* Returns TRUE if the specified section should be dumped. */
1276 process_section_p (asection
* section
)
1283 for (i
= 0; i
< only_used
; i
++)
1284 if (strcmp (only
[i
], section
->name
) == 0)
1291 /* The number of zeroes we want to see before we start skipping them.
1292 The number is arbitrarily chosen. */
1294 #define DEFAULT_SKIP_ZEROES 8
1296 /* The number of zeroes to skip at the end of a section. If the
1297 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1298 SKIP_ZEROES, they will be disassembled. If there are fewer than
1299 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1300 attempt to avoid disassembling zeroes inserted by section
1303 #define DEFAULT_SKIP_ZEROES_AT_END 3
1305 /* Disassemble some data in memory between given values. */
1308 disassemble_bytes (struct disassemble_info
* info
,
1309 disassembler_ftype disassemble_fn
,
1312 bfd_vma start_offset
,
1313 bfd_vma stop_offset
,
1316 arelent
** relppend
)
1318 struct objdump_disasm_info
*aux
;
1320 int octets_per_line
;
1321 bfd_boolean done_dot
;
1322 int skip_addr_chars
;
1323 bfd_vma addr_offset
;
1324 unsigned int opb
= info
->octets_per_byte
;
1325 unsigned int skip_zeroes
= info
->skip_zeroes
;
1326 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1330 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1334 sfile
.buffer
= xmalloc (sfile
.alloc
);
1338 octets_per_line
= 4;
1340 octets_per_line
= 16;
1342 /* Figure out how many characters to skip at the start of an
1343 address, to make the disassembly look nicer. We discard leading
1344 zeroes in chunks of 4, ensuring that there is always a leading
1346 skip_addr_chars
= 0;
1347 if (! prefix_addresses
)
1355 + bfd_section_size (section
->owner
, section
) / opb
));
1357 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1360 skip_addr_chars
+= 4;
1365 info
->insn_info_valid
= 0;
1368 addr_offset
= start_offset
;
1369 while (addr_offset
< stop_offset
)
1372 bfd_boolean need_nl
= FALSE
;
1373 int previous_octets
;
1375 /* Remember the length of the previous instruction. */
1376 previous_octets
= octets
;
1379 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1381 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1384 if (! disassemble_zeroes
1385 && (info
->insn_info_valid
== 0
1386 || info
->branch_delay_insns
== 0)
1387 && (z
- addr_offset
* opb
>= skip_zeroes
1388 || (z
== stop_offset
* opb
&&
1389 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1393 /* If there are more nonzero octets to follow, we only skip
1394 zeroes in multiples of 4, to try to avoid running over
1395 the start of an instruction which happens to start with
1397 if (z
!= stop_offset
* opb
)
1398 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1400 octets
= z
- addr_offset
* opb
;
1410 if (with_line_numbers
|| with_source_code
)
1411 show_line (aux
->abfd
, section
, addr_offset
);
1413 if (! prefix_addresses
)
1417 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1418 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1422 printf ("%s:\t", buf
+ skip_addr_chars
);
1426 aux
->require_sec
= TRUE
;
1427 objdump_print_address (section
->vma
+ addr_offset
, info
);
1428 aux
->require_sec
= FALSE
;
1435 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1436 info
->stream
= &sfile
;
1437 info
->bytes_per_line
= 0;
1438 info
->bytes_per_chunk
= 0;
1441 if (info
->disassembler_needs_relocs
1442 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1443 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1444 && *relppp
< relppend
)
1446 bfd_signed_vma distance_to_rel
;
1448 distance_to_rel
= (**relppp
)->address
1449 - (rel_offset
+ addr_offset
);
1451 /* Check to see if the current reloc is associated with
1452 the instruction that we are about to disassemble. */
1453 if (distance_to_rel
== 0
1454 /* FIXME: This is wrong. We are trying to catch
1455 relocs that are addressed part way through the
1456 current instruction, as might happen with a packed
1457 VLIW instruction. Unfortunately we do not know the
1458 length of the current instruction since we have not
1459 disassembled it yet. Instead we take a guess based
1460 upon the length of the previous instruction. The
1461 proper solution is to have a new target-specific
1462 disassembler function which just returns the length
1463 of an instruction at a given address without trying
1464 to display its disassembly. */
1465 || (distance_to_rel
> 0
1466 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1468 info
->flags
= INSN_HAS_RELOC
;
1469 aux
->reloc
= **relppp
;
1475 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1476 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1477 info
->stream
= stdout
;
1478 if (info
->bytes_per_line
!= 0)
1479 octets_per_line
= info
->bytes_per_line
;
1483 printf ("%s\n", sfile
.buffer
);
1491 octets
= octets_per_line
;
1492 if (addr_offset
+ octets
/ opb
> stop_offset
)
1493 octets
= (stop_offset
- addr_offset
) * opb
;
1495 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1497 if (ISPRINT (data
[j
]))
1498 buf
[j
- addr_offset
* opb
] = data
[j
];
1500 buf
[j
- addr_offset
* opb
] = '.';
1502 buf
[j
- addr_offset
* opb
] = '\0';
1505 if (prefix_addresses
1507 : show_raw_insn
>= 0)
1511 /* If ! prefix_addresses and ! wide_output, we print
1512 octets_per_line octets per line. */
1514 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1515 pb
= octets_per_line
;
1517 if (info
->bytes_per_chunk
)
1518 bpc
= info
->bytes_per_chunk
;
1522 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1526 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1528 for (k
= bpc
- 1; k
>= 0; k
--)
1529 printf ("%02x", (unsigned) data
[j
+ k
]);
1534 for (k
= 0; k
< bpc
; k
++)
1535 printf ("%02x", (unsigned) data
[j
+ k
]);
1540 for (; pb
< octets_per_line
; pb
+= bpc
)
1544 for (k
= 0; k
< bpc
; k
++)
1549 /* Separate raw data from instruction by extra space. */
1559 printf ("%s", sfile
.buffer
);
1561 if (prefix_addresses
1563 : show_raw_insn
>= 0)
1571 j
= addr_offset
* opb
+ pb
;
1573 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1574 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1578 printf ("%s:\t", buf
+ skip_addr_chars
);
1580 pb
+= octets_per_line
;
1583 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1587 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1589 for (k
= bpc
- 1; k
>= 0; k
--)
1590 printf ("%02x", (unsigned) data
[j
+ k
]);
1595 for (k
= 0; k
< bpc
; k
++)
1596 printf ("%02x", (unsigned) data
[j
+ k
]);
1609 while ((*relppp
) < relppend
1610 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1612 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1623 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1626 if (q
->howto
== NULL
)
1627 printf (": *unknown*\t");
1628 else if (q
->howto
->name
)
1629 printf (": %s\t", q
->howto
->name
);
1631 printf (": %d\t", q
->howto
->type
);
1633 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1634 printf ("*unknown*");
1637 const char *sym_name
;
1639 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1640 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1641 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1646 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1647 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1648 if (sym_name
== NULL
|| *sym_name
== '\0')
1649 sym_name
= "*unknown*";
1650 printf ("%s", sym_name
);
1657 objdump_print_value (q
->addend
, info
, TRUE
);
1669 addr_offset
+= octets
/ opb
;
1672 free (sfile
.buffer
);
1676 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1678 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1679 struct objdump_disasm_info
* paux
;
1680 unsigned int opb
= pinfo
->octets_per_byte
;
1681 bfd_byte
* data
= NULL
;
1682 bfd_size_type datasize
= 0;
1683 arelent
** rel_pp
= NULL
;
1684 arelent
** rel_ppstart
= NULL
;
1685 arelent
** rel_ppend
;
1686 unsigned long stop_offset
;
1687 asymbol
* sym
= NULL
;
1691 unsigned long addr_offset
;
1693 /* Sections that do not contain machine
1694 code are not normally disassembled. */
1695 if (! disassemble_all
1697 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1698 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1701 if (! process_section_p (section
))
1704 datasize
= bfd_get_section_size (section
);
1708 /* Decide which set of relocs to use. Load them if necessary. */
1709 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1710 if (paux
->dynrelbuf
)
1712 rel_pp
= paux
->dynrelbuf
;
1713 rel_count
= paux
->dynrelcount
;
1714 /* Dynamic reloc addresses are absolute, non-dynamic are section
1715 relative. REL_OFFSET specifies the reloc address corresponding
1716 to the start of this section. */
1717 rel_offset
= section
->vma
;
1725 if ((section
->flags
& SEC_RELOC
) != 0
1726 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1730 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1732 bfd_fatal (bfd_get_filename (abfd
));
1736 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1737 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1739 bfd_fatal (bfd_get_filename (abfd
));
1741 /* Sort the relocs by address. */
1742 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1747 rel_ppend
= rel_pp
+ rel_count
;
1749 data
= xmalloc (datasize
);
1751 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1753 paux
->sec
= section
;
1754 pinfo
->buffer
= data
;
1755 pinfo
->buffer_vma
= section
->vma
;
1756 pinfo
->buffer_length
= datasize
;
1757 pinfo
->section
= section
;
1759 if (start_address
== (bfd_vma
) -1
1760 || start_address
< pinfo
->buffer_vma
)
1763 addr_offset
= start_address
- pinfo
->buffer_vma
;
1765 if (stop_address
== (bfd_vma
) -1)
1766 stop_offset
= datasize
/ opb
;
1769 if (stop_address
< pinfo
->buffer_vma
)
1772 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1773 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1774 stop_offset
= pinfo
->buffer_length
/ opb
;
1777 /* Skip over the relocs belonging to addresses below the
1779 while (rel_pp
< rel_ppend
1780 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1783 printf (_("Disassembly of section %s:\n"), section
->name
);
1785 /* Find the nearest symbol forwards from our current position. */
1786 paux
->require_sec
= TRUE
;
1787 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1788 paux
->require_sec
= FALSE
;
1790 /* Disassemble a block of instructions up to the address associated with
1791 the symbol we have just found. Then print the symbol and find the
1792 next symbol on. Repeat until we have disassembled the entire section
1793 or we have reached the end of the address range we are interested in. */
1794 while (addr_offset
< stop_offset
)
1798 unsigned long nextstop_offset
;
1801 addr
= section
->vma
+ addr_offset
;
1803 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1808 (x
< sorted_symcount
1809 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1813 pinfo
->symbols
= sorted_syms
+ place
;
1814 pinfo
->num_symbols
= x
- place
;
1815 pinfo
->symtab_pos
= place
;
1819 pinfo
->symbols
= NULL
;
1820 pinfo
->num_symbols
= 0;
1821 pinfo
->symtab_pos
= -1;
1824 if (! prefix_addresses
)
1826 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1827 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1829 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1832 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1834 else if (sym
== NULL
)
1838 #define is_valid_next_sym(SYM) \
1839 ((SYM)->section == section \
1840 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1841 && pinfo->symbol_is_valid (SYM, pinfo))
1843 /* Search forward for the next appropriate symbol in
1844 SECTION. Note that all the symbols are sorted
1845 together into one big array, and that some sections
1846 may have overlapping addresses. */
1847 while (place
< sorted_symcount
1848 && ! is_valid_next_sym (sorted_syms
[place
]))
1851 if (place
>= sorted_symcount
)
1854 nextsym
= sorted_syms
[place
];
1857 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1858 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1859 else if (nextsym
== NULL
)
1860 nextstop_offset
= stop_offset
;
1862 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1864 if (nextstop_offset
> stop_offset
)
1865 nextstop_offset
= stop_offset
;
1867 /* If a symbol is explicitly marked as being an object
1868 rather than a function, just dump the bytes without
1869 disassembling them. */
1872 || bfd_asymbol_value (sym
) > addr
1873 || ((sym
->flags
& BSF_OBJECT
) == 0
1874 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1876 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1878 || (sym
->flags
& BSF_FUNCTION
) != 0)
1883 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1884 addr_offset
, nextstop_offset
,
1885 rel_offset
, &rel_pp
, rel_ppend
);
1887 addr_offset
= nextstop_offset
;
1893 if (rel_ppstart
!= NULL
)
1897 /* Disassemble the contents of an object file. */
1900 disassemble_data (bfd
*abfd
)
1902 struct disassemble_info disasm_info
;
1903 struct objdump_disasm_info aux
;
1907 prev_functionname
= NULL
;
1910 /* We make a copy of syms to sort. We don't want to sort syms
1911 because that will screw up the relocs. */
1912 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1913 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1914 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1915 sorted_symcount
* sizeof (asymbol
*));
1917 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1919 for (i
= 0; i
< synthcount
; ++i
)
1921 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1925 /* Sort the symbols into section and symbol order. */
1926 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1928 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1930 disasm_info
.application_data
= (void *) &aux
;
1932 aux
.require_sec
= FALSE
;
1933 aux
.dynrelbuf
= NULL
;
1934 aux
.dynrelcount
= 0;
1937 disasm_info
.print_address_func
= objdump_print_address
;
1938 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1940 if (machine
!= NULL
)
1942 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1945 fatal (_("Can't use supplied machine %s"), machine
);
1947 abfd
->arch_info
= info
;
1950 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1952 struct bfd_target
*xvec
;
1954 xvec
= xmalloc (sizeof (struct bfd_target
));
1955 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1956 xvec
->byteorder
= endian
;
1960 /* Use libopcodes to locate a suitable disassembler. */
1961 aux
.disassemble_fn
= disassembler (abfd
);
1962 if (!aux
.disassemble_fn
)
1964 non_fatal (_("Can't disassemble for architecture %s\n"),
1965 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1970 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1971 disasm_info
.arch
= bfd_get_arch (abfd
);
1972 disasm_info
.mach
= bfd_get_mach (abfd
);
1973 disasm_info
.disassembler_options
= disassembler_options
;
1974 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1975 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1976 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1977 disasm_info
.disassembler_needs_relocs
= FALSE
;
1979 if (bfd_big_endian (abfd
))
1980 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1981 else if (bfd_little_endian (abfd
))
1982 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1984 /* ??? Aborting here seems too drastic. We could default to big or little
1986 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1988 /* Allow the target to customize the info structure. */
1989 disassemble_init_for_target (& disasm_info
);
1991 /* Pre-load the dynamic relocs if we are going
1992 to be dumping them along with the disassembly. */
1993 if (dump_dynamic_reloc_info
)
1995 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1998 bfd_fatal (bfd_get_filename (abfd
));
2002 aux
.dynrelbuf
= xmalloc (relsize
);
2003 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2006 if (aux
.dynrelcount
< 0)
2007 bfd_fatal (bfd_get_filename (abfd
));
2009 /* Sort the relocs by address. */
2010 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2014 disasm_info
.symtab
= sorted_syms
;
2015 disasm_info
.symtab_size
= sorted_symcount
;
2017 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2019 if (aux
.dynrelbuf
!= NULL
)
2020 free (aux
.dynrelbuf
);
2025 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2027 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2032 /* If it is already loaded, do nothing. */
2033 if (section
->start
!= NULL
)
2036 /* Locate the debug section. */
2037 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2041 /* Compute a bias to be added to offsets found within the DWARF debug
2042 information. These offsets are meant to be relative to the start of
2043 the dwarf section, and hence the bias should be 0. For MACH-O however
2044 a dwarf section is really just a region of a much larger section and so
2045 the bias is the address of the start of that area within the larger
2046 section. This test is important for PE and COFF based targets which
2047 use DWARF debug information, since unlike ELF, they do not allow the
2048 dwarf sections to be placed at address 0. */
2049 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2050 section
->address
= bfd_get_section_vma (abfd
, sec
);
2052 section
->address
= 0;
2054 section
->size
= bfd_get_section_size (sec
);
2055 section
->start
= xmalloc (section
->size
);
2057 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2058 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2063 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2068 free_debug_section (debug
);
2069 printf (_("\nCan't get contents for section '%s'.\n"),
2077 free_debug_section (enum dwarf_section_display_enum debug
)
2079 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2081 if (section
->start
== NULL
)
2084 free ((char *) section
->start
);
2085 section
->start
= NULL
;
2086 section
->address
= 0;
2091 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2092 void *arg ATTRIBUTE_UNUSED
)
2094 const char *name
= bfd_get_section_name (abfd
, section
);
2096 enum dwarf_section_display_enum i
;
2098 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2099 match
= ".debug_info";
2103 for (i
= 0; i
< max
; i
++)
2104 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2106 if (!debug_displays
[i
].eh_frame
)
2108 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2110 if (load_debug_section (i
, abfd
))
2112 debug_displays
[i
].display (sec
, abfd
);
2114 if (i
!= info
&& i
!= abbrev
)
2115 free_debug_section (i
);
2122 static const char *mach_o_dwarf_sections
[] = {
2123 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2124 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2125 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2126 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2127 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2128 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2129 ".eh_frame", /* .eh_frame */
2130 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2131 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2132 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2133 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2134 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2135 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2136 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2137 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2138 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2141 static const char *generic_dwarf_sections
[max
];
2144 check_mach_o_dwarf (bfd
*abfd
)
2146 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2147 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2148 enum dwarf_section_display_enum i
;
2150 if (generic_dwarf_sections
[0] == NULL
)
2151 for (i
= 0; i
< max
; i
++)
2152 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2154 if (old_flavour
!= current_flavour
)
2156 if (current_flavour
== bfd_target_mach_o_flavour
)
2157 for (i
= 0; i
< max
; i
++)
2158 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2159 else if (old_flavour
== bfd_target_mach_o_flavour
)
2160 for (i
= 0; i
< max
; i
++)
2161 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2163 old_flavour
= current_flavour
;
2167 /* Dump the dwarf debugging information. */
2170 dump_dwarf (bfd
*abfd
)
2172 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2174 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2175 targets will return 64. */
2176 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2178 if (bfd_big_endian (abfd
))
2179 byte_get
= byte_get_big_endian
;
2180 else if (bfd_little_endian (abfd
))
2181 byte_get
= byte_get_little_endian
;
2185 check_mach_o_dwarf (abfd
);
2187 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2189 free_debug_memory ();
2192 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2193 it. Return NULL on failure. */
2196 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2202 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2203 if (stabsect
== NULL
)
2205 printf (_("No %s section present\n\n"), sect_name
);
2209 size
= bfd_section_size (abfd
, stabsect
);
2210 contents
= xmalloc (size
);
2212 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2214 non_fatal (_("Reading %s section of %s failed: %s"),
2215 sect_name
, bfd_get_filename (abfd
),
2216 bfd_errmsg (bfd_get_error ()));
2227 /* Stabs entries use a 12 byte format:
2228 4 byte string table index
2230 1 byte stab other field
2231 2 byte stab desc field
2233 FIXME: This will have to change for a 64 bit object format. */
2235 #define STRDXOFF (0)
2237 #define OTHEROFF (5)
2240 #define STABSIZE (12)
2242 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2243 using string table section STRSECT_NAME (in `strtab'). */
2246 print_section_stabs (bfd
*abfd
,
2247 const char *stabsect_name
,
2248 unsigned *string_offset_ptr
)
2251 unsigned file_string_table_offset
= 0;
2252 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2253 bfd_byte
*stabp
, *stabs_end
;
2256 stabs_end
= stabp
+ stab_size
;
2258 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2259 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2261 /* Loop through all symbols and print them.
2263 We start the index at -1 because there is a dummy symbol on
2264 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2265 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2269 unsigned char type
, other
;
2270 unsigned short desc
;
2273 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2274 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2275 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2276 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2277 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2279 printf ("\n%-6d ", i
);
2280 /* Either print the stab name, or, if unnamed, print its number
2281 again (makes consistent formatting for tools like awk). */
2282 name
= bfd_get_stab_name (type
);
2284 printf ("%-6s", name
);
2285 else if (type
== N_UNDF
)
2288 printf ("%-6d", type
);
2289 printf (" %-6d %-6d ", other
, desc
);
2290 bfd_printf_vma (abfd
, value
);
2291 printf (" %-6lu", strx
);
2293 /* Symbols with type == 0 (N_UNDF) specify the length of the
2294 string table associated with this file. We use that info
2295 to know how to relocate the *next* file's string table indices. */
2298 file_string_table_offset
= next_file_string_table_offset
;
2299 next_file_string_table_offset
+= value
;
2303 /* Using the (possibly updated) string table offset, print the
2304 string (if any) associated with this symbol. */
2305 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2306 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2312 *string_offset_ptr
= next_file_string_table_offset
;
2317 const char * section_name
;
2318 const char * string_section_name
;
2319 unsigned string_offset
;
2324 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2327 stab_section_names
* sought
= (stab_section_names
*) names
;
2329 /* Check for section names for which stabsect_name is a prefix, to
2330 handle .stab.N, etc. */
2331 len
= strlen (sought
->section_name
);
2333 /* If the prefix matches, and the files section name ends with a
2334 nul or a digit, then we match. I.e., we want either an exact
2335 match or a section followed by a number. */
2336 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2337 && (section
->name
[len
] == 0
2338 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2341 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2346 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2349 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2355 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2357 stab_section_names s
;
2359 s
.section_name
= stabsect_name
;
2360 s
.string_section_name
= strsect_name
;
2361 s
.string_offset
= 0;
2363 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2369 /* Dump the any sections containing stabs debugging information. */
2372 dump_stabs (bfd
*abfd
)
2374 dump_stabs_section (abfd
, ".stab", ".stabstr");
2375 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2376 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2377 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2381 dump_bfd_header (bfd
*abfd
)
2385 printf (_("architecture: %s, "),
2386 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2387 bfd_get_mach (abfd
)));
2388 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2390 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2391 PF (HAS_RELOC
, "HAS_RELOC");
2392 PF (EXEC_P
, "EXEC_P");
2393 PF (HAS_LINENO
, "HAS_LINENO");
2394 PF (HAS_DEBUG
, "HAS_DEBUG");
2395 PF (HAS_SYMS
, "HAS_SYMS");
2396 PF (HAS_LOCALS
, "HAS_LOCALS");
2397 PF (DYNAMIC
, "DYNAMIC");
2398 PF (WP_TEXT
, "WP_TEXT");
2399 PF (D_PAGED
, "D_PAGED");
2400 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2401 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2402 printf (_("\nstart address 0x"));
2403 bfd_printf_vma (abfd
, abfd
->start_address
);
2409 dump_bfd_private_header (bfd
*abfd
)
2411 bfd_print_private_bfd_data (abfd
, stdout
);
2415 /* Display a section in hexadecimal format with associated characters.
2416 Each line prefixed by the zero padded address. */
2419 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2422 bfd_size_type datasize
;
2423 bfd_size_type addr_offset
;
2424 bfd_size_type start_offset
;
2425 bfd_size_type stop_offset
;
2426 unsigned int opb
= bfd_octets_per_byte (abfd
);
2427 /* Bytes per line. */
2428 const int onaline
= 16;
2433 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2436 if (! process_section_p (section
))
2439 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2442 printf (_("Contents of section %s:\n"), section
->name
);
2444 data
= xmalloc (datasize
);
2446 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2448 /* Compute the address range to display. */
2449 if (start_address
== (bfd_vma
) -1
2450 || start_address
< section
->vma
)
2453 start_offset
= start_address
- section
->vma
;
2455 if (stop_address
== (bfd_vma
) -1)
2456 stop_offset
= datasize
/ opb
;
2459 if (stop_address
< section
->vma
)
2462 stop_offset
= stop_address
- section
->vma
;
2464 if (stop_offset
> datasize
/ opb
)
2465 stop_offset
= datasize
/ opb
;
2470 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2471 if (strlen (buf
) >= sizeof (buf
))
2475 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2477 count
= strlen (buf
) - count
;
2481 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2482 if (strlen (buf
) >= sizeof (buf
))
2486 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2488 count
= strlen (buf
) - count
;
2492 for (addr_offset
= start_offset
;
2493 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2497 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2498 count
= strlen (buf
);
2499 if ((size_t) count
>= sizeof (buf
))
2503 while (count
< width
)
2508 fputs (buf
+ count
- width
, stdout
);
2511 for (j
= addr_offset
* opb
;
2512 j
< addr_offset
* opb
+ onaline
; j
++)
2514 if (j
< stop_offset
* opb
)
2515 printf ("%02x", (unsigned) (data
[j
]));
2523 for (j
= addr_offset
* opb
;
2524 j
< addr_offset
* opb
+ onaline
; j
++)
2526 if (j
>= stop_offset
* opb
)
2529 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2536 /* Actually display the various requested regions. */
2539 dump_data (bfd
*abfd
)
2541 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2544 /* Should perhaps share code and display with nm? */
2547 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2557 printf ("DYNAMIC SYMBOL TABLE:\n");
2563 printf ("SYMBOL TABLE:\n");
2567 printf (_("no symbols\n"));
2569 for (count
= 0; count
< max
; count
++)
2573 if (*current
== NULL
)
2574 printf (_("no information for symbol number %ld\n"), count
);
2576 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2577 printf (_("could not determine the type of symbol number %ld\n"),
2580 else if (process_section_p ((* current
)->section
)
2581 && (dump_special_syms
2582 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2584 const char *name
= (*current
)->name
;
2586 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2590 /* If we want to demangle the name, we demangle it
2591 here, and temporarily clobber it while calling
2592 bfd_print_symbol. FIXME: This is a gross hack. */
2593 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2595 (*current
)->name
= alloc
;
2596 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2597 bfd_print_symbol_all
);
2600 (*current
)->name
= name
;
2605 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2606 bfd_print_symbol_all
);
2616 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2619 char *last_filename
, *last_functionname
;
2620 unsigned int last_line
;
2622 /* Get column headers lined up reasonably. */
2630 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2631 width
= strlen (buf
) - 7;
2633 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2636 last_filename
= NULL
;
2637 last_functionname
= NULL
;
2640 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2643 const char *filename
, *functionname
;
2645 const char *sym_name
;
2646 const char *section_name
;
2648 if (start_address
!= (bfd_vma
) -1
2649 && q
->address
< start_address
)
2651 if (stop_address
!= (bfd_vma
) -1
2652 && q
->address
> stop_address
)
2655 if (with_line_numbers
2657 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2658 &filename
, &functionname
, &line
))
2660 if (functionname
!= NULL
2661 && (last_functionname
== NULL
2662 || strcmp (functionname
, last_functionname
) != 0))
2664 printf ("%s():\n", functionname
);
2665 if (last_functionname
!= NULL
)
2666 free (last_functionname
);
2667 last_functionname
= xstrdup (functionname
);
2671 && (line
!= last_line
2672 || (filename
!= NULL
2673 && last_filename
!= NULL
2674 && strcmp (filename
, last_filename
) != 0)))
2676 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2678 if (last_filename
!= NULL
)
2679 free (last_filename
);
2680 if (filename
== NULL
)
2681 last_filename
= NULL
;
2683 last_filename
= xstrdup (filename
);
2687 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2689 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2690 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2695 section_name
= NULL
;
2698 bfd_printf_vma (abfd
, q
->address
);
2699 if (q
->howto
== NULL
)
2700 printf (" *unknown* ");
2701 else if (q
->howto
->name
)
2702 printf (" %-16s ", q
->howto
->name
);
2704 printf (" %-16d ", q
->howto
->type
);
2706 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2709 if (section_name
== NULL
)
2710 section_name
= "*unknown*";
2711 printf ("[%s]", section_name
);
2717 bfd_printf_vma (abfd
, q
->addend
);
2725 dump_relocs_in_section (bfd
*abfd
,
2727 void *dummy ATTRIBUTE_UNUSED
)
2733 if ( bfd_is_abs_section (section
)
2734 || bfd_is_und_section (section
)
2735 || bfd_is_com_section (section
)
2736 || (! process_section_p (section
))
2737 || ((section
->flags
& SEC_RELOC
) == 0))
2740 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2742 bfd_fatal (bfd_get_filename (abfd
));
2744 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2748 printf (" (none)\n\n");
2752 relpp
= xmalloc (relsize
);
2753 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2756 bfd_fatal (bfd_get_filename (abfd
));
2757 else if (relcount
== 0)
2758 printf (" (none)\n\n");
2762 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2769 dump_relocs (bfd
*abfd
)
2771 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2775 dump_dynamic_relocs (bfd
*abfd
)
2781 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2783 bfd_fatal (bfd_get_filename (abfd
));
2785 printf ("DYNAMIC RELOCATION RECORDS");
2788 printf (" (none)\n\n");
2791 relpp
= xmalloc (relsize
);
2792 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2795 bfd_fatal (bfd_get_filename (abfd
));
2796 else if (relcount
== 0)
2797 printf (" (none)\n\n");
2801 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2808 /* Creates a table of paths, to search for source files. */
2811 add_include_path (const char *path
)
2815 include_path_count
++;
2816 include_paths
= xrealloc (include_paths
,
2817 include_path_count
* sizeof (*include_paths
));
2818 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2819 if (path
[1] == ':' && path
[2] == 0)
2820 path
= concat (path
, ".", (const char *) 0);
2822 include_paths
[include_path_count
- 1] = path
;
2826 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2830 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2832 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2833 section
->vma
+= adjust_section_vma
;
2835 section
->lma
+= adjust_section_vma
;
2839 /* Dump selected contents of ABFD. */
2842 dump_bfd (bfd
*abfd
)
2844 /* If we are adjusting section VMA's, change them all now. Changing
2845 the BFD information is a hack. However, we must do it, or
2846 bfd_find_nearest_line will not do the right thing. */
2847 if (adjust_section_vma
!= 0)
2849 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2850 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2853 if (! dump_debugging_tags
)
2854 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2857 print_arelt_descr (stdout
, abfd
, TRUE
);
2858 if (dump_file_header
)
2859 dump_bfd_header (abfd
);
2860 if (dump_private_headers
)
2861 dump_bfd_private_header (abfd
);
2862 if (! dump_debugging_tags
)
2864 if (dump_section_headers
)
2865 dump_headers (abfd
);
2871 || dump_dwarf_section_info
)
2872 syms
= slurp_symtab (abfd
);
2873 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2874 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2875 dynsyms
= slurp_dynamic_symtab (abfd
);
2878 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2879 dynsymcount
, dynsyms
, &synthsyms
);
2885 dump_symbols (abfd
, FALSE
);
2886 if (dump_dynamic_symtab
)
2887 dump_symbols (abfd
, TRUE
);
2888 if (dump_dwarf_section_info
)
2890 if (dump_stab_section_info
)
2892 if (dump_reloc_info
&& ! disassemble
)
2894 if (dump_dynamic_reloc_info
&& ! disassemble
)
2895 dump_dynamic_relocs (abfd
);
2896 if (dump_section_contents
)
2899 disassemble_data (abfd
);
2905 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2906 if (dhandle
!= NULL
)
2908 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2910 dump_debugging_tags
? TRUE
: FALSE
))
2912 non_fatal (_("%s: printing debugging information failed"),
2913 bfd_get_filename (abfd
));
2943 display_bfd (bfd
*abfd
)
2947 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2953 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2955 nonfatal (bfd_get_filename (abfd
));
2956 list_matching_formats (matching
);
2961 if (bfd_get_error () != bfd_error_file_not_recognized
)
2963 nonfatal (bfd_get_filename (abfd
));
2967 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2973 nonfatal (bfd_get_filename (abfd
));
2975 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2977 list_matching_formats (matching
);
2983 display_file (char *filename
, char *target
)
2988 if (get_file_size (filename
) < 1)
2994 file
= bfd_openr (filename
, target
);
2997 nonfatal (filename
);
3001 /* If the file is an archive, process all of its elements. */
3002 if (bfd_check_format (file
, bfd_archive
))
3004 bfd
*last_arfile
= NULL
;
3006 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3009 bfd_set_error (bfd_error_no_error
);
3011 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3014 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3015 nonfatal (bfd_get_filename (file
));
3019 display_bfd (arfile
);
3021 if (last_arfile
!= NULL
)
3022 bfd_close (last_arfile
);
3023 last_arfile
= arfile
;
3026 if (last_arfile
!= NULL
)
3027 bfd_close (last_arfile
);
3036 main (int argc
, char **argv
)
3039 char *target
= default_target
;
3040 bfd_boolean seenflag
= FALSE
;
3042 #if defined (HAVE_SETLOCALE)
3043 #if defined (HAVE_LC_MESSAGES)
3044 setlocale (LC_MESSAGES
, "");
3046 setlocale (LC_CTYPE
, "");
3049 bindtextdomain (PACKAGE
, LOCALEDIR
);
3050 textdomain (PACKAGE
);
3052 program_name
= *argv
;
3053 xmalloc_set_program_name (program_name
);
3055 START_PROGRESS (program_name
, 0);
3057 expandargv (&argc
, &argv
);
3060 set_default_bfd_target ();
3062 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3063 long_options
, (int *) 0))
3069 break; /* We've been given a long option. */
3074 if (disassembler_options
)
3075 /* Ignore potential memory leak for now. */
3076 disassembler_options
= concat (disassembler_options
, ",",
3079 disassembler_options
= optarg
;
3082 if (only_used
== only_size
)
3085 only
= xrealloc (only
, only_size
* sizeof (char *));
3087 only
[only_used
++] = optarg
;
3090 with_line_numbers
= TRUE
;
3099 enum demangling_styles style
;
3101 style
= cplus_demangle_name_to_style (optarg
);
3102 if (style
== unknown_demangling
)
3103 fatal (_("unknown demangling style `%s'"),
3106 cplus_demangle_set_style (style
);
3112 case OPTION_ADJUST_VMA
:
3113 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3115 case OPTION_START_ADDRESS
:
3116 start_address
= parse_vma (optarg
, "--start-address");
3118 case OPTION_STOP_ADDRESS
:
3119 stop_address
= parse_vma (optarg
, "--stop-address");
3122 if (strcmp (optarg
, "B") == 0)
3123 endian
= BFD_ENDIAN_BIG
;
3124 else if (strcmp (optarg
, "L") == 0)
3125 endian
= BFD_ENDIAN_LITTLE
;
3128 non_fatal (_("unrecognized -E option"));
3133 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3134 endian
= BFD_ENDIAN_BIG
;
3135 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3136 endian
= BFD_ENDIAN_LITTLE
;
3139 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3145 dump_file_header
= TRUE
;
3149 formats_info
= TRUE
;
3153 add_include_path (optarg
);
3156 dump_private_headers
= TRUE
;
3160 dump_private_headers
= TRUE
;
3162 dump_reloc_info
= TRUE
;
3163 dump_file_header
= TRUE
;
3164 dump_ar_hdrs
= TRUE
;
3165 dump_section_headers
= TRUE
;
3173 dump_dynamic_symtab
= TRUE
;
3181 disassemble_zeroes
= TRUE
;
3185 disassemble_all
= TRUE
;
3190 with_source_code
= TRUE
;
3199 dump_debugging_tags
= 1;
3204 dump_dwarf_section_info
= TRUE
;
3207 do_debug_abbrevs
= 1;
3209 do_debug_pubnames
= 1;
3210 do_debug_aranges
= 1;
3211 do_debug_ranges
= 1;
3212 do_debug_frames
= 1;
3213 do_debug_macinfo
= 1;
3218 dump_stab_section_info
= TRUE
;
3222 dump_section_contents
= TRUE
;
3226 dump_reloc_info
= TRUE
;
3230 dump_dynamic_reloc_info
= TRUE
;
3234 dump_ar_hdrs
= TRUE
;
3238 dump_section_headers
= TRUE
;
3246 show_version
= TRUE
;
3256 print_version ("objdump");
3262 exit_status
= display_info ();
3266 display_file ("a.out", target
);
3268 for (; optind
< argc
;)
3269 display_file (argv
[optind
++], target
);
3272 END_PROGRESS (program_name
);