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
)
1135 if (line
>= p
->maxline
)
1137 l
= p
->linemap
[line
];
1138 fwrite (l
, 1, strcspn (l
, "\n\r"), stdout
);
1142 /* Print a range of source code lines. */
1145 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1149 while (start
<= end
)
1151 print_line (p
, start
);
1156 /* Show the line number, or the source line, in a disassembly
1160 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1162 const char *filename
;
1163 const char *functionname
;
1166 if (! with_line_numbers
&& ! with_source_code
)
1169 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1170 &functionname
, &line
))
1173 if (filename
!= NULL
&& *filename
== '\0')
1175 if (functionname
!= NULL
&& *functionname
== '\0')
1176 functionname
= NULL
;
1178 if (with_line_numbers
)
1180 if (functionname
!= NULL
1181 && (prev_functionname
== NULL
1182 || strcmp (functionname
, prev_functionname
) != 0))
1183 printf ("%s():\n", functionname
);
1184 if (line
> 0 && line
!= prev_line
)
1185 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1188 if (with_source_code
1192 struct print_file_list
**pp
, *p
;
1195 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1196 if (strcmp ((*pp
)->filename
, filename
) == 0)
1201 p
= update_source_path (filename
);
1203 if (p
!= NULL
&& line
!= p
->last_line
)
1205 if (file_start_context
&& p
->first
)
1209 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1212 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1213 l
= p
->last_line
+ 1;
1215 dump_lines (p
, l
, line
);
1216 p
->last_line
= line
;
1221 if (functionname
!= NULL
1222 && (prev_functionname
== NULL
1223 || strcmp (functionname
, prev_functionname
) != 0))
1225 if (prev_functionname
!= NULL
)
1226 free (prev_functionname
);
1227 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1228 strcpy (prev_functionname
, functionname
);
1231 if (line
> 0 && line
!= prev_line
)
1235 /* Pseudo FILE object for strings. */
1243 /* sprintf to a "stream". */
1245 static int ATTRIBUTE_PRINTF_2
1246 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1253 size_t space
= f
->alloc
- f
->pos
;
1255 va_start (args
, format
);
1256 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1262 f
->alloc
= (f
->alloc
+ n
) * 2;
1263 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1270 /* Returns TRUE if the specified section should be dumped. */
1273 process_section_p (asection
* section
)
1280 for (i
= 0; i
< only_used
; i
++)
1281 if (strcmp (only
[i
], section
->name
) == 0)
1288 /* The number of zeroes we want to see before we start skipping them.
1289 The number is arbitrarily chosen. */
1291 #define DEFAULT_SKIP_ZEROES 8
1293 /* The number of zeroes to skip at the end of a section. If the
1294 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1295 SKIP_ZEROES, they will be disassembled. If there are fewer than
1296 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1297 attempt to avoid disassembling zeroes inserted by section
1300 #define DEFAULT_SKIP_ZEROES_AT_END 3
1302 /* Disassemble some data in memory between given values. */
1305 disassemble_bytes (struct disassemble_info
* info
,
1306 disassembler_ftype disassemble_fn
,
1309 bfd_vma start_offset
,
1310 bfd_vma stop_offset
,
1313 arelent
** relppend
)
1315 struct objdump_disasm_info
*aux
;
1317 int octets_per_line
;
1318 bfd_boolean done_dot
;
1319 int skip_addr_chars
;
1320 bfd_vma addr_offset
;
1321 unsigned int opb
= info
->octets_per_byte
;
1322 unsigned int skip_zeroes
= info
->skip_zeroes
;
1323 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1327 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1331 sfile
.buffer
= xmalloc (sfile
.alloc
);
1335 octets_per_line
= 4;
1337 octets_per_line
= 16;
1339 /* Figure out how many characters to skip at the start of an
1340 address, to make the disassembly look nicer. We discard leading
1341 zeroes in chunks of 4, ensuring that there is always a leading
1343 skip_addr_chars
= 0;
1344 if (! prefix_addresses
)
1352 + bfd_section_size (section
->owner
, section
) / opb
));
1354 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1357 skip_addr_chars
+= 4;
1362 info
->insn_info_valid
= 0;
1365 addr_offset
= start_offset
;
1366 while (addr_offset
< stop_offset
)
1369 bfd_boolean need_nl
= FALSE
;
1370 int previous_octets
;
1372 /* Remember the length of the previous instruction. */
1373 previous_octets
= octets
;
1376 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1378 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1381 if (! disassemble_zeroes
1382 && (info
->insn_info_valid
== 0
1383 || info
->branch_delay_insns
== 0)
1384 && (z
- addr_offset
* opb
>= skip_zeroes
1385 || (z
== stop_offset
* opb
&&
1386 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1390 /* If there are more nonzero octets to follow, we only skip
1391 zeroes in multiples of 4, to try to avoid running over
1392 the start of an instruction which happens to start with
1394 if (z
!= stop_offset
* opb
)
1395 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1397 octets
= z
- addr_offset
* opb
;
1407 if (with_line_numbers
|| with_source_code
)
1408 show_line (aux
->abfd
, section
, addr_offset
);
1410 if (! prefix_addresses
)
1414 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1415 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1419 printf ("%s:\t", buf
+ skip_addr_chars
);
1423 aux
->require_sec
= TRUE
;
1424 objdump_print_address (section
->vma
+ addr_offset
, info
);
1425 aux
->require_sec
= FALSE
;
1432 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1433 info
->stream
= &sfile
;
1434 info
->bytes_per_line
= 0;
1435 info
->bytes_per_chunk
= 0;
1438 if (info
->disassembler_needs_relocs
1439 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1440 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1441 && *relppp
< relppend
)
1443 bfd_signed_vma distance_to_rel
;
1445 distance_to_rel
= (**relppp
)->address
1446 - (rel_offset
+ addr_offset
);
1448 /* Check to see if the current reloc is associated with
1449 the instruction that we are about to disassemble. */
1450 if (distance_to_rel
== 0
1451 /* FIXME: This is wrong. We are trying to catch
1452 relocs that are addressed part way through the
1453 current instruction, as might happen with a packed
1454 VLIW instruction. Unfortunately we do not know the
1455 length of the current instruction since we have not
1456 disassembled it yet. Instead we take a guess based
1457 upon the length of the previous instruction. The
1458 proper solution is to have a new target-specific
1459 disassembler function which just returns the length
1460 of an instruction at a given address without trying
1461 to display its disassembly. */
1462 || (distance_to_rel
> 0
1463 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1465 info
->flags
= INSN_HAS_RELOC
;
1466 aux
->reloc
= **relppp
;
1472 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1473 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1474 info
->stream
= stdout
;
1475 if (info
->bytes_per_line
!= 0)
1476 octets_per_line
= info
->bytes_per_line
;
1480 printf ("%s\n", sfile
.buffer
);
1488 octets
= octets_per_line
;
1489 if (addr_offset
+ octets
/ opb
> stop_offset
)
1490 octets
= (stop_offset
- addr_offset
) * opb
;
1492 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1494 if (ISPRINT (data
[j
]))
1495 buf
[j
- addr_offset
* opb
] = data
[j
];
1497 buf
[j
- addr_offset
* opb
] = '.';
1499 buf
[j
- addr_offset
* opb
] = '\0';
1502 if (prefix_addresses
1504 : show_raw_insn
>= 0)
1508 /* If ! prefix_addresses and ! wide_output, we print
1509 octets_per_line octets per line. */
1511 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1512 pb
= octets_per_line
;
1514 if (info
->bytes_per_chunk
)
1515 bpc
= info
->bytes_per_chunk
;
1519 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1523 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1525 for (k
= bpc
- 1; k
>= 0; k
--)
1526 printf ("%02x", (unsigned) data
[j
+ k
]);
1531 for (k
= 0; k
< bpc
; k
++)
1532 printf ("%02x", (unsigned) data
[j
+ k
]);
1537 for (; pb
< octets_per_line
; pb
+= bpc
)
1541 for (k
= 0; k
< bpc
; k
++)
1546 /* Separate raw data from instruction by extra space. */
1556 printf ("%s", sfile
.buffer
);
1558 if (prefix_addresses
1560 : show_raw_insn
>= 0)
1568 j
= addr_offset
* opb
+ pb
;
1570 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1571 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1575 printf ("%s:\t", buf
+ skip_addr_chars
);
1577 pb
+= octets_per_line
;
1580 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1584 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1586 for (k
= bpc
- 1; k
>= 0; k
--)
1587 printf ("%02x", (unsigned) data
[j
+ k
]);
1592 for (k
= 0; k
< bpc
; k
++)
1593 printf ("%02x", (unsigned) data
[j
+ k
]);
1606 while ((*relppp
) < relppend
1607 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1609 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1620 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1623 if (q
->howto
== NULL
)
1624 printf (": *unknown*\t");
1625 else if (q
->howto
->name
)
1626 printf (": %s\t", q
->howto
->name
);
1628 printf (": %d\t", q
->howto
->type
);
1630 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1631 printf ("*unknown*");
1634 const char *sym_name
;
1636 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1637 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1638 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1643 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1644 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1645 if (sym_name
== NULL
|| *sym_name
== '\0')
1646 sym_name
= "*unknown*";
1647 printf ("%s", sym_name
);
1654 objdump_print_value (q
->addend
, info
, TRUE
);
1666 addr_offset
+= octets
/ opb
;
1669 free (sfile
.buffer
);
1673 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1675 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1676 struct objdump_disasm_info
* paux
;
1677 unsigned int opb
= pinfo
->octets_per_byte
;
1678 bfd_byte
* data
= NULL
;
1679 bfd_size_type datasize
= 0;
1680 arelent
** rel_pp
= NULL
;
1681 arelent
** rel_ppstart
= NULL
;
1682 arelent
** rel_ppend
;
1683 unsigned long stop_offset
;
1684 asymbol
* sym
= NULL
;
1688 unsigned long addr_offset
;
1690 /* Sections that do not contain machine
1691 code are not normally disassembled. */
1692 if (! disassemble_all
1694 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1695 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1698 if (! process_section_p (section
))
1701 datasize
= bfd_get_section_size (section
);
1705 /* Decide which set of relocs to use. Load them if necessary. */
1706 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1707 if (paux
->dynrelbuf
)
1709 rel_pp
= paux
->dynrelbuf
;
1710 rel_count
= paux
->dynrelcount
;
1711 /* Dynamic reloc addresses are absolute, non-dynamic are section
1712 relative. REL_OFFSET specifies the reloc address corresponding
1713 to the start of this section. */
1714 rel_offset
= section
->vma
;
1722 if ((section
->flags
& SEC_RELOC
) != 0
1723 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1727 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1729 bfd_fatal (bfd_get_filename (abfd
));
1733 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1734 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1736 bfd_fatal (bfd_get_filename (abfd
));
1738 /* Sort the relocs by address. */
1739 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1744 rel_ppend
= rel_pp
+ rel_count
;
1746 data
= xmalloc (datasize
);
1748 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1750 paux
->sec
= section
;
1751 pinfo
->buffer
= data
;
1752 pinfo
->buffer_vma
= section
->vma
;
1753 pinfo
->buffer_length
= datasize
;
1754 pinfo
->section
= section
;
1756 if (start_address
== (bfd_vma
) -1
1757 || start_address
< pinfo
->buffer_vma
)
1760 addr_offset
= start_address
- pinfo
->buffer_vma
;
1762 if (stop_address
== (bfd_vma
) -1)
1763 stop_offset
= datasize
/ opb
;
1766 if (stop_address
< pinfo
->buffer_vma
)
1769 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1770 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1771 stop_offset
= pinfo
->buffer_length
/ opb
;
1774 /* Skip over the relocs belonging to addresses below the
1776 while (rel_pp
< rel_ppend
1777 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1780 printf (_("Disassembly of section %s:\n"), section
->name
);
1782 /* Find the nearest symbol forwards from our current position. */
1783 paux
->require_sec
= TRUE
;
1784 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1785 paux
->require_sec
= FALSE
;
1787 /* Disassemble a block of instructions up to the address associated with
1788 the symbol we have just found. Then print the symbol and find the
1789 next symbol on. Repeat until we have disassembled the entire section
1790 or we have reached the end of the address range we are interested in. */
1791 while (addr_offset
< stop_offset
)
1795 unsigned long nextstop_offset
;
1798 addr
= section
->vma
+ addr_offset
;
1800 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1805 (x
< sorted_symcount
1806 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1810 pinfo
->symbols
= sorted_syms
+ place
;
1811 pinfo
->num_symbols
= x
- place
;
1812 pinfo
->symtab_pos
= place
;
1816 pinfo
->symbols
= NULL
;
1817 pinfo
->num_symbols
= 0;
1818 pinfo
->symtab_pos
= -1;
1821 if (! prefix_addresses
)
1823 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1824 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1826 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1829 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1831 else if (sym
== NULL
)
1835 #define is_valid_next_sym(SYM) \
1836 ((SYM)->section == section \
1837 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1838 && pinfo->symbol_is_valid (SYM, pinfo))
1840 /* Search forward for the next appropriate symbol in
1841 SECTION. Note that all the symbols are sorted
1842 together into one big array, and that some sections
1843 may have overlapping addresses. */
1844 while (place
< sorted_symcount
1845 && ! is_valid_next_sym (sorted_syms
[place
]))
1848 if (place
>= sorted_symcount
)
1851 nextsym
= sorted_syms
[place
];
1854 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1855 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1856 else if (nextsym
== NULL
)
1857 nextstop_offset
= stop_offset
;
1859 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1861 if (nextstop_offset
> stop_offset
)
1862 nextstop_offset
= stop_offset
;
1864 /* If a symbol is explicitly marked as being an object
1865 rather than a function, just dump the bytes without
1866 disassembling them. */
1869 || bfd_asymbol_value (sym
) > addr
1870 || ((sym
->flags
& BSF_OBJECT
) == 0
1871 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1873 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1875 || (sym
->flags
& BSF_FUNCTION
) != 0)
1880 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1881 addr_offset
, nextstop_offset
,
1882 rel_offset
, &rel_pp
, rel_ppend
);
1884 addr_offset
= nextstop_offset
;
1890 if (rel_ppstart
!= NULL
)
1894 /* Disassemble the contents of an object file. */
1897 disassemble_data (bfd
*abfd
)
1899 struct disassemble_info disasm_info
;
1900 struct objdump_disasm_info aux
;
1904 prev_functionname
= NULL
;
1907 /* We make a copy of syms to sort. We don't want to sort syms
1908 because that will screw up the relocs. */
1909 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1910 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1911 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1912 sorted_symcount
* sizeof (asymbol
*));
1914 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1916 for (i
= 0; i
< synthcount
; ++i
)
1918 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1922 /* Sort the symbols into section and symbol order. */
1923 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1925 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1927 disasm_info
.application_data
= (void *) &aux
;
1929 aux
.require_sec
= FALSE
;
1930 aux
.dynrelbuf
= NULL
;
1931 aux
.dynrelcount
= 0;
1934 disasm_info
.print_address_func
= objdump_print_address
;
1935 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1937 if (machine
!= NULL
)
1939 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1942 fatal (_("Can't use supplied machine %s"), machine
);
1944 abfd
->arch_info
= info
;
1947 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1949 struct bfd_target
*xvec
;
1951 xvec
= xmalloc (sizeof (struct bfd_target
));
1952 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1953 xvec
->byteorder
= endian
;
1957 /* Use libopcodes to locate a suitable disassembler. */
1958 aux
.disassemble_fn
= disassembler (abfd
);
1959 if (!aux
.disassemble_fn
)
1961 non_fatal (_("Can't disassemble for architecture %s\n"),
1962 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1967 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1968 disasm_info
.arch
= bfd_get_arch (abfd
);
1969 disasm_info
.mach
= bfd_get_mach (abfd
);
1970 disasm_info
.disassembler_options
= disassembler_options
;
1971 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1972 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1973 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1974 disasm_info
.disassembler_needs_relocs
= FALSE
;
1976 if (bfd_big_endian (abfd
))
1977 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1978 else if (bfd_little_endian (abfd
))
1979 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1981 /* ??? Aborting here seems too drastic. We could default to big or little
1983 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1985 /* Allow the target to customize the info structure. */
1986 disassemble_init_for_target (& disasm_info
);
1988 /* Pre-load the dynamic relocs if we are going
1989 to be dumping them along with the disassembly. */
1990 if (dump_dynamic_reloc_info
)
1992 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1995 bfd_fatal (bfd_get_filename (abfd
));
1999 aux
.dynrelbuf
= xmalloc (relsize
);
2000 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2003 if (aux
.dynrelcount
< 0)
2004 bfd_fatal (bfd_get_filename (abfd
));
2006 /* Sort the relocs by address. */
2007 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2011 disasm_info
.symtab
= sorted_syms
;
2012 disasm_info
.symtab_size
= sorted_symcount
;
2014 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2016 if (aux
.dynrelbuf
!= NULL
)
2017 free (aux
.dynrelbuf
);
2022 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2024 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2029 /* If it is already loaded, do nothing. */
2030 if (section
->start
!= NULL
)
2033 /* Locate the debug section. */
2034 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2038 /* Compute a bias to be added to offsets found within the DWARF debug
2039 information. These offsets are meant to be relative to the start of
2040 the dwarf section, and hence the bias should be 0. For MACH-O however
2041 a dwarf section is really just a region of a much larger section and so
2042 the bias is the address of the start of that area within the larger
2043 section. This test is important for PE and COFF based targets which
2044 use DWARF debug information, since unlike ELF, they do not allow the
2045 dwarf sections to be placed at address 0. */
2046 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2047 section
->address
= bfd_get_section_vma (abfd
, sec
);
2049 section
->address
= 0;
2051 section
->size
= bfd_get_section_size (sec
);
2052 section
->start
= xmalloc (section
->size
);
2054 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2055 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2060 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2065 free_debug_section (debug
);
2066 printf (_("\nCan't get contents for section '%s'.\n"),
2074 free_debug_section (enum dwarf_section_display_enum debug
)
2076 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2078 if (section
->start
== NULL
)
2081 free ((char *) section
->start
);
2082 section
->start
= NULL
;
2083 section
->address
= 0;
2088 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2089 void *arg ATTRIBUTE_UNUSED
)
2091 const char *name
= bfd_get_section_name (abfd
, section
);
2093 enum dwarf_section_display_enum i
;
2095 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2096 match
= ".debug_info";
2100 for (i
= 0; i
< max
; i
++)
2101 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2103 if (!debug_displays
[i
].eh_frame
)
2105 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2107 if (load_debug_section (i
, abfd
))
2109 debug_displays
[i
].display (sec
, abfd
);
2111 if (i
!= info
&& i
!= abbrev
)
2112 free_debug_section (i
);
2119 static const char *mach_o_dwarf_sections
[] = {
2120 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2121 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2122 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2123 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2124 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2125 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2126 ".eh_frame", /* .eh_frame */
2127 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2128 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2129 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2130 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2131 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2132 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2133 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2134 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2135 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2138 static const char *generic_dwarf_sections
[max
];
2141 check_mach_o_dwarf (bfd
*abfd
)
2143 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2144 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2145 enum dwarf_section_display_enum i
;
2147 if (generic_dwarf_sections
[0] == NULL
)
2148 for (i
= 0; i
< max
; i
++)
2149 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2151 if (old_flavour
!= current_flavour
)
2153 if (current_flavour
== bfd_target_mach_o_flavour
)
2154 for (i
= 0; i
< max
; i
++)
2155 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2156 else if (old_flavour
== bfd_target_mach_o_flavour
)
2157 for (i
= 0; i
< max
; i
++)
2158 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2160 old_flavour
= current_flavour
;
2164 /* Dump the dwarf debugging information. */
2167 dump_dwarf (bfd
*abfd
)
2169 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2172 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2173 targets will return 64. */
2174 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2176 if (bfd_big_endian (abfd
))
2177 byte_get
= byte_get_big_endian
;
2178 else if (bfd_little_endian (abfd
))
2179 byte_get
= byte_get_little_endian
;
2183 check_mach_o_dwarf (abfd
);
2185 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2187 free_debug_memory ();
2190 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2191 it. Return NULL on failure. */
2194 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2200 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2201 if (stabsect
== NULL
)
2203 printf (_("No %s section present\n\n"), sect_name
);
2207 size
= bfd_section_size (abfd
, stabsect
);
2208 contents
= xmalloc (size
);
2210 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2212 non_fatal (_("Reading %s section of %s failed: %s"),
2213 sect_name
, bfd_get_filename (abfd
),
2214 bfd_errmsg (bfd_get_error ()));
2225 /* Stabs entries use a 12 byte format:
2226 4 byte string table index
2228 1 byte stab other field
2229 2 byte stab desc field
2231 FIXME: This will have to change for a 64 bit object format. */
2233 #define STRDXOFF (0)
2235 #define OTHEROFF (5)
2238 #define STABSIZE (12)
2240 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2241 using string table section STRSECT_NAME (in `strtab'). */
2244 print_section_stabs (bfd
*abfd
,
2245 const char *stabsect_name
,
2246 unsigned *string_offset_ptr
)
2249 unsigned file_string_table_offset
= 0;
2250 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2251 bfd_byte
*stabp
, *stabs_end
;
2254 stabs_end
= stabp
+ stab_size
;
2256 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2257 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2259 /* Loop through all symbols and print them.
2261 We start the index at -1 because there is a dummy symbol on
2262 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2263 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2267 unsigned char type
, other
;
2268 unsigned short desc
;
2271 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2272 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2273 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2274 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2275 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2277 printf ("\n%-6d ", i
);
2278 /* Either print the stab name, or, if unnamed, print its number
2279 again (makes consistent formatting for tools like awk). */
2280 name
= bfd_get_stab_name (type
);
2282 printf ("%-6s", name
);
2283 else if (type
== N_UNDF
)
2286 printf ("%-6d", type
);
2287 printf (" %-6d %-6d ", other
, desc
);
2288 bfd_printf_vma (abfd
, value
);
2289 printf (" %-6lu", strx
);
2291 /* Symbols with type == 0 (N_UNDF) specify the length of the
2292 string table associated with this file. We use that info
2293 to know how to relocate the *next* file's string table indices. */
2296 file_string_table_offset
= next_file_string_table_offset
;
2297 next_file_string_table_offset
+= value
;
2301 /* Using the (possibly updated) string table offset, print the
2302 string (if any) associated with this symbol. */
2303 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2304 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2310 *string_offset_ptr
= next_file_string_table_offset
;
2315 const char * section_name
;
2316 const char * string_section_name
;
2317 unsigned string_offset
;
2322 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2325 stab_section_names
* sought
= (stab_section_names
*) names
;
2327 /* Check for section names for which stabsect_name is a prefix, to
2328 handle .stab.N, etc. */
2329 len
= strlen (sought
->section_name
);
2331 /* If the prefix matches, and the files section name ends with a
2332 nul or a digit, then we match. I.e., we want either an exact
2333 match or a section followed by a number. */
2334 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2335 && (section
->name
[len
] == 0
2336 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2339 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2344 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2347 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2353 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2355 stab_section_names s
;
2357 s
.section_name
= stabsect_name
;
2358 s
.string_section_name
= strsect_name
;
2359 s
.string_offset
= 0;
2361 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2367 /* Dump the any sections containing stabs debugging information. */
2370 dump_stabs (bfd
*abfd
)
2372 dump_stabs_section (abfd
, ".stab", ".stabstr");
2373 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2374 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2375 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2379 dump_bfd_header (bfd
*abfd
)
2383 printf (_("architecture: %s, "),
2384 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2385 bfd_get_mach (abfd
)));
2386 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2388 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2389 PF (HAS_RELOC
, "HAS_RELOC");
2390 PF (EXEC_P
, "EXEC_P");
2391 PF (HAS_LINENO
, "HAS_LINENO");
2392 PF (HAS_DEBUG
, "HAS_DEBUG");
2393 PF (HAS_SYMS
, "HAS_SYMS");
2394 PF (HAS_LOCALS
, "HAS_LOCALS");
2395 PF (DYNAMIC
, "DYNAMIC");
2396 PF (WP_TEXT
, "WP_TEXT");
2397 PF (D_PAGED
, "D_PAGED");
2398 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2399 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2400 printf (_("\nstart address 0x"));
2401 bfd_printf_vma (abfd
, abfd
->start_address
);
2407 dump_bfd_private_header (bfd
*abfd
)
2409 bfd_print_private_bfd_data (abfd
, stdout
);
2413 /* Display a section in hexadecimal format with associated characters.
2414 Each line prefixed by the zero padded address. */
2417 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2420 bfd_size_type datasize
;
2421 bfd_size_type addr_offset
;
2422 bfd_size_type start_offset
;
2423 bfd_size_type stop_offset
;
2424 unsigned int opb
= bfd_octets_per_byte (abfd
);
2425 /* Bytes per line. */
2426 const int onaline
= 16;
2431 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2434 if (! process_section_p (section
))
2437 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2440 printf (_("Contents of section %s:\n"), section
->name
);
2442 data
= xmalloc (datasize
);
2444 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2446 /* Compute the address range to display. */
2447 if (start_address
== (bfd_vma
) -1
2448 || start_address
< section
->vma
)
2451 start_offset
= start_address
- section
->vma
;
2453 if (stop_address
== (bfd_vma
) -1)
2454 stop_offset
= datasize
/ opb
;
2457 if (stop_address
< section
->vma
)
2460 stop_offset
= stop_address
- section
->vma
;
2462 if (stop_offset
> datasize
/ opb
)
2463 stop_offset
= datasize
/ opb
;
2468 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2469 if (strlen (buf
) >= sizeof (buf
))
2473 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2475 count
= strlen (buf
) - count
;
2479 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2480 if (strlen (buf
) >= sizeof (buf
))
2484 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2486 count
= strlen (buf
) - count
;
2490 for (addr_offset
= start_offset
;
2491 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2495 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2496 count
= strlen (buf
);
2497 if ((size_t) count
>= sizeof (buf
))
2501 while (count
< width
)
2506 fputs (buf
+ count
- width
, stdout
);
2509 for (j
= addr_offset
* opb
;
2510 j
< addr_offset
* opb
+ onaline
; j
++)
2512 if (j
< stop_offset
* opb
)
2513 printf ("%02x", (unsigned) (data
[j
]));
2521 for (j
= addr_offset
* opb
;
2522 j
< addr_offset
* opb
+ onaline
; j
++)
2524 if (j
>= stop_offset
* opb
)
2527 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2534 /* Actually display the various requested regions. */
2537 dump_data (bfd
*abfd
)
2539 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2542 /* Should perhaps share code and display with nm? */
2545 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2555 printf ("DYNAMIC SYMBOL TABLE:\n");
2561 printf ("SYMBOL TABLE:\n");
2565 printf (_("no symbols\n"));
2567 for (count
= 0; count
< max
; count
++)
2571 if (*current
== NULL
)
2572 printf (_("no information for symbol number %ld\n"), count
);
2574 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2575 printf (_("could not determine the type of symbol number %ld\n"),
2578 else if (process_section_p ((* current
)->section
)
2579 && (dump_special_syms
2580 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2582 const char *name
= (*current
)->name
;
2584 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2588 /* If we want to demangle the name, we demangle it
2589 here, and temporarily clobber it while calling
2590 bfd_print_symbol. FIXME: This is a gross hack. */
2591 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2593 (*current
)->name
= alloc
;
2594 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2595 bfd_print_symbol_all
);
2598 (*current
)->name
= name
;
2603 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2604 bfd_print_symbol_all
);
2614 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2617 char *last_filename
, *last_functionname
;
2618 unsigned int last_line
;
2620 /* Get column headers lined up reasonably. */
2628 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2629 width
= strlen (buf
) - 7;
2631 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2634 last_filename
= NULL
;
2635 last_functionname
= NULL
;
2638 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2641 const char *filename
, *functionname
;
2643 const char *sym_name
;
2644 const char *section_name
;
2646 if (start_address
!= (bfd_vma
) -1
2647 && q
->address
< start_address
)
2649 if (stop_address
!= (bfd_vma
) -1
2650 && q
->address
> stop_address
)
2653 if (with_line_numbers
2655 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2656 &filename
, &functionname
, &line
))
2658 if (functionname
!= NULL
2659 && (last_functionname
== NULL
2660 || strcmp (functionname
, last_functionname
) != 0))
2662 printf ("%s():\n", functionname
);
2663 if (last_functionname
!= NULL
)
2664 free (last_functionname
);
2665 last_functionname
= xstrdup (functionname
);
2669 && (line
!= last_line
2670 || (filename
!= NULL
2671 && last_filename
!= NULL
2672 && strcmp (filename
, last_filename
) != 0)))
2674 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2676 if (last_filename
!= NULL
)
2677 free (last_filename
);
2678 if (filename
== NULL
)
2679 last_filename
= NULL
;
2681 last_filename
= xstrdup (filename
);
2685 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2687 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2688 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2693 section_name
= NULL
;
2696 bfd_printf_vma (abfd
, q
->address
);
2697 if (q
->howto
== NULL
)
2698 printf (" *unknown* ");
2699 else if (q
->howto
->name
)
2700 printf (" %-16s ", q
->howto
->name
);
2702 printf (" %-16d ", q
->howto
->type
);
2704 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2707 if (section_name
== NULL
)
2708 section_name
= "*unknown*";
2709 printf ("[%s]", section_name
);
2715 bfd_printf_vma (abfd
, q
->addend
);
2723 dump_relocs_in_section (bfd
*abfd
,
2725 void *dummy ATTRIBUTE_UNUSED
)
2731 if ( bfd_is_abs_section (section
)
2732 || bfd_is_und_section (section
)
2733 || bfd_is_com_section (section
)
2734 || (! process_section_p (section
))
2735 || ((section
->flags
& SEC_RELOC
) == 0))
2738 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2740 bfd_fatal (bfd_get_filename (abfd
));
2742 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2746 printf (" (none)\n\n");
2750 relpp
= xmalloc (relsize
);
2751 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2754 bfd_fatal (bfd_get_filename (abfd
));
2755 else if (relcount
== 0)
2756 printf (" (none)\n\n");
2760 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2767 dump_relocs (bfd
*abfd
)
2769 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2773 dump_dynamic_relocs (bfd
*abfd
)
2779 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2781 bfd_fatal (bfd_get_filename (abfd
));
2783 printf ("DYNAMIC RELOCATION RECORDS");
2786 printf (" (none)\n\n");
2789 relpp
= xmalloc (relsize
);
2790 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2793 bfd_fatal (bfd_get_filename (abfd
));
2794 else if (relcount
== 0)
2795 printf (" (none)\n\n");
2799 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2806 /* Creates a table of paths, to search for source files. */
2809 add_include_path (const char *path
)
2813 include_path_count
++;
2814 include_paths
= xrealloc (include_paths
,
2815 include_path_count
* sizeof (*include_paths
));
2816 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2817 if (path
[1] == ':' && path
[2] == 0)
2818 path
= concat (path
, ".", (const char *) 0);
2820 include_paths
[include_path_count
- 1] = path
;
2824 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2828 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2830 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2831 section
->vma
+= adjust_section_vma
;
2833 section
->lma
+= adjust_section_vma
;
2837 /* Dump selected contents of ABFD. */
2840 dump_bfd (bfd
*abfd
)
2842 /* If we are adjusting section VMA's, change them all now. Changing
2843 the BFD information is a hack. However, we must do it, or
2844 bfd_find_nearest_line will not do the right thing. */
2845 if (adjust_section_vma
!= 0)
2847 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2848 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2851 if (! dump_debugging_tags
)
2852 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2855 print_arelt_descr (stdout
, abfd
, TRUE
);
2856 if (dump_file_header
)
2857 dump_bfd_header (abfd
);
2858 if (dump_private_headers
)
2859 dump_bfd_private_header (abfd
);
2860 if (! dump_debugging_tags
)
2862 if (dump_section_headers
)
2863 dump_headers (abfd
);
2869 || dump_dwarf_section_info
)
2870 syms
= slurp_symtab (abfd
);
2871 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2872 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2873 dynsyms
= slurp_dynamic_symtab (abfd
);
2876 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2877 dynsymcount
, dynsyms
, &synthsyms
);
2883 dump_symbols (abfd
, FALSE
);
2884 if (dump_dynamic_symtab
)
2885 dump_symbols (abfd
, TRUE
);
2886 if (dump_dwarf_section_info
)
2888 if (dump_stab_section_info
)
2890 if (dump_reloc_info
&& ! disassemble
)
2892 if (dump_dynamic_reloc_info
&& ! disassemble
)
2893 dump_dynamic_relocs (abfd
);
2894 if (dump_section_contents
)
2897 disassemble_data (abfd
);
2903 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2904 if (dhandle
!= NULL
)
2906 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2908 dump_debugging_tags
? TRUE
: FALSE
))
2910 non_fatal (_("%s: printing debugging information failed"),
2911 bfd_get_filename (abfd
));
2941 display_bfd (bfd
*abfd
)
2945 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2951 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2953 nonfatal (bfd_get_filename (abfd
));
2954 list_matching_formats (matching
);
2959 if (bfd_get_error () != bfd_error_file_not_recognized
)
2961 nonfatal (bfd_get_filename (abfd
));
2965 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2971 nonfatal (bfd_get_filename (abfd
));
2973 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2975 list_matching_formats (matching
);
2981 display_file (char *filename
, char *target
)
2986 if (get_file_size (filename
) < 1)
2992 file
= bfd_openr (filename
, target
);
2995 nonfatal (filename
);
2999 /* If the file is an archive, process all of its elements. */
3000 if (bfd_check_format (file
, bfd_archive
))
3002 bfd
*last_arfile
= NULL
;
3004 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3007 bfd_set_error (bfd_error_no_error
);
3009 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3012 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3013 nonfatal (bfd_get_filename (file
));
3017 display_bfd (arfile
);
3019 if (last_arfile
!= NULL
)
3020 bfd_close (last_arfile
);
3021 last_arfile
= arfile
;
3024 if (last_arfile
!= NULL
)
3025 bfd_close (last_arfile
);
3034 main (int argc
, char **argv
)
3037 char *target
= default_target
;
3038 bfd_boolean seenflag
= FALSE
;
3040 #if defined (HAVE_SETLOCALE)
3041 #if defined (HAVE_LC_MESSAGES)
3042 setlocale (LC_MESSAGES
, "");
3044 setlocale (LC_CTYPE
, "");
3047 bindtextdomain (PACKAGE
, LOCALEDIR
);
3048 textdomain (PACKAGE
);
3050 program_name
= *argv
;
3051 xmalloc_set_program_name (program_name
);
3053 START_PROGRESS (program_name
, 0);
3055 expandargv (&argc
, &argv
);
3058 set_default_bfd_target ();
3060 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3061 long_options
, (int *) 0))
3067 break; /* We've been given a long option. */
3072 if (disassembler_options
)
3073 /* Ignore potential memory leak for now. */
3074 disassembler_options
= concat (disassembler_options
, ",",
3077 disassembler_options
= optarg
;
3080 if (only_used
== only_size
)
3083 only
= xrealloc (only
, only_size
* sizeof (char *));
3085 only
[only_used
++] = optarg
;
3088 with_line_numbers
= TRUE
;
3097 enum demangling_styles style
;
3099 style
= cplus_demangle_name_to_style (optarg
);
3100 if (style
== unknown_demangling
)
3101 fatal (_("unknown demangling style `%s'"),
3104 cplus_demangle_set_style (style
);
3110 case OPTION_ADJUST_VMA
:
3111 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3113 case OPTION_START_ADDRESS
:
3114 start_address
= parse_vma (optarg
, "--start-address");
3116 case OPTION_STOP_ADDRESS
:
3117 stop_address
= parse_vma (optarg
, "--stop-address");
3120 if (strcmp (optarg
, "B") == 0)
3121 endian
= BFD_ENDIAN_BIG
;
3122 else if (strcmp (optarg
, "L") == 0)
3123 endian
= BFD_ENDIAN_LITTLE
;
3126 non_fatal (_("unrecognized -E option"));
3131 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3132 endian
= BFD_ENDIAN_BIG
;
3133 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3134 endian
= BFD_ENDIAN_LITTLE
;
3137 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3143 dump_file_header
= TRUE
;
3147 formats_info
= TRUE
;
3151 add_include_path (optarg
);
3154 dump_private_headers
= TRUE
;
3158 dump_private_headers
= TRUE
;
3160 dump_reloc_info
= TRUE
;
3161 dump_file_header
= TRUE
;
3162 dump_ar_hdrs
= TRUE
;
3163 dump_section_headers
= TRUE
;
3171 dump_dynamic_symtab
= TRUE
;
3179 disassemble_zeroes
= TRUE
;
3183 disassemble_all
= TRUE
;
3188 with_source_code
= TRUE
;
3197 dump_debugging_tags
= 1;
3202 dump_dwarf_section_info
= TRUE
;
3205 do_debug_abbrevs
= 1;
3207 do_debug_pubnames
= 1;
3208 do_debug_aranges
= 1;
3209 do_debug_ranges
= 1;
3210 do_debug_frames
= 1;
3211 do_debug_macinfo
= 1;
3216 dump_stab_section_info
= TRUE
;
3220 dump_section_contents
= TRUE
;
3224 dump_reloc_info
= TRUE
;
3228 dump_dynamic_reloc_info
= TRUE
;
3232 dump_ar_hdrs
= TRUE
;
3236 dump_section_headers
= TRUE
;
3244 show_version
= TRUE
;
3254 print_version ("objdump");
3260 exit_status
= display_info ();
3264 display_file ("a.out", target
);
3266 for (; optind
< argc
;)
3267 display_file (argv
[optind
++], target
);
3270 END_PROGRESS (program_name
);