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 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
56 #include "safe-ctype.h"
58 #include "libiberty.h"
63 /* Internal headers for the ELF .stab-dump code - sorry. */
64 #define BYTES_IN_WORD 32
65 #include "aout/aout64.h"
68 static int exit_status
= 0;
70 static char *default_target
= NULL
; /* Default at runtime. */
72 /* The following variables are set based on arguments passed on the
74 static int show_version
= 0; /* Show the version number. */
75 static int dump_section_contents
; /* -s */
76 static int dump_section_headers
; /* -h */
77 static bfd_boolean dump_file_header
; /* -f */
78 static int dump_symtab
; /* -t */
79 static int dump_dynamic_symtab
; /* -T */
80 static int dump_reloc_info
; /* -r */
81 static int dump_dynamic_reloc_info
; /* -R */
82 static int dump_ar_hdrs
; /* -a */
83 static int dump_private_headers
; /* -p */
84 static int prefix_addresses
; /* --prefix-addresses */
85 static int with_line_numbers
; /* -l */
86 static bfd_boolean with_source_code
; /* -S */
87 static int show_raw_insn
; /* --show-raw-insn */
88 static int dump_dwarf_section_info
; /* --dwarf */
89 static int dump_stab_section_info
; /* --stabs */
90 static int do_demangle
; /* -C, --demangle */
91 static bfd_boolean disassemble
; /* -d */
92 static bfd_boolean disassemble_all
; /* -D */
93 static int disassemble_zeroes
; /* --disassemble-zeroes */
94 static bfd_boolean formats_info
; /* -i */
95 static int wide_output
; /* -w */
96 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
97 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
98 static int dump_debugging
; /* --debugging */
99 static int dump_debugging_tags
; /* --debugging-tags */
100 static int dump_special_syms
= 0; /* --special-syms */
101 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
102 static int file_start_context
= 0; /* --file-start-context */
104 /* Pointer to an array of section names provided by
105 one or more "-j secname" command line options. */
107 /* The total number of slots in the only[] array. */
108 static size_t only_size
= 0;
109 /* The number of occupied slots in the only[] array. */
110 static size_t only_used
= 0;
112 /* Variables for handling include file path table. */
113 static const char **include_paths
;
114 static int include_path_count
;
116 /* Extra info to pass to the section disassembler and address printing
118 struct objdump_disasm_info
122 bfd_boolean require_sec
;
123 arelent
** dynrelbuf
;
125 disassembler_ftype disassemble_fn
;
129 /* Architecture to disassemble for, or default if NULL. */
130 static char *machine
= NULL
;
132 /* Target specific options to the disassembler. */
133 static char *disassembler_options
= NULL
;
135 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
136 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
138 /* The symbol table. */
139 static asymbol
**syms
;
141 /* Number of symbols in `syms'. */
142 static long symcount
= 0;
144 /* The sorted symbol table. */
145 static asymbol
**sorted_syms
;
147 /* Number of symbols in `sorted_syms'. */
148 static long sorted_symcount
= 0;
150 /* The dynamic symbol table. */
151 static asymbol
**dynsyms
;
153 /* The synthetic symbol table. */
154 static asymbol
*synthsyms
;
155 static long synthcount
= 0;
157 /* Number of symbols in `dynsyms'. */
158 static long dynsymcount
= 0;
160 static bfd_byte
*stabs
;
161 static bfd_size_type stab_size
;
164 static bfd_size_type stabstr_size
;
167 usage (FILE *stream
, int status
)
169 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
170 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
171 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
172 fprintf (stream
, _("\
173 -a, --archive-headers Display archive header information\n\
174 -f, --file-headers Display the contents of the overall file header\n\
175 -p, --private-headers Display object format specific file header contents\n\
176 -h, --[section-]headers Display the contents of the section headers\n\
177 -x, --all-headers Display the contents of all headers\n\
178 -d, --disassemble Display assembler contents of executable sections\n\
179 -D, --disassemble-all Display assembler contents of all sections\n\
180 -S, --source Intermix source code with disassembly\n\
181 -s, --full-contents Display the full contents of all sections requested\n\
182 -g, --debugging Display debug information in object file\n\
183 -e, --debugging-tags Display debug information using ctags style\n\
184 -G, --stabs Display (in raw form) any STABS info in the file\n\
185 -W, --dwarf Display DWARF info in the file\n\
186 -t, --syms Display the contents of the symbol table(s)\n\
187 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
188 -r, --reloc Display the relocation entries in the file\n\
189 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
190 @<file> Read options from <file>\n\
191 -v, --version Display this program's version number\n\
192 -i, --info List object formats and architectures supported\n\
193 -H, --help Display this information\n\
197 fprintf (stream
, _("\n The following switches are optional:\n"));
198 fprintf (stream
, _("\
199 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
200 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
201 -j, --section=NAME Only display information for section NAME\n\
202 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
203 -EB --endian=big Assume big endian format when disassembling\n\
204 -EL --endian=little Assume little endian format when disassembling\n\
205 --file-start-context Include context from start of file (with -S)\n\
206 -I, --include=DIR Add DIR to search list for source files\n\
207 -l, --line-numbers Include line numbers and filenames in output\n\
208 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
209 The STYLE, if specified, can be `auto', `gnu',\n\
210 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
212 -w, --wide Format output for more than 80 columns\n\
213 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
214 --start-address=ADDR Only process data whose address is >= ADDR\n\
215 --stop-address=ADDR Only process data whose address is <= ADDR\n\
216 --prefix-addresses Print complete address alongside disassembly\n\
217 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
218 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
219 --special-syms Include special symbols in symbol dumps\n\
221 list_supported_targets (program_name
, stream
);
222 list_supported_architectures (program_name
, stream
);
224 disassembler_usage (stream
);
226 if (REPORT_BUGS_TO
[0] && status
== 0)
227 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
231 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
235 OPTION_START_ADDRESS
,
240 static struct option long_options
[]=
242 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
243 {"all-headers", no_argument
, NULL
, 'x'},
244 {"private-headers", no_argument
, NULL
, 'p'},
245 {"architecture", required_argument
, NULL
, 'm'},
246 {"archive-headers", no_argument
, NULL
, 'a'},
247 {"debugging", no_argument
, NULL
, 'g'},
248 {"debugging-tags", no_argument
, NULL
, 'e'},
249 {"demangle", optional_argument
, NULL
, 'C'},
250 {"disassemble", no_argument
, NULL
, 'd'},
251 {"disassemble-all", no_argument
, NULL
, 'D'},
252 {"disassembler-options", required_argument
, NULL
, 'M'},
253 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
254 {"dynamic-reloc", no_argument
, NULL
, 'R'},
255 {"dynamic-syms", no_argument
, NULL
, 'T'},
256 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
257 {"file-headers", no_argument
, NULL
, 'f'},
258 {"file-start-context", no_argument
, &file_start_context
, 1},
259 {"full-contents", no_argument
, NULL
, 's'},
260 {"headers", no_argument
, NULL
, 'h'},
261 {"help", no_argument
, NULL
, 'H'},
262 {"info", no_argument
, NULL
, 'i'},
263 {"line-numbers", no_argument
, NULL
, 'l'},
264 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
265 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
266 {"reloc", no_argument
, NULL
, 'r'},
267 {"section", required_argument
, NULL
, 'j'},
268 {"section-headers", no_argument
, NULL
, 'h'},
269 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
270 {"source", no_argument
, NULL
, 'S'},
271 {"special-syms", no_argument
, &dump_special_syms
, 1},
272 {"include", required_argument
, NULL
, 'I'},
273 {"dwarf", no_argument
, NULL
, 'W'},
274 {"stabs", no_argument
, NULL
, 'G'},
275 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
276 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
277 {"syms", no_argument
, NULL
, 't'},
278 {"target", required_argument
, NULL
, 'b'},
279 {"version", no_argument
, NULL
, 'V'},
280 {"wide", no_argument
, NULL
, 'w'},
281 {0, no_argument
, 0, 0}
285 nonfatal (const char *msg
)
292 dump_section_header (bfd
*abfd
, asection
*section
,
293 void *ignored ATTRIBUTE_UNUSED
)
296 unsigned int opb
= bfd_octets_per_byte (abfd
);
298 /* Ignore linker created section. See elfNN_ia64_object_p in
300 if (section
->flags
& SEC_LINKER_CREATED
)
303 printf ("%3d %-13s %08lx ", section
->index
,
304 bfd_get_section_name (abfd
, section
),
305 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
306 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
308 bfd_printf_vma (abfd
, section
->lma
);
309 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
310 bfd_get_section_alignment (abfd
, section
));
316 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
318 PF (SEC_HAS_CONTENTS
, "CONTENTS");
319 PF (SEC_ALLOC
, "ALLOC");
320 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
321 PF (SEC_LOAD
, "LOAD");
322 PF (SEC_RELOC
, "RELOC");
323 PF (SEC_READONLY
, "READONLY");
324 PF (SEC_CODE
, "CODE");
325 PF (SEC_DATA
, "DATA");
327 PF (SEC_DEBUGGING
, "DEBUGGING");
328 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
329 PF (SEC_EXCLUDE
, "EXCLUDE");
330 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
331 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
333 PF (SEC_TIC54X_BLOCK
, "BLOCK");
334 PF (SEC_TIC54X_CLINK
, "CLINK");
336 PF (SEC_SMALL_DATA
, "SMALL_DATA");
337 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
338 PF (SEC_COFF_SHARED
, "SHARED");
339 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
340 PF (SEC_GROUP
, "GROUP");
342 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
345 struct coff_comdat_info
*comdat
;
347 switch (section
->flags
& SEC_LINK_DUPLICATES
)
351 case SEC_LINK_DUPLICATES_DISCARD
:
352 ls
= "LINK_ONCE_DISCARD";
354 case SEC_LINK_DUPLICATES_ONE_ONLY
:
355 ls
= "LINK_ONCE_ONE_ONLY";
357 case SEC_LINK_DUPLICATES_SAME_SIZE
:
358 ls
= "LINK_ONCE_SAME_SIZE";
360 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
361 ls
= "LINK_ONCE_SAME_CONTENTS";
364 printf ("%s%s", comma
, ls
);
366 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
368 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
378 dump_headers (bfd
*abfd
)
380 printf (_("Sections:\n"));
383 printf (_("Idx Name Size VMA LMA File off Algn"));
385 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
386 if (bfd_get_arch_size (abfd
) == 32)
387 printf (_("Idx Name Size VMA LMA File off Algn"));
389 printf (_("Idx Name Size VMA LMA File off Algn"));
393 printf (_(" Flags"));
394 if (abfd
->flags
& HAS_LOAD_PAGE
)
398 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
402 slurp_symtab (bfd
*abfd
)
407 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
413 storage
= bfd_get_symtab_upper_bound (abfd
);
415 bfd_fatal (bfd_get_filename (abfd
));
417 sy
= xmalloc (storage
);
419 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
421 bfd_fatal (bfd_get_filename (abfd
));
425 /* Read in the dynamic symbols. */
428 slurp_dynamic_symtab (bfd
*abfd
)
433 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
436 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
438 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
443 bfd_fatal (bfd_get_filename (abfd
));
446 sy
= xmalloc (storage
);
448 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
450 bfd_fatal (bfd_get_filename (abfd
));
454 /* Filter out (in place) symbols that are useless for disassembly.
455 COUNT is the number of elements in SYMBOLS.
456 Return the number of useful symbols. */
459 remove_useless_symbols (asymbol
**symbols
, long count
)
461 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
465 asymbol
*sym
= *in_ptr
++;
467 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
469 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
471 if (bfd_is_und_section (sym
->section
)
472 || bfd_is_com_section (sym
->section
))
477 return out_ptr
- symbols
;
480 /* Sort symbols into value order. */
483 compare_symbols (const void *ap
, const void *bp
)
485 const asymbol
*a
= * (const asymbol
**) ap
;
486 const asymbol
*b
= * (const asymbol
**) bp
;
496 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
498 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
501 if (a
->section
> b
->section
)
503 else if (a
->section
< b
->section
)
506 an
= bfd_asymbol_name (a
);
507 bn
= bfd_asymbol_name (b
);
511 /* The symbols gnu_compiled and gcc2_compiled convey no real
512 information, so put them after other symbols with the same value. */
513 af
= (strstr (an
, "gnu_compiled") != NULL
514 || strstr (an
, "gcc2_compiled") != NULL
);
515 bf
= (strstr (bn
, "gnu_compiled") != NULL
516 || strstr (bn
, "gcc2_compiled") != NULL
);
523 /* We use a heuristic for the file name, to try to sort it after
524 more useful symbols. It may not work on non Unix systems, but it
525 doesn't really matter; the only difference is precisely which
526 symbol names get printed. */
528 #define file_symbol(s, sn, snl) \
529 (((s)->flags & BSF_FILE) != 0 \
530 || ((sn)[(snl) - 2] == '.' \
531 && ((sn)[(snl) - 1] == 'o' \
532 || (sn)[(snl) - 1] == 'a')))
534 af
= file_symbol (a
, an
, anl
);
535 bf
= file_symbol (b
, bn
, bnl
);
542 /* Try to sort global symbols before local symbols before function
543 symbols before debugging symbols. */
548 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
550 if ((aflags
& BSF_DEBUGGING
) != 0)
555 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
557 if ((aflags
& BSF_FUNCTION
) != 0)
562 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
564 if ((aflags
& BSF_LOCAL
) != 0)
569 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
571 if ((aflags
& BSF_GLOBAL
) != 0)
577 /* Symbols that start with '.' might be section names, so sort them
578 after symbols that don't start with '.'. */
579 if (an
[0] == '.' && bn
[0] != '.')
581 if (an
[0] != '.' && bn
[0] == '.')
584 /* Finally, if we can't distinguish them in any other way, try to
585 get consistent results by sorting the symbols by name. */
586 return strcmp (an
, bn
);
589 /* Sort relocs into address order. */
592 compare_relocs (const void *ap
, const void *bp
)
594 const arelent
*a
= * (const arelent
**) ap
;
595 const arelent
*b
= * (const arelent
**) bp
;
597 if (a
->address
> b
->address
)
599 else if (a
->address
< b
->address
)
602 /* So that associated relocations tied to the same address show up
603 in the correct order, we don't do any further sorting. */
612 /* Print an address (VMA) to the output stream in INFO.
613 If SKIP_ZEROES is TRUE, omit leading zeroes. */
616 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
617 bfd_boolean skip_zeroes
)
621 struct objdump_disasm_info
*aux
;
623 aux
= (struct objdump_disasm_info
*) info
->application_data
;
624 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
629 for (p
= buf
; *p
== '0'; ++p
)
634 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
637 /* Print the name of a symbol. */
640 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
647 name
= bfd_asymbol_name (sym
);
648 if (do_demangle
&& name
[0] != '\0')
650 /* Demangle the name. */
651 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
657 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
665 /* Locate a symbol given a bfd and a section (from INFO->application_data),
666 and a VMA. If INFO->application_data->require_sec is TRUE, then always
667 require the symbol to be in the section. Returns NULL if there is no
668 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
669 of the symbol in sorted_syms. */
672 find_symbol_for_address (bfd_vma vma
,
673 struct disassemble_info
*info
,
676 /* @@ Would it speed things up to cache the last two symbols returned,
677 and maybe their address ranges? For many processors, only one memory
678 operand can be present at a time, so the 2-entry cache wouldn't be
679 constantly churned by code doing heavy memory accesses. */
681 /* Indices in `sorted_syms'. */
683 long max
= sorted_symcount
;
685 struct objdump_disasm_info
*aux
;
690 if (sorted_symcount
< 1)
693 aux
= (struct objdump_disasm_info
*) info
->application_data
;
696 opb
= bfd_octets_per_byte (abfd
);
698 /* Perform a binary search looking for the closest symbol to the
699 required value. We are searching the range (min, max]. */
700 while (min
+ 1 < max
)
704 thisplace
= (max
+ min
) / 2;
705 sym
= sorted_syms
[thisplace
];
707 if (bfd_asymbol_value (sym
) > vma
)
709 else if (bfd_asymbol_value (sym
) < vma
)
718 /* The symbol we want is now in min, the low end of the range we
719 were searching. If there are several symbols with the same
720 value, we want the first one. */
723 && (bfd_asymbol_value (sorted_syms
[thisplace
])
724 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
727 /* If the file is relocatable, and the symbol could be from this
728 section, prefer a symbol from this section over symbols from
729 others, even if the other symbol's value might be closer.
731 Note that this may be wrong for some symbol references if the
732 sections have overlapping memory ranges, but in that case there's
733 no way to tell what's desired without looking at the relocation
735 if (sorted_syms
[thisplace
]->section
!= sec
737 || ((abfd
->flags
& HAS_RELOC
) != 0
738 && vma
>= bfd_get_section_vma (abfd
, sec
)
739 && vma
< (bfd_get_section_vma (abfd
, sec
)
740 + bfd_section_size (abfd
, sec
) / opb
))))
744 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
746 if (bfd_asymbol_value (sorted_syms
[i
])
747 != bfd_asymbol_value (sorted_syms
[thisplace
]))
755 if (sorted_syms
[i
]->section
== sec
757 || sorted_syms
[i
- 1]->section
!= sec
758 || (bfd_asymbol_value (sorted_syms
[i
])
759 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
766 if (sorted_syms
[thisplace
]->section
!= sec
)
768 /* We didn't find a good symbol with a smaller value.
769 Look for one with a larger value. */
770 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
772 if (sorted_syms
[i
]->section
== sec
)
780 if (sorted_syms
[thisplace
]->section
!= sec
782 || ((abfd
->flags
& HAS_RELOC
) != 0
783 && vma
>= bfd_get_section_vma (abfd
, sec
)
784 && vma
< (bfd_get_section_vma (abfd
, sec
)
785 + bfd_section_size (abfd
, sec
)))))
786 /* There is no suitable symbol. */
790 /* Give the target a chance to reject the symbol. */
791 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
794 if (thisplace
>= sorted_symcount
795 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
802 return sorted_syms
[thisplace
];
805 /* Print an address and the offset to the nearest symbol. */
808 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
809 bfd_vma vma
, struct disassemble_info
*info
,
810 bfd_boolean skip_zeroes
)
812 objdump_print_value (vma
, info
, skip_zeroes
);
818 (*info
->fprintf_func
) (info
->stream
, " <%s",
819 bfd_get_section_name (abfd
, sec
));
820 secaddr
= bfd_get_section_vma (abfd
, sec
);
823 (*info
->fprintf_func
) (info
->stream
, "-0x");
824 objdump_print_value (secaddr
- vma
, info
, TRUE
);
826 else if (vma
> secaddr
)
828 (*info
->fprintf_func
) (info
->stream
, "+0x");
829 objdump_print_value (vma
- secaddr
, info
, TRUE
);
831 (*info
->fprintf_func
) (info
->stream
, ">");
835 (*info
->fprintf_func
) (info
->stream
, " <");
836 objdump_print_symname (abfd
, info
, sym
);
837 if (bfd_asymbol_value (sym
) > vma
)
839 (*info
->fprintf_func
) (info
->stream
, "-0x");
840 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
842 else if (vma
> bfd_asymbol_value (sym
))
844 (*info
->fprintf_func
) (info
->stream
, "+0x");
845 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
847 (*info
->fprintf_func
) (info
->stream
, ">");
851 /* Print an address (VMA), symbolically if possible.
852 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
855 objdump_print_addr (bfd_vma vma
,
856 struct disassemble_info
*info
,
857 bfd_boolean skip_zeroes
)
859 struct objdump_disasm_info
*aux
;
860 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
861 bfd_boolean skip_find
= FALSE
;
863 if (sorted_symcount
< 1)
865 (*info
->fprintf_func
) (info
->stream
, "0x");
866 objdump_print_value (vma
, info
, skip_zeroes
);
870 aux
= (struct objdump_disasm_info
*) info
->application_data
;
872 if (aux
->reloc
!= NULL
873 && aux
->reloc
->sym_ptr_ptr
!= NULL
874 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
876 sym
= * aux
->reloc
->sym_ptr_ptr
;
878 /* Adjust the vma to the reloc. */
879 vma
+= bfd_asymbol_value (sym
);
881 if (bfd_is_und_section (bfd_get_section (sym
)))
886 sym
= find_symbol_for_address (vma
, info
, NULL
);
888 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
892 /* Print VMA to INFO. This function is passed to the disassembler
896 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
898 objdump_print_addr (vma
, info
, ! prefix_addresses
);
901 /* Determine if the given address has a symbol associated with it. */
904 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
908 sym
= find_symbol_for_address (vma
, info
, NULL
);
910 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
913 /* Hold the last function name and the last line number we displayed
916 static char *prev_functionname
;
917 static unsigned int prev_line
;
919 /* We keep a list of all files that we have seen when doing a
920 disassembly with source, so that we know how much of the file to
921 display. This can be important for inlined functions. */
923 struct print_file_list
925 struct print_file_list
*next
;
926 const char *filename
;
932 static struct print_file_list
*print_files
;
934 /* The number of preceding context lines to show when we start
935 displaying a file for the first time. */
937 #define SHOW_PRECEDING_CONTEXT_LINES (5)
939 /* Tries to open MODNAME, and if successful adds a node to print_files
940 linked list and returns that node. Returns NULL on failure. */
942 static struct print_file_list
*
943 try_print_file_open (const char *origname
, const char *modname
)
945 struct print_file_list
*p
;
948 f
= fopen (modname
, "r");
952 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
954 fclose (print_files
->f
);
955 print_files
->f
= NULL
;
958 p
= xmalloc (sizeof (struct print_file_list
));
959 p
->filename
= origname
;
960 p
->modname
= modname
;
963 p
->next
= print_files
;
968 /* If the the source file, as described in the symtab, is not found
969 try to locate it in one of the paths specified with -I
970 If found, add location to print_files linked list. */
972 static struct print_file_list
*
973 update_source_path (const char *filename
)
975 struct print_file_list
*p
;
979 if (filename
== NULL
)
982 p
= try_print_file_open (filename
, filename
);
986 if (include_path_count
== 0)
989 /* Get the name of the file. */
990 fname
= strrchr (filename
, '/');
991 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
993 /* We could have a mixed forward/back slash case. */
994 char *backslash
= strrchr (filename
, '\\');
995 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
997 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
998 fname
= filename
+ 1;
1006 /* If file exists under a new path, we need to add it to the list
1007 so that show_line knows about it. */
1008 for (i
= 0; i
< include_path_count
; i
++)
1010 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1012 p
= try_print_file_open (filename
, modname
);
1022 /* Skip ahead to a given line in a file, optionally printing each
1026 skip_to_line (struct print_file_list
*p
, unsigned int line
,
1029 while (p
->line
< line
)
1033 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1043 if (strchr (buf
, '\n') != NULL
)
1048 /* Show the line number, or the source line, in a disassembly
1052 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1054 const char *filename
;
1055 const char *functionname
;
1058 if (! with_line_numbers
&& ! with_source_code
)
1061 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1062 &functionname
, &line
))
1065 if (filename
!= NULL
&& *filename
== '\0')
1067 if (functionname
!= NULL
&& *functionname
== '\0')
1068 functionname
= NULL
;
1070 if (with_line_numbers
)
1072 if (functionname
!= NULL
1073 && (prev_functionname
== NULL
1074 || strcmp (functionname
, prev_functionname
) != 0))
1075 printf ("%s():\n", functionname
);
1076 if (line
> 0 && line
!= prev_line
)
1077 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1080 if (with_source_code
1084 struct print_file_list
**pp
, *p
;
1086 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1087 if (strcmp ((*pp
)->filename
, filename
) == 0)
1093 if (p
!= print_files
)
1097 /* We have reencountered a file name which we saw
1098 earlier. This implies that either we are dumping out
1099 code from an included file, or the same file was
1100 linked in more than once. There are two common cases
1101 of an included file: inline functions in a header
1102 file, and a bison or flex skeleton file. In the
1103 former case we want to just start printing (but we
1104 back up a few lines to give context); in the latter
1105 case we want to continue from where we left off. I
1106 can't think of a good way to distinguish the cases,
1107 so I used a heuristic based on the file name. */
1108 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1112 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1119 p
->f
= fopen (p
->modname
, "r");
1123 skip_to_line (p
, l
, FALSE
);
1125 if (print_files
->f
!= NULL
)
1127 fclose (print_files
->f
);
1128 print_files
->f
= NULL
;
1134 skip_to_line (p
, line
, TRUE
);
1136 p
->next
= print_files
;
1142 p
= update_source_path (filename
);
1148 if (file_start_context
)
1151 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1154 skip_to_line (p
, l
, FALSE
);
1156 skip_to_line (p
, line
, TRUE
);
1161 if (functionname
!= NULL
1162 && (prev_functionname
== NULL
1163 || strcmp (functionname
, prev_functionname
) != 0))
1165 if (prev_functionname
!= NULL
)
1166 free (prev_functionname
);
1167 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1168 strcpy (prev_functionname
, functionname
);
1171 if (line
> 0 && line
!= prev_line
)
1175 /* Pseudo FILE object for strings. */
1183 /* sprintf to a "stream". */
1185 static int ATTRIBUTE_PRINTF_2
1186 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1193 size_t space
= f
->alloc
- f
->pos
;
1195 va_start (args
, format
);
1196 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1202 f
->alloc
= (f
->alloc
+ n
) * 2;
1203 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1210 /* Returns TRUE if the specified section should be dumped. */
1213 process_section_p (asection
* section
)
1220 for (i
= 0; i
< only_used
; i
++)
1221 if (strcmp (only
[i
], section
->name
) == 0)
1228 /* The number of zeroes we want to see before we start skipping them.
1229 The number is arbitrarily chosen. */
1231 #define DEFAULT_SKIP_ZEROES 8
1233 /* The number of zeroes to skip at the end of a section. If the
1234 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1235 SKIP_ZEROES, they will be disassembled. If there are fewer than
1236 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1237 attempt to avoid disassembling zeroes inserted by section
1240 #define DEFAULT_SKIP_ZEROES_AT_END 3
1242 /* Disassemble some data in memory between given values. */
1245 disassemble_bytes (struct disassemble_info
* info
,
1246 disassembler_ftype disassemble_fn
,
1249 bfd_vma start_offset
,
1250 bfd_vma stop_offset
,
1253 arelent
** relppend
)
1255 struct objdump_disasm_info
*aux
;
1257 int octets_per_line
;
1258 bfd_boolean done_dot
;
1259 int skip_addr_chars
;
1260 bfd_vma addr_offset
;
1261 unsigned int opb
= info
->octets_per_byte
;
1262 unsigned int skip_zeroes
= info
->skip_zeroes
;
1263 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1267 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1271 sfile
.buffer
= xmalloc (sfile
.alloc
);
1275 octets_per_line
= 4;
1277 octets_per_line
= 16;
1279 /* Figure out how many characters to skip at the start of an
1280 address, to make the disassembly look nicer. We discard leading
1281 zeroes in chunks of 4, ensuring that there is always a leading
1283 skip_addr_chars
= 0;
1284 if (! prefix_addresses
)
1292 + bfd_section_size (section
->owner
, section
) / opb
));
1294 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1297 skip_addr_chars
+= 4;
1302 info
->insn_info_valid
= 0;
1305 addr_offset
= start_offset
;
1306 while (addr_offset
< stop_offset
)
1309 bfd_boolean need_nl
= FALSE
;
1310 int previous_octets
;
1312 /* Remember the length of the previous instruction. */
1313 previous_octets
= octets
;
1316 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1318 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1321 if (! disassemble_zeroes
1322 && (info
->insn_info_valid
== 0
1323 || info
->branch_delay_insns
== 0)
1324 && (z
- addr_offset
* opb
>= skip_zeroes
1325 || (z
== stop_offset
* opb
&&
1326 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1330 /* If there are more nonzero octets to follow, we only skip
1331 zeroes in multiples of 4, to try to avoid running over
1332 the start of an instruction which happens to start with
1334 if (z
!= stop_offset
* opb
)
1335 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1337 octets
= z
- addr_offset
* opb
;
1347 if (with_line_numbers
|| with_source_code
)
1348 show_line (aux
->abfd
, section
, addr_offset
);
1350 if (! prefix_addresses
)
1354 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1355 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1359 printf ("%s:\t", buf
+ skip_addr_chars
);
1363 aux
->require_sec
= TRUE
;
1364 objdump_print_address (section
->vma
+ addr_offset
, info
);
1365 aux
->require_sec
= FALSE
;
1372 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1373 info
->stream
= &sfile
;
1374 info
->bytes_per_line
= 0;
1375 info
->bytes_per_chunk
= 0;
1378 if (info
->disassembler_needs_relocs
1379 && *relppp
< relppend
)
1381 bfd_signed_vma distance_to_rel
;
1383 distance_to_rel
= (**relppp
)->address
1384 - (rel_offset
+ addr_offset
);
1386 /* Check to see if the current reloc is associated with
1387 the instruction that we are about to disassemble. */
1388 if (distance_to_rel
== 0
1389 /* FIXME: This is wrong. We are trying to catch
1390 relocs that are addressed part way through the
1391 current instruction, as might happen with a packed
1392 VLIW instruction. Unfortunately we do not know the
1393 length of the current instruction since we have not
1394 disassembled it yet. Instead we take a guess based
1395 upon the length of the previous instruction. The
1396 proper solution is to have a new target-specific
1397 disassembler function which just returns the length
1398 of an instruction at a given address without trying
1399 to display its disassembly. */
1400 || (distance_to_rel
> 0
1401 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1403 info
->flags
= INSN_HAS_RELOC
;
1404 aux
->reloc
= **relppp
;
1410 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1411 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1412 info
->stream
= stdout
;
1413 if (info
->bytes_per_line
!= 0)
1414 octets_per_line
= info
->bytes_per_line
;
1418 printf ("%s\n", sfile
.buffer
);
1426 octets
= octets_per_line
;
1427 if (addr_offset
+ octets
/ opb
> stop_offset
)
1428 octets
= (stop_offset
- addr_offset
) * opb
;
1430 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1432 if (ISPRINT (data
[j
]))
1433 buf
[j
- addr_offset
* opb
] = data
[j
];
1435 buf
[j
- addr_offset
* opb
] = '.';
1437 buf
[j
- addr_offset
* opb
] = '\0';
1440 if (prefix_addresses
1442 : show_raw_insn
>= 0)
1446 /* If ! prefix_addresses and ! wide_output, we print
1447 octets_per_line octets per line. */
1449 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1450 pb
= octets_per_line
;
1452 if (info
->bytes_per_chunk
)
1453 bpc
= info
->bytes_per_chunk
;
1457 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1461 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1463 for (k
= bpc
- 1; k
>= 0; k
--)
1464 printf ("%02x", (unsigned) data
[j
+ k
]);
1469 for (k
= 0; k
< bpc
; k
++)
1470 printf ("%02x", (unsigned) data
[j
+ k
]);
1475 for (; pb
< octets_per_line
; pb
+= bpc
)
1479 for (k
= 0; k
< bpc
; k
++)
1484 /* Separate raw data from instruction by extra space. */
1494 printf ("%s", sfile
.buffer
);
1496 if (prefix_addresses
1498 : show_raw_insn
>= 0)
1506 j
= addr_offset
* opb
+ pb
;
1508 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1509 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1513 printf ("%s:\t", buf
+ skip_addr_chars
);
1515 pb
+= octets_per_line
;
1518 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1522 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1524 for (k
= bpc
- 1; k
>= 0; k
--)
1525 printf ("%02x", (unsigned) data
[j
+ k
]);
1530 for (k
= 0; k
< bpc
; k
++)
1531 printf ("%02x", (unsigned) data
[j
+ k
]);
1544 while ((*relppp
) < relppend
1545 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1547 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1558 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1561 if (q
->howto
== NULL
)
1562 printf (": *unknown*\t");
1563 else if (q
->howto
->name
)
1564 printf (": %s\t", q
->howto
->name
);
1566 printf (": %d\t", q
->howto
->type
);
1568 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1569 printf ("*unknown*");
1572 const char *sym_name
;
1574 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1575 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1576 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1581 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1582 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1583 if (sym_name
== NULL
|| *sym_name
== '\0')
1584 sym_name
= "*unknown*";
1585 printf ("%s", sym_name
);
1592 objdump_print_value (q
->addend
, info
, TRUE
);
1604 addr_offset
+= octets
/ opb
;
1607 free (sfile
.buffer
);
1611 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1613 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1614 struct objdump_disasm_info
* paux
;
1615 unsigned int opb
= pinfo
->octets_per_byte
;
1616 bfd_byte
* data
= NULL
;
1617 bfd_size_type datasize
= 0;
1618 arelent
** rel_pp
= NULL
;
1619 arelent
** rel_ppstart
= NULL
;
1620 arelent
** rel_ppend
;
1621 unsigned long stop_offset
;
1622 asymbol
* sym
= NULL
;
1626 unsigned long addr_offset
;
1628 /* Sections that do not contain machine
1629 code are not normally disassembled. */
1630 if (! disassemble_all
1632 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1633 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1636 if (! process_section_p (section
))
1639 datasize
= bfd_get_section_size (section
);
1643 /* Decide which set of relocs to use. Load them if necessary. */
1644 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1645 if (paux
->dynrelbuf
)
1647 rel_pp
= paux
->dynrelbuf
;
1648 rel_count
= paux
->dynrelcount
;
1649 /* Dynamic reloc addresses are absolute, non-dynamic are section
1650 relative. REL_OFFSET specifies the reloc address corresponding
1651 to the start of this section. */
1652 rel_offset
= section
->vma
;
1660 if ((section
->flags
& SEC_RELOC
) != 0
1661 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1665 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1667 bfd_fatal (bfd_get_filename (abfd
));
1671 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1672 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1674 bfd_fatal (bfd_get_filename (abfd
));
1676 /* Sort the relocs by address. */
1677 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1682 rel_ppend
= rel_pp
+ rel_count
;
1684 data
= xmalloc (datasize
);
1686 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1688 paux
->sec
= section
;
1689 pinfo
->buffer
= data
;
1690 pinfo
->buffer_vma
= section
->vma
;
1691 pinfo
->buffer_length
= datasize
;
1692 pinfo
->section
= section
;
1694 if (start_address
== (bfd_vma
) -1
1695 || start_address
< pinfo
->buffer_vma
)
1698 addr_offset
= start_address
- pinfo
->buffer_vma
;
1700 if (stop_address
== (bfd_vma
) -1)
1701 stop_offset
= datasize
/ opb
;
1704 if (stop_address
< pinfo
->buffer_vma
)
1707 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1708 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1709 stop_offset
= pinfo
->buffer_length
/ opb
;
1712 /* Skip over the relocs belonging to addresses below the
1714 while (rel_pp
< rel_ppend
1715 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1718 printf (_("Disassembly of section %s:\n"), section
->name
);
1720 /* Find the nearest symbol forwards from our current position. */
1721 paux
->require_sec
= TRUE
;
1722 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1723 paux
->require_sec
= FALSE
;
1725 /* Disassemble a block of instructions up to the address associated with
1726 the symbol we have just found. Then print the symbol and find the
1727 next symbol on. Repeat until we have disassembled the entire section
1728 or we have reached the end of the address range we are interested in. */
1729 while (addr_offset
< stop_offset
)
1733 unsigned long nextstop_offset
;
1736 addr
= section
->vma
+ addr_offset
;
1738 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1743 (x
< sorted_symcount
1744 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1748 pinfo
->symbols
= sorted_syms
+ place
;
1749 pinfo
->num_symbols
= x
- place
;
1750 pinfo
->symtab_pos
= place
;
1754 pinfo
->symbols
= NULL
;
1755 pinfo
->num_symbols
= 0;
1756 pinfo
->symtab_pos
= -1;
1759 if (! prefix_addresses
)
1761 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1762 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1764 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1767 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1769 else if (sym
== NULL
)
1773 #define is_valid_next_sym(SYM) \
1774 ((SYM)->section == section \
1775 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1776 && pinfo->symbol_is_valid (SYM, pinfo))
1778 /* Search forward for the next appropriate symbol in
1779 SECTION. Note that all the symbols are sorted
1780 together into one big array, and that some sections
1781 may have overlapping addresses. */
1782 while (place
< sorted_symcount
1783 && ! is_valid_next_sym (sorted_syms
[place
]))
1786 if (place
>= sorted_symcount
)
1789 nextsym
= sorted_syms
[place
];
1792 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1793 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1794 else if (nextsym
== NULL
)
1795 nextstop_offset
= stop_offset
;
1797 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1799 if (nextstop_offset
> stop_offset
)
1800 nextstop_offset
= stop_offset
;
1802 /* If a symbol is explicitly marked as being an object
1803 rather than a function, just dump the bytes without
1804 disassembling them. */
1807 || bfd_asymbol_value (sym
) > addr
1808 || ((sym
->flags
& BSF_OBJECT
) == 0
1809 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1811 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1813 || (sym
->flags
& BSF_FUNCTION
) != 0)
1818 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1819 addr_offset
, nextstop_offset
,
1820 rel_offset
, &rel_pp
, rel_ppend
);
1822 addr_offset
= nextstop_offset
;
1828 if (rel_ppstart
!= NULL
)
1832 /* Disassemble the contents of an object file. */
1835 disassemble_data (bfd
*abfd
)
1837 struct disassemble_info disasm_info
;
1838 struct objdump_disasm_info aux
;
1842 prev_functionname
= NULL
;
1845 /* We make a copy of syms to sort. We don't want to sort syms
1846 because that will screw up the relocs. */
1847 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1848 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1849 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1850 sorted_symcount
* sizeof (asymbol
*));
1852 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1854 for (i
= 0; i
< synthcount
; ++i
)
1856 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1860 /* Sort the symbols into section and symbol order. */
1861 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1863 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1865 disasm_info
.application_data
= (void *) &aux
;
1867 aux
.require_sec
= FALSE
;
1868 aux
.dynrelbuf
= NULL
;
1869 aux
.dynrelcount
= 0;
1872 disasm_info
.print_address_func
= objdump_print_address
;
1873 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1875 if (machine
!= NULL
)
1877 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1880 fatal (_("Can't use supplied machine %s"), machine
);
1882 abfd
->arch_info
= info
;
1885 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1887 struct bfd_target
*xvec
;
1889 xvec
= xmalloc (sizeof (struct bfd_target
));
1890 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1891 xvec
->byteorder
= endian
;
1895 /* Use libopcodes to locate a suitable disassembler. */
1896 aux
.disassemble_fn
= disassembler (abfd
);
1897 if (!aux
.disassemble_fn
)
1899 non_fatal (_("Can't disassemble for architecture %s\n"),
1900 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1905 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1906 disasm_info
.arch
= bfd_get_arch (abfd
);
1907 disasm_info
.mach
= bfd_get_mach (abfd
);
1908 disasm_info
.disassembler_options
= disassembler_options
;
1909 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1910 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1911 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1912 disasm_info
.disassembler_needs_relocs
= FALSE
;
1914 if (bfd_big_endian (abfd
))
1915 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1916 else if (bfd_little_endian (abfd
))
1917 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1919 /* ??? Aborting here seems too drastic. We could default to big or little
1921 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1923 /* Allow the target to customize the info structure. */
1924 disassemble_init_for_target (& disasm_info
);
1926 /* Pre-load the dynamic relocs if we are going
1927 to be dumping them along with the disassembly. */
1928 if (dump_dynamic_reloc_info
)
1930 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1933 bfd_fatal (bfd_get_filename (abfd
));
1937 aux
.dynrelbuf
= xmalloc (relsize
);
1938 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1941 if (aux
.dynrelcount
< 0)
1942 bfd_fatal (bfd_get_filename (abfd
));
1944 /* Sort the relocs by address. */
1945 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1949 disasm_info
.symtab
= sorted_syms
;
1950 disasm_info
.symtab_size
= sorted_symcount
;
1952 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1954 if (aux
.dynrelbuf
!= NULL
)
1955 free (aux
.dynrelbuf
);
1960 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
1962 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
1967 /* If it is already loaded, do nothing. */
1968 if (section
->start
!= NULL
)
1971 /* Locate the debug section. */
1972 sec
= bfd_get_section_by_name (abfd
, section
->name
);
1976 section
->address
= bfd_get_section_vma (abfd
, sec
);
1977 section
->size
= bfd_get_section_size (sec
);
1978 section
->start
= xmalloc (section
->size
);
1980 if (is_relocatable
&& debug_displays
[debug
].relocate
)
1981 ret
= bfd_simple_get_relocated_section_contents (abfd
,
1986 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
1991 free_debug_section (debug
);
1992 printf (_("\nCan't get contents for section '%s'.\n"),
2000 free_debug_section (enum dwarf_section_display_enum debug
)
2002 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2004 if (section
->start
== NULL
)
2007 free ((char *) section
->start
);
2008 section
->start
= NULL
;
2009 section
->address
= 0;
2014 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2015 void *arg ATTRIBUTE_UNUSED
)
2017 const char *name
= bfd_get_section_name (abfd
, section
);
2019 enum dwarf_section_display_enum i
;
2021 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2022 match
= ".debug_info";
2026 for (i
= 0; i
< max
; i
++)
2027 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2029 if (!debug_displays
[i
].eh_frame
)
2031 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2033 if (load_debug_section (i
, abfd
))
2035 debug_displays
[i
].display (sec
, abfd
);
2037 if (i
!= info
&& i
!= abbrev
)
2038 free_debug_section (i
);
2045 static const char *mach_o_dwarf_sections
[] = {
2046 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2047 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2048 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2049 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2050 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2051 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2052 ".eh_frame", /* .eh_frame */
2053 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2054 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2055 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2056 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2057 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2058 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2059 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2060 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2061 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2064 static const char *generic_dwarf_sections
[max
];
2067 check_mach_o_dwarf (bfd
*abfd
)
2069 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2070 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2071 enum dwarf_section_display_enum i
;
2073 if (generic_dwarf_sections
[0] == NULL
)
2074 for (i
= 0; i
< max
; i
++)
2075 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2077 if (old_flavour
!= current_flavour
)
2079 if (current_flavour
== bfd_target_mach_o_flavour
)
2080 for (i
= 0; i
< max
; i
++)
2081 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2082 else if (old_flavour
== bfd_target_mach_o_flavour
)
2083 for (i
= 0; i
< max
; i
++)
2084 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2086 old_flavour
= current_flavour
;
2090 /* Dump the dwarf debugging information. */
2093 dump_dwarf (bfd
*abfd
)
2095 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2098 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2099 targets will return 64. */
2100 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2102 if (bfd_big_endian (abfd
))
2103 byte_get
= byte_get_big_endian
;
2104 else if (bfd_little_endian (abfd
))
2105 byte_get
= byte_get_little_endian
;
2109 check_mach_o_dwarf (abfd
);
2111 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2113 free_debug_memory ();
2116 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2117 it. Return NULL on failure. */
2120 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2126 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2127 if (stabsect
== NULL
)
2129 printf (_("No %s section present\n\n"), sect_name
);
2133 size
= bfd_section_size (abfd
, stabsect
);
2134 contents
= xmalloc (size
);
2136 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2138 non_fatal (_("Reading %s section of %s failed: %s"),
2139 sect_name
, bfd_get_filename (abfd
),
2140 bfd_errmsg (bfd_get_error ()));
2151 /* Stabs entries use a 12 byte format:
2152 4 byte string table index
2154 1 byte stab other field
2155 2 byte stab desc field
2157 FIXME: This will have to change for a 64 bit object format. */
2159 #define STRDXOFF (0)
2161 #define OTHEROFF (5)
2164 #define STABSIZE (12)
2166 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2167 using string table section STRSECT_NAME (in `strtab'). */
2170 print_section_stabs (bfd
*abfd
,
2171 const char *stabsect_name
,
2172 unsigned *string_offset_ptr
)
2175 unsigned file_string_table_offset
= 0;
2176 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2177 bfd_byte
*stabp
, *stabs_end
;
2180 stabs_end
= stabp
+ stab_size
;
2182 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2183 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2185 /* Loop through all symbols and print them.
2187 We start the index at -1 because there is a dummy symbol on
2188 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2189 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2193 unsigned char type
, other
;
2194 unsigned short desc
;
2197 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2198 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2199 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2200 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2201 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2203 printf ("\n%-6d ", i
);
2204 /* Either print the stab name, or, if unnamed, print its number
2205 again (makes consistent formatting for tools like awk). */
2206 name
= bfd_get_stab_name (type
);
2208 printf ("%-6s", name
);
2209 else if (type
== N_UNDF
)
2212 printf ("%-6d", type
);
2213 printf (" %-6d %-6d ", other
, desc
);
2214 bfd_printf_vma (abfd
, value
);
2215 printf (" %-6lu", strx
);
2217 /* Symbols with type == 0 (N_UNDF) specify the length of the
2218 string table associated with this file. We use that info
2219 to know how to relocate the *next* file's string table indices. */
2222 file_string_table_offset
= next_file_string_table_offset
;
2223 next_file_string_table_offset
+= value
;
2227 /* Using the (possibly updated) string table offset, print the
2228 string (if any) associated with this symbol. */
2229 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2230 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2236 *string_offset_ptr
= next_file_string_table_offset
;
2241 const char * section_name
;
2242 const char * string_section_name
;
2243 unsigned string_offset
;
2248 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2251 stab_section_names
* sought
= (stab_section_names
*) names
;
2253 /* Check for section names for which stabsect_name is a prefix, to
2254 handle .stab.N, etc. */
2255 len
= strlen (sought
->section_name
);
2257 /* If the prefix matches, and the files section name ends with a
2258 nul or a digit, then we match. I.e., we want either an exact
2259 match or a section followed by a number. */
2260 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2261 && (section
->name
[len
] == 0
2262 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2265 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2270 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2273 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2279 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2281 stab_section_names s
;
2283 s
.section_name
= stabsect_name
;
2284 s
.string_section_name
= strsect_name
;
2285 s
.string_offset
= 0;
2287 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2293 /* Dump the any sections containing stabs debugging information. */
2296 dump_stabs (bfd
*abfd
)
2298 dump_stabs_section (abfd
, ".stab", ".stabstr");
2299 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2300 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2301 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2305 dump_bfd_header (bfd
*abfd
)
2309 printf (_("architecture: %s, "),
2310 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2311 bfd_get_mach (abfd
)));
2312 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2314 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2315 PF (HAS_RELOC
, "HAS_RELOC");
2316 PF (EXEC_P
, "EXEC_P");
2317 PF (HAS_LINENO
, "HAS_LINENO");
2318 PF (HAS_DEBUG
, "HAS_DEBUG");
2319 PF (HAS_SYMS
, "HAS_SYMS");
2320 PF (HAS_LOCALS
, "HAS_LOCALS");
2321 PF (DYNAMIC
, "DYNAMIC");
2322 PF (WP_TEXT
, "WP_TEXT");
2323 PF (D_PAGED
, "D_PAGED");
2324 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2325 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2326 printf (_("\nstart address 0x"));
2327 bfd_printf_vma (abfd
, abfd
->start_address
);
2333 dump_bfd_private_header (bfd
*abfd
)
2335 bfd_print_private_bfd_data (abfd
, stdout
);
2339 /* Display a section in hexadecimal format with associated characters.
2340 Each line prefixed by the zero padded address. */
2343 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2346 bfd_size_type datasize
;
2347 bfd_size_type addr_offset
;
2348 bfd_size_type start_offset
;
2349 bfd_size_type stop_offset
;
2350 unsigned int opb
= bfd_octets_per_byte (abfd
);
2351 /* Bytes per line. */
2352 const int onaline
= 16;
2357 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2360 if (! process_section_p (section
))
2363 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2366 printf (_("Contents of section %s:\n"), section
->name
);
2368 data
= xmalloc (datasize
);
2370 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2372 /* Compute the address range to display. */
2373 if (start_address
== (bfd_vma
) -1
2374 || start_address
< section
->vma
)
2377 start_offset
= start_address
- section
->vma
;
2379 if (stop_address
== (bfd_vma
) -1)
2380 stop_offset
= datasize
/ opb
;
2383 if (stop_address
< section
->vma
)
2386 stop_offset
= stop_address
- section
->vma
;
2388 if (stop_offset
> datasize
/ opb
)
2389 stop_offset
= datasize
/ opb
;
2394 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2395 if (strlen (buf
) >= sizeof (buf
))
2399 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2401 count
= strlen (buf
) - count
;
2405 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2406 if (strlen (buf
) >= sizeof (buf
))
2410 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2412 count
= strlen (buf
) - count
;
2416 for (addr_offset
= start_offset
;
2417 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2421 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2422 count
= strlen (buf
);
2423 if ((size_t) count
>= sizeof (buf
))
2427 while (count
< width
)
2432 fputs (buf
+ count
- width
, stdout
);
2435 for (j
= addr_offset
* opb
;
2436 j
< addr_offset
* opb
+ onaline
; j
++)
2438 if (j
< stop_offset
* opb
)
2439 printf ("%02x", (unsigned) (data
[j
]));
2447 for (j
= addr_offset
* opb
;
2448 j
< addr_offset
* opb
+ onaline
; j
++)
2450 if (j
>= stop_offset
* opb
)
2453 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2460 /* Actually display the various requested regions. */
2463 dump_data (bfd
*abfd
)
2465 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2468 /* Should perhaps share code and display with nm? */
2471 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2481 printf ("DYNAMIC SYMBOL TABLE:\n");
2487 printf ("SYMBOL TABLE:\n");
2491 printf (_("no symbols\n"));
2493 for (count
= 0; count
< max
; count
++)
2497 if (*current
== NULL
)
2498 printf (_("no information for symbol number %ld\n"), count
);
2500 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2501 printf (_("could not determine the type of symbol number %ld\n"),
2504 else if (process_section_p ((* current
)->section
)
2505 && (dump_special_syms
2506 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2508 const char *name
= (*current
)->name
;
2510 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2514 /* If we want to demangle the name, we demangle it
2515 here, and temporarily clobber it while calling
2516 bfd_print_symbol. FIXME: This is a gross hack. */
2517 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2519 (*current
)->name
= alloc
;
2520 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2521 bfd_print_symbol_all
);
2524 (*current
)->name
= name
;
2529 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2530 bfd_print_symbol_all
);
2540 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2543 char *last_filename
, *last_functionname
;
2544 unsigned int last_line
;
2546 /* Get column headers lined up reasonably. */
2554 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2555 width
= strlen (buf
) - 7;
2557 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2560 last_filename
= NULL
;
2561 last_functionname
= NULL
;
2564 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2567 const char *filename
, *functionname
;
2569 const char *sym_name
;
2570 const char *section_name
;
2572 if (start_address
!= (bfd_vma
) -1
2573 && q
->address
< start_address
)
2575 if (stop_address
!= (bfd_vma
) -1
2576 && q
->address
> stop_address
)
2579 if (with_line_numbers
2581 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2582 &filename
, &functionname
, &line
))
2584 if (functionname
!= NULL
2585 && (last_functionname
== NULL
2586 || strcmp (functionname
, last_functionname
) != 0))
2588 printf ("%s():\n", functionname
);
2589 if (last_functionname
!= NULL
)
2590 free (last_functionname
);
2591 last_functionname
= xstrdup (functionname
);
2595 && (line
!= last_line
2596 || (filename
!= NULL
2597 && last_filename
!= NULL
2598 && strcmp (filename
, last_filename
) != 0)))
2600 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2602 if (last_filename
!= NULL
)
2603 free (last_filename
);
2604 if (filename
== NULL
)
2605 last_filename
= NULL
;
2607 last_filename
= xstrdup (filename
);
2611 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2613 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2614 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2619 section_name
= NULL
;
2622 bfd_printf_vma (abfd
, q
->address
);
2623 if (q
->howto
== NULL
)
2624 printf (" *unknown* ");
2625 else if (q
->howto
->name
)
2626 printf (" %-16s ", q
->howto
->name
);
2628 printf (" %-16d ", q
->howto
->type
);
2630 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2633 if (section_name
== NULL
)
2634 section_name
= "*unknown*";
2635 printf ("[%s]", section_name
);
2641 bfd_printf_vma (abfd
, q
->addend
);
2649 dump_relocs_in_section (bfd
*abfd
,
2651 void *dummy ATTRIBUTE_UNUSED
)
2657 if ( bfd_is_abs_section (section
)
2658 || bfd_is_und_section (section
)
2659 || bfd_is_com_section (section
)
2660 || (! process_section_p (section
))
2661 || ((section
->flags
& SEC_RELOC
) == 0))
2664 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2666 bfd_fatal (bfd_get_filename (abfd
));
2668 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2672 printf (" (none)\n\n");
2676 relpp
= xmalloc (relsize
);
2677 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2680 bfd_fatal (bfd_get_filename (abfd
));
2681 else if (relcount
== 0)
2682 printf (" (none)\n\n");
2686 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2693 dump_relocs (bfd
*abfd
)
2695 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2699 dump_dynamic_relocs (bfd
*abfd
)
2705 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2707 bfd_fatal (bfd_get_filename (abfd
));
2709 printf ("DYNAMIC RELOCATION RECORDS");
2712 printf (" (none)\n\n");
2715 relpp
= xmalloc (relsize
);
2716 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2719 bfd_fatal (bfd_get_filename (abfd
));
2720 else if (relcount
== 0)
2721 printf (" (none)\n\n");
2725 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2732 /* Creates a table of paths, to search for source files. */
2735 add_include_path (const char *path
)
2739 include_path_count
++;
2740 include_paths
= xrealloc (include_paths
,
2741 include_path_count
* sizeof (*include_paths
));
2742 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2743 if (path
[1] == ':' && path
[2] == 0)
2744 path
= concat (path
, ".", (const char *) 0);
2746 include_paths
[include_path_count
- 1] = path
;
2750 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2754 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2756 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2757 section
->vma
+= adjust_section_vma
;
2759 section
->lma
+= adjust_section_vma
;
2763 /* Dump selected contents of ABFD. */
2766 dump_bfd (bfd
*abfd
)
2768 /* If we are adjusting section VMA's, change them all now. Changing
2769 the BFD information is a hack. However, we must do it, or
2770 bfd_find_nearest_line will not do the right thing. */
2771 if (adjust_section_vma
!= 0)
2773 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2774 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2777 if (! dump_debugging_tags
)
2778 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2781 print_arelt_descr (stdout
, abfd
, TRUE
);
2782 if (dump_file_header
)
2783 dump_bfd_header (abfd
);
2784 if (dump_private_headers
)
2785 dump_bfd_private_header (abfd
);
2786 if (! dump_debugging_tags
)
2788 if (dump_section_headers
)
2789 dump_headers (abfd
);
2795 || dump_dwarf_section_info
)
2796 syms
= slurp_symtab (abfd
);
2797 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2798 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2799 dynsyms
= slurp_dynamic_symtab (abfd
);
2802 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2803 dynsymcount
, dynsyms
, &synthsyms
);
2809 dump_symbols (abfd
, FALSE
);
2810 if (dump_dynamic_symtab
)
2811 dump_symbols (abfd
, TRUE
);
2812 if (dump_dwarf_section_info
)
2814 if (dump_stab_section_info
)
2816 if (dump_reloc_info
&& ! disassemble
)
2818 if (dump_dynamic_reloc_info
&& ! disassemble
)
2819 dump_dynamic_relocs (abfd
);
2820 if (dump_section_contents
)
2823 disassemble_data (abfd
);
2829 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2830 if (dhandle
!= NULL
)
2832 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2834 dump_debugging_tags
? TRUE
: FALSE
))
2836 non_fatal (_("%s: printing debugging information failed"),
2837 bfd_get_filename (abfd
));
2867 display_bfd (bfd
*abfd
)
2871 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2877 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2879 nonfatal (bfd_get_filename (abfd
));
2880 list_matching_formats (matching
);
2885 if (bfd_get_error () != bfd_error_file_not_recognized
)
2887 nonfatal (bfd_get_filename (abfd
));
2891 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2897 nonfatal (bfd_get_filename (abfd
));
2899 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2901 list_matching_formats (matching
);
2907 display_file (char *filename
, char *target
)
2912 if (get_file_size (filename
) < 1)
2918 file
= bfd_openr (filename
, target
);
2921 nonfatal (filename
);
2925 /* If the file is an archive, process all of its elements. */
2926 if (bfd_check_format (file
, bfd_archive
))
2928 bfd
*last_arfile
= NULL
;
2930 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2933 bfd_set_error (bfd_error_no_error
);
2935 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2938 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2939 nonfatal (bfd_get_filename (file
));
2943 display_bfd (arfile
);
2945 if (last_arfile
!= NULL
)
2946 bfd_close (last_arfile
);
2947 last_arfile
= arfile
;
2950 if (last_arfile
!= NULL
)
2951 bfd_close (last_arfile
);
2960 main (int argc
, char **argv
)
2963 char *target
= default_target
;
2964 bfd_boolean seenflag
= FALSE
;
2966 #if defined (HAVE_SETLOCALE)
2967 #if defined (HAVE_LC_MESSAGES)
2968 setlocale (LC_MESSAGES
, "");
2970 setlocale (LC_CTYPE
, "");
2973 bindtextdomain (PACKAGE
, LOCALEDIR
);
2974 textdomain (PACKAGE
);
2976 program_name
= *argv
;
2977 xmalloc_set_program_name (program_name
);
2979 START_PROGRESS (program_name
, 0);
2981 expandargv (&argc
, &argv
);
2984 set_default_bfd_target ();
2986 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2987 long_options
, (int *) 0))
2993 break; /* We've been given a long option. */
2998 if (disassembler_options
)
2999 /* Ignore potential memory leak for now. */
3000 disassembler_options
= concat (disassembler_options
, ",",
3003 disassembler_options
= optarg
;
3006 if (only_used
== only_size
)
3009 only
= xrealloc (only
, only_size
* sizeof (char *));
3011 only
[only_used
++] = optarg
;
3014 with_line_numbers
= TRUE
;
3023 enum demangling_styles style
;
3025 style
= cplus_demangle_name_to_style (optarg
);
3026 if (style
== unknown_demangling
)
3027 fatal (_("unknown demangling style `%s'"),
3030 cplus_demangle_set_style (style
);
3036 case OPTION_ADJUST_VMA
:
3037 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3039 case OPTION_START_ADDRESS
:
3040 start_address
= parse_vma (optarg
, "--start-address");
3042 case OPTION_STOP_ADDRESS
:
3043 stop_address
= parse_vma (optarg
, "--stop-address");
3046 if (strcmp (optarg
, "B") == 0)
3047 endian
= BFD_ENDIAN_BIG
;
3048 else if (strcmp (optarg
, "L") == 0)
3049 endian
= BFD_ENDIAN_LITTLE
;
3052 non_fatal (_("unrecognized -E option"));
3057 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3058 endian
= BFD_ENDIAN_BIG
;
3059 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3060 endian
= BFD_ENDIAN_LITTLE
;
3063 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3069 dump_file_header
= TRUE
;
3073 formats_info
= TRUE
;
3077 add_include_path (optarg
);
3080 dump_private_headers
= TRUE
;
3084 dump_private_headers
= TRUE
;
3086 dump_reloc_info
= TRUE
;
3087 dump_file_header
= TRUE
;
3088 dump_ar_hdrs
= TRUE
;
3089 dump_section_headers
= TRUE
;
3097 dump_dynamic_symtab
= TRUE
;
3105 disassemble_zeroes
= TRUE
;
3109 disassemble_all
= TRUE
;
3114 with_source_code
= TRUE
;
3123 dump_debugging_tags
= 1;
3128 dump_dwarf_section_info
= TRUE
;
3131 do_debug_abbrevs
= 1;
3133 do_debug_pubnames
= 1;
3134 do_debug_aranges
= 1;
3135 do_debug_ranges
= 1;
3136 do_debug_frames
= 1;
3137 do_debug_macinfo
= 1;
3142 dump_stab_section_info
= TRUE
;
3146 dump_section_contents
= TRUE
;
3150 dump_reloc_info
= TRUE
;
3154 dump_dynamic_reloc_info
= TRUE
;
3158 dump_ar_hdrs
= TRUE
;
3162 dump_section_headers
= TRUE
;
3170 show_version
= TRUE
;
3180 print_version ("objdump");
3186 exit_status
= display_info ();
3190 display_file ("a.out", target
);
3192 for (; optind
< argc
;)
3193 display_file (argv
[optind
++], target
);
3196 END_PROGRESS (program_name
);