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, 2008, 2009, 2010
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. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
64 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static int prefix_addresses
; /* --prefix-addresses */
96 static int with_line_numbers
; /* -l */
97 static bfd_boolean with_source_code
; /* -S */
98 static int show_raw_insn
; /* --show-raw-insn */
99 static int dump_dwarf_section_info
; /* --dwarf */
100 static int dump_stab_section_info
; /* --stabs */
101 static int do_demangle
; /* -C, --demangle */
102 static bfd_boolean disassemble
; /* -d */
103 static bfd_boolean disassemble_all
; /* -D */
104 static int disassemble_zeroes
; /* --disassemble-zeroes */
105 static bfd_boolean formats_info
; /* -i */
106 static int wide_output
; /* -w */
107 static int insn_width
; /* --insn-width */
108 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
109 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
110 static int dump_debugging
; /* --debugging */
111 static int dump_debugging_tags
; /* --debugging-tags */
112 static int dump_special_syms
= 0; /* --special-syms */
113 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
114 static int file_start_context
= 0; /* --file-start-context */
115 static bfd_boolean display_file_offsets
;/* -F */
116 static const char *prefix
; /* --prefix */
117 static int prefix_strip
; /* --prefix-strip */
118 static size_t prefix_length
;
120 /* A structure to record the sections mentioned in -j switches. */
123 const char * name
; /* The name of the section. */
124 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
125 struct only
* next
; /* Pointer to the next structure in the list. */
127 /* Pointer to an array of 'only' structures.
128 This pointer is NULL if the -j switch has not been used. */
129 static struct only
* only_list
= NULL
;
131 /* Variables for handling include file path table. */
132 static const char **include_paths
;
133 static int include_path_count
;
135 /* Extra info to pass to the section disassembler and address printing
137 struct objdump_disasm_info
141 bfd_boolean require_sec
;
142 arelent
** dynrelbuf
;
144 disassembler_ftype disassemble_fn
;
148 /* Architecture to disassemble for, or default if NULL. */
149 static char *machine
= NULL
;
151 /* Target specific options to the disassembler. */
152 static char *disassembler_options
= NULL
;
154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
155 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
157 /* The symbol table. */
158 static asymbol
**syms
;
160 /* Number of symbols in `syms'. */
161 static long symcount
= 0;
163 /* The sorted symbol table. */
164 static asymbol
**sorted_syms
;
166 /* Number of symbols in `sorted_syms'. */
167 static long sorted_symcount
= 0;
169 /* The dynamic symbol table. */
170 static asymbol
**dynsyms
;
172 /* The synthetic symbol table. */
173 static asymbol
*synthsyms
;
174 static long synthcount
= 0;
176 /* Number of symbols in `dynsyms'. */
177 static long dynsymcount
= 0;
179 static bfd_byte
*stabs
;
180 static bfd_size_type stab_size
;
183 static bfd_size_type stabstr_size
;
185 static bfd_boolean is_relocatable
= FALSE
;
188 usage (FILE *stream
, int status
)
190 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
191 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
192 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
193 fprintf (stream
, _("\
194 -a, --archive-headers Display archive header information\n\
195 -f, --file-headers Display the contents of the overall file header\n\
196 -p, --private-headers Display object format specific file header contents\n\
197 -h, --[section-]headers Display the contents of the section headers\n\
198 -x, --all-headers Display the contents of all headers\n\
199 -d, --disassemble Display assembler contents of executable sections\n\
200 -D, --disassemble-all Display assembler contents of all sections\n\
201 -S, --source Intermix source code with disassembly\n\
202 -s, --full-contents Display the full contents of all sections requested\n\
203 -g, --debugging Display debug information in object file\n\
204 -e, --debugging-tags Display debug information using ctags style\n\
205 -G, --stabs Display (in raw form) any STABS info in the file\n\
206 -W[lLiaprmfFsoRt] or\n\
207 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
208 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
209 Display DWARF info in the file\n\
210 -t, --syms Display the contents of the symbol table(s)\n\
211 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
212 -r, --reloc Display the relocation entries in the file\n\
213 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
214 @<file> Read options from <file>\n\
215 -v, --version Display this program's version number\n\
216 -i, --info List object formats and architectures supported\n\
217 -H, --help Display this information\n\
221 fprintf (stream
, _("\n The following switches are optional:\n"));
222 fprintf (stream
, _("\
223 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
224 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
225 -j, --section=NAME Only display information for section NAME\n\
226 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
227 -EB --endian=big Assume big endian format when disassembling\n\
228 -EL --endian=little Assume little endian format when disassembling\n\
229 --file-start-context Include context from start of file (with -S)\n\
230 -I, --include=DIR Add DIR to search list for source files\n\
231 -l, --line-numbers Include line numbers and filenames in output\n\
232 -F, --file-offsets Include file offsets when displaying information\n\
233 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
234 The STYLE, if specified, can be `auto', `gnu',\n\
235 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
237 -w, --wide Format output for more than 80 columns\n\
238 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
239 --start-address=ADDR Only process data whose address is >= ADDR\n\
240 --stop-address=ADDR Only process data whose address is <= ADDR\n\
241 --prefix-addresses Print complete address alongside disassembly\n\
242 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
243 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
244 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
245 --special-syms Include special symbols in symbol dumps\n\
246 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
247 --prefix-strip=LEVEL Strip initial directory names for -S\n\
249 list_supported_targets (program_name
, stream
);
250 list_supported_architectures (program_name
, stream
);
252 disassembler_usage (stream
);
254 if (REPORT_BUGS_TO
[0] && status
== 0)
255 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
259 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
263 OPTION_START_ADDRESS
,
272 static struct option long_options
[]=
274 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
275 {"all-headers", no_argument
, NULL
, 'x'},
276 {"private-headers", no_argument
, NULL
, 'p'},
277 {"architecture", required_argument
, NULL
, 'm'},
278 {"archive-headers", no_argument
, NULL
, 'a'},
279 {"debugging", no_argument
, NULL
, 'g'},
280 {"debugging-tags", no_argument
, NULL
, 'e'},
281 {"demangle", optional_argument
, NULL
, 'C'},
282 {"disassemble", no_argument
, NULL
, 'd'},
283 {"disassemble-all", no_argument
, NULL
, 'D'},
284 {"disassembler-options", required_argument
, NULL
, 'M'},
285 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
286 {"dynamic-reloc", no_argument
, NULL
, 'R'},
287 {"dynamic-syms", no_argument
, NULL
, 'T'},
288 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
289 {"file-headers", no_argument
, NULL
, 'f'},
290 {"file-offsets", no_argument
, NULL
, 'F'},
291 {"file-start-context", no_argument
, &file_start_context
, 1},
292 {"full-contents", no_argument
, NULL
, 's'},
293 {"headers", no_argument
, NULL
, 'h'},
294 {"help", no_argument
, NULL
, 'H'},
295 {"info", no_argument
, NULL
, 'i'},
296 {"line-numbers", no_argument
, NULL
, 'l'},
297 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
298 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
299 {"reloc", no_argument
, NULL
, 'r'},
300 {"section", required_argument
, NULL
, 'j'},
301 {"section-headers", no_argument
, NULL
, 'h'},
302 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
303 {"source", no_argument
, NULL
, 'S'},
304 {"special-syms", no_argument
, &dump_special_syms
, 1},
305 {"include", required_argument
, NULL
, 'I'},
306 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
307 {"stabs", no_argument
, NULL
, 'G'},
308 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
309 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
310 {"syms", no_argument
, NULL
, 't'},
311 {"target", required_argument
, NULL
, 'b'},
312 {"version", no_argument
, NULL
, 'V'},
313 {"wide", no_argument
, NULL
, 'w'},
314 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
315 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
316 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
317 {0, no_argument
, 0, 0}
321 nonfatal (const char *msg
)
327 /* Returns TRUE if the specified section should be dumped. */
330 process_section_p (asection
* section
)
334 if (only_list
== NULL
)
337 for (only
= only_list
; only
; only
= only
->next
)
338 if (strcmp (only
->name
, section
->name
) == 0)
347 /* Add an entry to the 'only' list. */
350 add_only (char * name
)
354 /* First check to make sure that we do not
355 already have an entry for this name. */
356 for (only
= only_list
; only
; only
= only
->next
)
357 if (strcmp (only
->name
, name
) == 0)
360 only
= xmalloc (sizeof * only
);
363 only
->next
= only_list
;
367 /* Release the memory used by the 'only' list.
368 PR 11225: Issue a warning message for unseen sections.
369 Only do this if none of the sections were seen. This is mainly to support
370 tools like the GAS testsuite where an object file is dumped with a list of
371 generic section names known to be present in a range of different file
375 free_only_list (void)
377 bfd_boolean at_least_one_seen
= FALSE
;
381 if (only_list
== NULL
)
384 for (only
= only_list
; only
; only
= only
->next
)
387 at_least_one_seen
= TRUE
;
391 for (only
= only_list
; only
; only
= next
)
393 if (! at_least_one_seen
)
395 non_fatal (_("Section '%s' mentioned in a -j option, but not found in any input file"),
406 dump_section_header (bfd
*abfd
, asection
*section
,
407 void *ignored ATTRIBUTE_UNUSED
)
410 unsigned int opb
= bfd_octets_per_byte (abfd
);
412 /* Ignore linker created section. See elfNN_ia64_object_p in
414 if (section
->flags
& SEC_LINKER_CREATED
)
417 /* PR 10413: Skip sections that we are ignoring. */
418 if (! process_section_p (section
))
421 printf ("%3d %-13s %08lx ", section
->index
,
422 bfd_get_section_name (abfd
, section
),
423 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
424 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
426 bfd_printf_vma (abfd
, section
->lma
);
427 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
428 bfd_get_section_alignment (abfd
, section
));
434 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
436 PF (SEC_HAS_CONTENTS
, "CONTENTS");
437 PF (SEC_ALLOC
, "ALLOC");
438 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
439 PF (SEC_LOAD
, "LOAD");
440 PF (SEC_RELOC
, "RELOC");
441 PF (SEC_READONLY
, "READONLY");
442 PF (SEC_CODE
, "CODE");
443 PF (SEC_DATA
, "DATA");
445 PF (SEC_DEBUGGING
, "DEBUGGING");
446 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
447 PF (SEC_EXCLUDE
, "EXCLUDE");
448 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
449 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
451 PF (SEC_TIC54X_BLOCK
, "BLOCK");
452 PF (SEC_TIC54X_CLINK
, "CLINK");
454 PF (SEC_SMALL_DATA
, "SMALL_DATA");
455 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
456 PF (SEC_COFF_SHARED
, "SHARED");
457 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
458 PF (SEC_GROUP
, "GROUP");
460 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
463 struct coff_comdat_info
*comdat
;
465 switch (section
->flags
& SEC_LINK_DUPLICATES
)
469 case SEC_LINK_DUPLICATES_DISCARD
:
470 ls
= "LINK_ONCE_DISCARD";
472 case SEC_LINK_DUPLICATES_ONE_ONLY
:
473 ls
= "LINK_ONCE_ONE_ONLY";
475 case SEC_LINK_DUPLICATES_SAME_SIZE
:
476 ls
= "LINK_ONCE_SAME_SIZE";
478 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
479 ls
= "LINK_ONCE_SAME_CONTENTS";
482 printf ("%s%s", comma
, ls
);
484 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
486 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
496 dump_headers (bfd
*abfd
)
498 printf (_("Sections:\n"));
501 printf (_("Idx Name Size VMA LMA File off Algn"));
503 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
504 if (bfd_get_arch_size (abfd
) == 32)
505 printf (_("Idx Name Size VMA LMA File off Algn"));
507 printf (_("Idx Name Size VMA LMA File off Algn"));
511 printf (_(" Flags"));
512 if (abfd
->flags
& HAS_LOAD_PAGE
)
516 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
520 slurp_symtab (bfd
*abfd
)
525 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
531 storage
= bfd_get_symtab_upper_bound (abfd
);
533 bfd_fatal (bfd_get_filename (abfd
));
535 sy
= (asymbol
**) xmalloc (storage
);
537 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
539 bfd_fatal (bfd_get_filename (abfd
));
543 /* Read in the dynamic symbols. */
546 slurp_dynamic_symtab (bfd
*abfd
)
551 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
554 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
556 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
561 bfd_fatal (bfd_get_filename (abfd
));
564 sy
= (asymbol
**) xmalloc (storage
);
566 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
568 bfd_fatal (bfd_get_filename (abfd
));
572 /* Filter out (in place) symbols that are useless for disassembly.
573 COUNT is the number of elements in SYMBOLS.
574 Return the number of useful symbols. */
577 remove_useless_symbols (asymbol
**symbols
, long count
)
579 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
583 asymbol
*sym
= *in_ptr
++;
585 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
587 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
589 if (bfd_is_und_section (sym
->section
)
590 || bfd_is_com_section (sym
->section
))
595 return out_ptr
- symbols
;
598 /* Sort symbols into value order. */
601 compare_symbols (const void *ap
, const void *bp
)
603 const asymbol
*a
= * (const asymbol
**) ap
;
604 const asymbol
*b
= * (const asymbol
**) bp
;
614 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
616 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
619 if (a
->section
> b
->section
)
621 else if (a
->section
< b
->section
)
624 an
= bfd_asymbol_name (a
);
625 bn
= bfd_asymbol_name (b
);
629 /* The symbols gnu_compiled and gcc2_compiled convey no real
630 information, so put them after other symbols with the same value. */
631 af
= (strstr (an
, "gnu_compiled") != NULL
632 || strstr (an
, "gcc2_compiled") != NULL
);
633 bf
= (strstr (bn
, "gnu_compiled") != NULL
634 || strstr (bn
, "gcc2_compiled") != NULL
);
641 /* We use a heuristic for the file name, to try to sort it after
642 more useful symbols. It may not work on non Unix systems, but it
643 doesn't really matter; the only difference is precisely which
644 symbol names get printed. */
646 #define file_symbol(s, sn, snl) \
647 (((s)->flags & BSF_FILE) != 0 \
648 || ((sn)[(snl) - 2] == '.' \
649 && ((sn)[(snl) - 1] == 'o' \
650 || (sn)[(snl) - 1] == 'a')))
652 af
= file_symbol (a
, an
, anl
);
653 bf
= file_symbol (b
, bn
, bnl
);
660 /* Try to sort global symbols before local symbols before function
661 symbols before debugging symbols. */
666 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
668 if ((aflags
& BSF_DEBUGGING
) != 0)
673 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
675 if ((aflags
& BSF_FUNCTION
) != 0)
680 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
682 if ((aflags
& BSF_LOCAL
) != 0)
687 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
689 if ((aflags
& BSF_GLOBAL
) != 0)
695 /* Symbols that start with '.' might be section names, so sort them
696 after symbols that don't start with '.'. */
697 if (an
[0] == '.' && bn
[0] != '.')
699 if (an
[0] != '.' && bn
[0] == '.')
702 /* Finally, if we can't distinguish them in any other way, try to
703 get consistent results by sorting the symbols by name. */
704 return strcmp (an
, bn
);
707 /* Sort relocs into address order. */
710 compare_relocs (const void *ap
, const void *bp
)
712 const arelent
*a
= * (const arelent
**) ap
;
713 const arelent
*b
= * (const arelent
**) bp
;
715 if (a
->address
> b
->address
)
717 else if (a
->address
< b
->address
)
720 /* So that associated relocations tied to the same address show up
721 in the correct order, we don't do any further sorting. */
730 /* Print an address (VMA) to the output stream in INFO.
731 If SKIP_ZEROES is TRUE, omit leading zeroes. */
734 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
735 bfd_boolean skip_zeroes
)
739 struct objdump_disasm_info
*aux
;
741 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
742 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
747 for (p
= buf
; *p
== '0'; ++p
)
752 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
755 /* Print the name of a symbol. */
758 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
765 name
= bfd_asymbol_name (sym
);
766 if (do_demangle
&& name
[0] != '\0')
768 /* Demangle the name. */
769 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
775 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
783 /* Locate a symbol given a bfd and a section (from INFO->application_data),
784 and a VMA. If INFO->application_data->require_sec is TRUE, then always
785 require the symbol to be in the section. Returns NULL if there is no
786 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
787 of the symbol in sorted_syms. */
790 find_symbol_for_address (bfd_vma vma
,
791 struct disassemble_info
*inf
,
794 /* @@ Would it speed things up to cache the last two symbols returned,
795 and maybe their address ranges? For many processors, only one memory
796 operand can be present at a time, so the 2-entry cache wouldn't be
797 constantly churned by code doing heavy memory accesses. */
799 /* Indices in `sorted_syms'. */
801 long max_count
= sorted_symcount
;
803 struct objdump_disasm_info
*aux
;
807 bfd_boolean want_section
;
809 if (sorted_symcount
< 1)
812 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
815 opb
= inf
->octets_per_byte
;
817 /* Perform a binary search looking for the closest symbol to the
818 required value. We are searching the range (min, max_count]. */
819 while (min
+ 1 < max_count
)
823 thisplace
= (max_count
+ min
) / 2;
824 sym
= sorted_syms
[thisplace
];
826 if (bfd_asymbol_value (sym
) > vma
)
827 max_count
= thisplace
;
828 else if (bfd_asymbol_value (sym
) < vma
)
837 /* The symbol we want is now in min, the low end of the range we
838 were searching. If there are several symbols with the same
839 value, we want the first one. */
842 && (bfd_asymbol_value (sorted_syms
[thisplace
])
843 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
846 /* Prefer a symbol in the current section if we have multple symbols
847 with the same value, as can occur with overlays or zero size
850 while (min
< max_count
851 && (bfd_asymbol_value (sorted_syms
[min
])
852 == bfd_asymbol_value (sorted_syms
[thisplace
])))
854 if (sorted_syms
[min
]->section
== sec
855 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
862 return sorted_syms
[thisplace
];
867 /* If the file is relocatable, and the symbol could be from this
868 section, prefer a symbol from this section over symbols from
869 others, even if the other symbol's value might be closer.
871 Note that this may be wrong for some symbol references if the
872 sections have overlapping memory ranges, but in that case there's
873 no way to tell what's desired without looking at the relocation
876 Also give the target a chance to reject symbols. */
877 want_section
= (aux
->require_sec
878 || ((abfd
->flags
& HAS_RELOC
) != 0
879 && vma
>= bfd_get_section_vma (abfd
, sec
)
880 && vma
< (bfd_get_section_vma (abfd
, sec
)
881 + bfd_section_size (abfd
, sec
) / opb
)));
882 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
883 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
886 long newplace
= sorted_symcount
;
888 for (i
= min
- 1; i
>= 0; i
--)
890 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
891 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
893 if (newplace
== sorted_symcount
)
896 if (bfd_asymbol_value (sorted_syms
[i
])
897 != bfd_asymbol_value (sorted_syms
[newplace
]))
900 /* Remember this symbol and keep searching until we reach
901 an earlier address. */
906 if (newplace
!= sorted_symcount
)
907 thisplace
= newplace
;
910 /* We didn't find a good symbol with a smaller value.
911 Look for one with a larger value. */
912 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
914 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
915 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
923 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
924 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
925 /* There is no suitable symbol. */
932 return sorted_syms
[thisplace
];
935 /* Print an address and the offset to the nearest symbol. */
938 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
939 bfd_vma vma
, struct disassemble_info
*inf
,
940 bfd_boolean skip_zeroes
)
942 objdump_print_value (vma
, inf
, skip_zeroes
);
948 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
949 bfd_get_section_name (abfd
, sec
));
950 secaddr
= bfd_get_section_vma (abfd
, sec
);
953 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
954 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
956 else if (vma
> secaddr
)
958 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
959 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
961 (*inf
->fprintf_func
) (inf
->stream
, ">");
965 (*inf
->fprintf_func
) (inf
->stream
, " <");
966 objdump_print_symname (abfd
, inf
, sym
);
967 if (bfd_asymbol_value (sym
) > vma
)
969 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
970 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
972 else if (vma
> bfd_asymbol_value (sym
))
974 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
975 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
977 (*inf
->fprintf_func
) (inf
->stream
, ">");
980 if (display_file_offsets
)
981 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
982 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
985 /* Print an address (VMA), symbolically if possible.
986 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
989 objdump_print_addr (bfd_vma vma
,
990 struct disassemble_info
*inf
,
991 bfd_boolean skip_zeroes
)
993 struct objdump_disasm_info
*aux
;
995 bfd_boolean skip_find
= FALSE
;
997 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
999 if (sorted_symcount
< 1)
1001 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1002 objdump_print_value (vma
, inf
, skip_zeroes
);
1004 if (display_file_offsets
)
1005 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1006 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1010 if (aux
->reloc
!= NULL
1011 && aux
->reloc
->sym_ptr_ptr
!= NULL
1012 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1014 sym
= * aux
->reloc
->sym_ptr_ptr
;
1016 /* Adjust the vma to the reloc. */
1017 vma
+= bfd_asymbol_value (sym
);
1019 if (bfd_is_und_section (bfd_get_section (sym
)))
1024 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1026 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1030 /* Print VMA to INFO. This function is passed to the disassembler
1034 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1036 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1039 /* Determine if the given address has a symbol associated with it. */
1042 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1046 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1048 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1051 /* Hold the last function name and the last line number we displayed
1052 in a disassembly. */
1054 static char *prev_functionname
;
1055 static unsigned int prev_line
;
1057 /* We keep a list of all files that we have seen when doing a
1058 disassembly with source, so that we know how much of the file to
1059 display. This can be important for inlined functions. */
1061 struct print_file_list
1063 struct print_file_list
*next
;
1064 const char *filename
;
1065 const char *modname
;
1068 const char **linemap
;
1074 static struct print_file_list
*print_files
;
1076 /* The number of preceding context lines to show when we start
1077 displaying a file for the first time. */
1079 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1081 /* Read a complete file into memory. */
1084 slurp_file (const char *fn
, size_t *size
)
1087 int ps
= getpagesize ();
1092 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1096 if (fstat (fd
, &st
) < 0)
1100 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1101 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1102 if (map
!= (char *)-1L)
1108 map
= (const char *) malloc (*size
);
1109 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1118 #define line_map_decrease 5
1120 /* Precompute array of lines for a mapped file. */
1122 static const char **
1123 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1125 const char *p
, *lstart
, *end
;
1126 int chars_per_line
= 45; /* First iteration will use 40. */
1127 unsigned int lineno
;
1128 const char **linemap
= NULL
;
1129 unsigned long line_map_size
= 0;
1135 for (p
= map
; p
< end
; p
++)
1139 if (p
+ 1 < end
&& p
[1] == '\r')
1142 else if (*p
== '\r')
1144 if (p
+ 1 < end
&& p
[1] == '\n')
1150 /* End of line found. */
1152 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1154 unsigned long newsize
;
1156 chars_per_line
-= line_map_decrease
;
1157 if (chars_per_line
<= 1)
1159 line_map_size
= size
/ chars_per_line
+ 1;
1160 if (line_map_size
< lineno
+ 1)
1161 line_map_size
= lineno
+ 1;
1162 newsize
= line_map_size
* sizeof (char *);
1163 linemap
= (const char **) xrealloc (linemap
, newsize
);
1166 linemap
[lineno
++] = lstart
;
1174 /* Tries to open MODNAME, and if successful adds a node to print_files
1175 linked list and returns that node. Returns NULL on failure. */
1177 static struct print_file_list
*
1178 try_print_file_open (const char *origname
, const char *modname
)
1180 struct print_file_list
*p
;
1182 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1184 p
->map
= slurp_file (modname
, &p
->mapsize
);
1191 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1193 p
->filename
= origname
;
1194 p
->modname
= modname
;
1195 p
->next
= print_files
;
1201 /* If the the source file, as described in the symtab, is not found
1202 try to locate it in one of the paths specified with -I
1203 If found, add location to print_files linked list. */
1205 static struct print_file_list
*
1206 update_source_path (const char *filename
)
1208 struct print_file_list
*p
;
1212 if (filename
== NULL
)
1215 p
= try_print_file_open (filename
, filename
);
1219 if (include_path_count
== 0)
1222 /* Get the name of the file. */
1223 fname
= lbasename (filename
);
1225 /* If file exists under a new path, we need to add it to the list
1226 so that show_line knows about it. */
1227 for (i
= 0; i
< include_path_count
; i
++)
1229 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1231 p
= try_print_file_open (filename
, modname
);
1241 /* Print a source file line. */
1244 print_line (struct print_file_list
*p
, unsigned int linenum
)
1250 if (linenum
>= p
->maxline
)
1252 l
= p
->linemap
[linenum
];
1253 /* Test fwrite return value to quiet glibc warning. */
1254 len
= strcspn (l
, "\n\r");
1255 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1259 /* Print a range of source code lines. */
1262 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1266 while (start
<= end
)
1268 print_line (p
, start
);
1273 /* Show the line number, or the source line, in a disassembly
1277 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1279 const char *filename
;
1280 const char *functionname
;
1281 unsigned int linenumber
;
1284 if (! with_line_numbers
&& ! with_source_code
)
1287 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1288 &functionname
, &linenumber
))
1291 if (filename
!= NULL
&& *filename
== '\0')
1293 if (functionname
!= NULL
&& *functionname
== '\0')
1294 functionname
= NULL
;
1297 && IS_ABSOLUTE_PATH (filename
)
1301 const char *fname
= filename
;
1302 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1305 memcpy (path
, prefix
, prefix_length
);
1306 path_up
= path
+ prefix_length
;
1308 /* Build relocated filename, stripping off leading directories
1309 from the initial filename if requested. */
1310 if (prefix_strip
> 0)
1315 /* Skip selected directory levels. */
1316 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1317 if (IS_DIR_SEPARATOR(*s
))
1324 /* Update complete filename. */
1325 strncpy (path_up
, fname
, PATH_MAX
);
1326 path_up
[PATH_MAX
] = '\0';
1334 if (with_line_numbers
)
1336 if (functionname
!= NULL
1337 && (prev_functionname
== NULL
1338 || strcmp (functionname
, prev_functionname
) != 0))
1339 printf ("%s():\n", functionname
);
1340 if (linenumber
> 0 && linenumber
!= prev_line
)
1341 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1344 if (with_source_code
1348 struct print_file_list
**pp
, *p
;
1351 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1352 if (strcmp ((*pp
)->filename
, filename
) == 0)
1359 filename
= xstrdup (filename
);
1360 p
= update_source_path (filename
);
1363 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1365 if (file_start_context
&& p
->first
)
1369 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1370 if (l
>= linenumber
)
1372 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1373 l
= p
->last_line
+ 1;
1375 dump_lines (p
, l
, linenumber
);
1376 p
->last_line
= linenumber
;
1381 if (functionname
!= NULL
1382 && (prev_functionname
== NULL
1383 || strcmp (functionname
, prev_functionname
) != 0))
1385 if (prev_functionname
!= NULL
)
1386 free (prev_functionname
);
1387 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1388 strcpy (prev_functionname
, functionname
);
1391 if (linenumber
> 0 && linenumber
!= prev_line
)
1392 prev_line
= linenumber
;
1395 /* Pseudo FILE object for strings. */
1403 /* sprintf to a "stream". */
1405 static int ATTRIBUTE_PRINTF_2
1406 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1413 size_t space
= f
->alloc
- f
->pos
;
1415 va_start (args
, format
);
1416 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1422 f
->alloc
= (f
->alloc
+ n
) * 2;
1423 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1430 /* The number of zeroes we want to see before we start skipping them.
1431 The number is arbitrarily chosen. */
1433 #define DEFAULT_SKIP_ZEROES 8
1435 /* The number of zeroes to skip at the end of a section. If the
1436 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1437 SKIP_ZEROES, they will be disassembled. If there are fewer than
1438 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1439 attempt to avoid disassembling zeroes inserted by section
1442 #define DEFAULT_SKIP_ZEROES_AT_END 3
1444 /* Disassemble some data in memory between given values. */
1447 disassemble_bytes (struct disassemble_info
* inf
,
1448 disassembler_ftype disassemble_fn
,
1451 bfd_vma start_offset
,
1452 bfd_vma stop_offset
,
1455 arelent
** relppend
)
1457 struct objdump_disasm_info
*aux
;
1459 int octets_per_line
;
1460 bfd_boolean done_dot
;
1461 int skip_addr_chars
;
1462 bfd_vma addr_offset
;
1463 unsigned int opb
= inf
->octets_per_byte
;
1464 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1465 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1469 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1473 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1477 octets_per_line
= insn_width
;
1479 octets_per_line
= 4;
1481 octets_per_line
= 16;
1483 /* Figure out how many characters to skip at the start of an
1484 address, to make the disassembly look nicer. We discard leading
1485 zeroes in chunks of 4, ensuring that there is always a leading
1487 skip_addr_chars
= 0;
1488 if (! prefix_addresses
)
1492 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1494 while (buf
[skip_addr_chars
] == '0')
1497 /* Don't discard zeros on overflow. */
1498 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1499 skip_addr_chars
= 0;
1501 if (skip_addr_chars
!= 0)
1502 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1505 inf
->insn_info_valid
= 0;
1508 addr_offset
= start_offset
;
1509 while (addr_offset
< stop_offset
)
1512 bfd_boolean need_nl
= FALSE
;
1513 int previous_octets
;
1515 /* Remember the length of the previous instruction. */
1516 previous_octets
= octets
;
1519 /* Make sure we don't use relocs from previous instructions. */
1522 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1524 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1527 if (! disassemble_zeroes
1528 && (inf
->insn_info_valid
== 0
1529 || inf
->branch_delay_insns
== 0)
1530 && (z
- addr_offset
* opb
>= skip_zeroes
1531 || (z
== stop_offset
* opb
&&
1532 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1534 /* If there are more nonzero octets to follow, we only skip
1535 zeroes in multiples of 4, to try to avoid running over
1536 the start of an instruction which happens to start with
1538 if (z
!= stop_offset
* opb
)
1539 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1541 octets
= z
- addr_offset
* opb
;
1543 /* If we are going to display more data, and we are displaying
1544 file offsets, then tell the user how many zeroes we skip
1545 and the file offset from where we resume dumping. */
1546 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1547 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1549 (unsigned long) (section
->filepos
1550 + (addr_offset
+ (octets
/ opb
))));
1562 if (with_line_numbers
|| with_source_code
)
1563 show_line (aux
->abfd
, section
, addr_offset
);
1565 if (! prefix_addresses
)
1569 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1570 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1574 printf ("%s:\t", buf
+ skip_addr_chars
);
1578 aux
->require_sec
= TRUE
;
1579 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1580 aux
->require_sec
= FALSE
;
1587 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1588 inf
->stream
= &sfile
;
1589 inf
->bytes_per_line
= 0;
1590 inf
->bytes_per_chunk
= 0;
1591 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1593 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1595 if (inf
->disassembler_needs_relocs
1596 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1597 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1598 && *relppp
< relppend
)
1600 bfd_signed_vma distance_to_rel
;
1602 distance_to_rel
= (**relppp
)->address
1603 - (rel_offset
+ addr_offset
);
1605 /* Check to see if the current reloc is associated with
1606 the instruction that we are about to disassemble. */
1607 if (distance_to_rel
== 0
1608 /* FIXME: This is wrong. We are trying to catch
1609 relocs that are addressed part way through the
1610 current instruction, as might happen with a packed
1611 VLIW instruction. Unfortunately we do not know the
1612 length of the current instruction since we have not
1613 disassembled it yet. Instead we take a guess based
1614 upon the length of the previous instruction. The
1615 proper solution is to have a new target-specific
1616 disassembler function which just returns the length
1617 of an instruction at a given address without trying
1618 to display its disassembly. */
1619 || (distance_to_rel
> 0
1620 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1622 inf
->flags
|= INSN_HAS_RELOC
;
1623 aux
->reloc
= **relppp
;
1627 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1628 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1629 inf
->stream
= stdout
;
1630 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1631 octets_per_line
= inf
->bytes_per_line
;
1635 printf ("%s\n", sfile
.buffer
);
1643 octets
= octets_per_line
;
1644 if (addr_offset
+ octets
/ opb
> stop_offset
)
1645 octets
= (stop_offset
- addr_offset
) * opb
;
1647 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1649 if (ISPRINT (data
[j
]))
1650 buf
[j
- addr_offset
* opb
] = data
[j
];
1652 buf
[j
- addr_offset
* opb
] = '.';
1654 buf
[j
- addr_offset
* opb
] = '\0';
1657 if (prefix_addresses
1659 : show_raw_insn
>= 0)
1663 /* If ! prefix_addresses and ! wide_output, we print
1664 octets_per_line octets per line. */
1666 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1667 pb
= octets_per_line
;
1669 if (inf
->bytes_per_chunk
)
1670 bpc
= inf
->bytes_per_chunk
;
1674 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1678 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1680 for (k
= bpc
- 1; k
>= 0; k
--)
1681 printf ("%02x", (unsigned) data
[j
+ k
]);
1686 for (k
= 0; k
< bpc
; k
++)
1687 printf ("%02x", (unsigned) data
[j
+ k
]);
1692 for (; pb
< octets_per_line
; pb
+= bpc
)
1696 for (k
= 0; k
< bpc
; k
++)
1701 /* Separate raw data from instruction by extra space. */
1711 printf ("%s", sfile
.buffer
);
1713 if (prefix_addresses
1715 : show_raw_insn
>= 0)
1723 j
= addr_offset
* opb
+ pb
;
1725 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1726 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1730 printf ("%s:\t", buf
+ skip_addr_chars
);
1732 pb
+= octets_per_line
;
1735 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1739 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1741 for (k
= bpc
- 1; k
>= 0; k
--)
1742 printf ("%02x", (unsigned) data
[j
+ k
]);
1747 for (k
= 0; k
< bpc
; k
++)
1748 printf ("%02x", (unsigned) data
[j
+ k
]);
1761 while ((*relppp
) < relppend
1762 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1764 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1775 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1778 if (q
->howto
== NULL
)
1779 printf (": *unknown*\t");
1780 else if (q
->howto
->name
)
1781 printf (": %s\t", q
->howto
->name
);
1783 printf (": %d\t", q
->howto
->type
);
1785 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1786 printf ("*unknown*");
1789 const char *sym_name
;
1791 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1792 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1793 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1798 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1799 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1800 if (sym_name
== NULL
|| *sym_name
== '\0')
1801 sym_name
= "*unknown*";
1802 printf ("%s", sym_name
);
1809 objdump_print_value (q
->addend
, inf
, TRUE
);
1821 addr_offset
+= octets
/ opb
;
1824 free (sfile
.buffer
);
1828 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1830 const struct elf_backend_data
* bed
;
1831 bfd_vma sign_adjust
= 0;
1832 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1833 struct objdump_disasm_info
* paux
;
1834 unsigned int opb
= pinfo
->octets_per_byte
;
1835 bfd_byte
* data
= NULL
;
1836 bfd_size_type datasize
= 0;
1837 arelent
** rel_pp
= NULL
;
1838 arelent
** rel_ppstart
= NULL
;
1839 arelent
** rel_ppend
;
1840 unsigned long stop_offset
;
1841 asymbol
* sym
= NULL
;
1845 unsigned long addr_offset
;
1847 /* Sections that do not contain machine
1848 code are not normally disassembled. */
1849 if (! disassemble_all
1850 && only_list
== NULL
1851 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1852 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1855 if (! process_section_p (section
))
1858 datasize
= bfd_get_section_size (section
);
1862 /* Decide which set of relocs to use. Load them if necessary. */
1863 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1864 if (paux
->dynrelbuf
)
1866 rel_pp
= paux
->dynrelbuf
;
1867 rel_count
= paux
->dynrelcount
;
1868 /* Dynamic reloc addresses are absolute, non-dynamic are section
1869 relative. REL_OFFSET specifies the reloc address corresponding
1870 to the start of this section. */
1871 rel_offset
= section
->vma
;
1879 if ((section
->flags
& SEC_RELOC
) != 0
1880 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1884 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1886 bfd_fatal (bfd_get_filename (abfd
));
1890 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1891 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1893 bfd_fatal (bfd_get_filename (abfd
));
1895 /* Sort the relocs by address. */
1896 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1900 rel_ppend
= rel_pp
+ rel_count
;
1902 data
= (bfd_byte
*) xmalloc (datasize
);
1904 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1906 paux
->sec
= section
;
1907 pinfo
->buffer
= data
;
1908 pinfo
->buffer_vma
= section
->vma
;
1909 pinfo
->buffer_length
= datasize
;
1910 pinfo
->section
= section
;
1912 if (start_address
== (bfd_vma
) -1
1913 || start_address
< pinfo
->buffer_vma
)
1916 addr_offset
= start_address
- pinfo
->buffer_vma
;
1918 if (stop_address
== (bfd_vma
) -1)
1919 stop_offset
= datasize
/ opb
;
1922 if (stop_address
< pinfo
->buffer_vma
)
1925 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1926 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1927 stop_offset
= pinfo
->buffer_length
/ opb
;
1930 /* Skip over the relocs belonging to addresses below the
1932 while (rel_pp
< rel_ppend
1933 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1936 if (addr_offset
< stop_offset
)
1937 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1939 /* Find the nearest symbol forwards from our current position. */
1940 paux
->require_sec
= TRUE
;
1941 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1942 (struct disassemble_info
*) inf
,
1944 paux
->require_sec
= FALSE
;
1946 /* PR 9774: If the target used signed addresses then we must make
1947 sure that we sign extend the value that we calculate for 'addr'
1948 in the loop below. */
1949 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1950 && (bed
= get_elf_backend_data (abfd
)) != NULL
1951 && bed
->sign_extend_vma
)
1952 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
1954 /* Disassemble a block of instructions up to the address associated with
1955 the symbol we have just found. Then print the symbol and find the
1956 next symbol on. Repeat until we have disassembled the entire section
1957 or we have reached the end of the address range we are interested in. */
1958 while (addr_offset
< stop_offset
)
1962 unsigned long nextstop_offset
;
1965 addr
= section
->vma
+ addr_offset
;
1966 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
1968 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1973 (x
< sorted_symcount
1974 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1978 pinfo
->symbols
= sorted_syms
+ place
;
1979 pinfo
->num_symbols
= x
- place
;
1980 pinfo
->symtab_pos
= place
;
1984 pinfo
->symbols
= NULL
;
1985 pinfo
->num_symbols
= 0;
1986 pinfo
->symtab_pos
= -1;
1989 if (! prefix_addresses
)
1991 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1992 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1994 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1997 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1999 else if (sym
== NULL
)
2003 #define is_valid_next_sym(SYM) \
2004 ((SYM)->section == section \
2005 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2006 && pinfo->symbol_is_valid (SYM, pinfo))
2008 /* Search forward for the next appropriate symbol in
2009 SECTION. Note that all the symbols are sorted
2010 together into one big array, and that some sections
2011 may have overlapping addresses. */
2012 while (place
< sorted_symcount
2013 && ! is_valid_next_sym (sorted_syms
[place
]))
2016 if (place
>= sorted_symcount
)
2019 nextsym
= sorted_syms
[place
];
2022 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2023 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2024 else if (nextsym
== NULL
)
2025 nextstop_offset
= stop_offset
;
2027 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2029 if (nextstop_offset
> stop_offset
2030 || nextstop_offset
<= addr_offset
)
2031 nextstop_offset
= stop_offset
;
2033 /* If a symbol is explicitly marked as being an object
2034 rather than a function, just dump the bytes without
2035 disassembling them. */
2038 || sym
->section
!= section
2039 || bfd_asymbol_value (sym
) > addr
2040 || ((sym
->flags
& BSF_OBJECT
) == 0
2041 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2043 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2045 || (sym
->flags
& BSF_FUNCTION
) != 0)
2050 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2051 addr_offset
, nextstop_offset
,
2052 rel_offset
, &rel_pp
, rel_ppend
);
2054 addr_offset
= nextstop_offset
;
2060 if (rel_ppstart
!= NULL
)
2064 /* Disassemble the contents of an object file. */
2067 disassemble_data (bfd
*abfd
)
2069 struct disassemble_info disasm_info
;
2070 struct objdump_disasm_info aux
;
2074 prev_functionname
= NULL
;
2077 /* We make a copy of syms to sort. We don't want to sort syms
2078 because that will screw up the relocs. */
2079 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2080 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2081 * sizeof (asymbol
*));
2082 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2083 sorted_symcount
* sizeof (asymbol
*));
2085 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2087 for (i
= 0; i
< synthcount
; ++i
)
2089 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2093 /* Sort the symbols into section and symbol order. */
2094 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2096 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2098 disasm_info
.application_data
= (void *) &aux
;
2100 aux
.require_sec
= FALSE
;
2101 aux
.dynrelbuf
= NULL
;
2102 aux
.dynrelcount
= 0;
2105 disasm_info
.print_address_func
= objdump_print_address
;
2106 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2108 if (machine
!= NULL
)
2110 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2113 fatal (_("Can't use supplied machine %s"), machine
);
2115 abfd
->arch_info
= inf
;
2118 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2120 struct bfd_target
*xvec
;
2122 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2123 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2124 xvec
->byteorder
= endian
;
2128 /* Use libopcodes to locate a suitable disassembler. */
2129 aux
.disassemble_fn
= disassembler (abfd
);
2130 if (!aux
.disassemble_fn
)
2132 non_fatal (_("Can't disassemble for architecture %s\n"),
2133 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2138 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2139 disasm_info
.arch
= bfd_get_arch (abfd
);
2140 disasm_info
.mach
= bfd_get_mach (abfd
);
2141 disasm_info
.disassembler_options
= disassembler_options
;
2142 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2143 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2144 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2145 disasm_info
.disassembler_needs_relocs
= FALSE
;
2147 if (bfd_big_endian (abfd
))
2148 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2149 else if (bfd_little_endian (abfd
))
2150 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2152 /* ??? Aborting here seems too drastic. We could default to big or little
2154 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2156 /* Allow the target to customize the info structure. */
2157 disassemble_init_for_target (& disasm_info
);
2159 /* Pre-load the dynamic relocs if we are going
2160 to be dumping them along with the disassembly. */
2161 if (dump_dynamic_reloc_info
)
2163 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2166 bfd_fatal (bfd_get_filename (abfd
));
2170 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2171 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2174 if (aux
.dynrelcount
< 0)
2175 bfd_fatal (bfd_get_filename (abfd
));
2177 /* Sort the relocs by address. */
2178 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2182 disasm_info
.symtab
= sorted_syms
;
2183 disasm_info
.symtab_size
= sorted_symcount
;
2185 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2187 if (aux
.dynrelbuf
!= NULL
)
2188 free (aux
.dynrelbuf
);
2193 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2194 asection
*sec
, void *file
)
2196 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2197 bfd
*abfd
= (bfd
*) file
;
2199 int section_is_compressed
;
2201 /* If it is already loaded, do nothing. */
2202 if (section
->start
!= NULL
)
2205 section_is_compressed
= section
->name
== section
->compressed_name
;
2207 section
->address
= 0;
2208 section
->size
= bfd_get_section_size (sec
);
2209 section
->start
= (unsigned char *) xmalloc (section
->size
);
2211 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2212 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2217 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2222 free_debug_section (debug
);
2223 printf (_("\nCan't get contents for section '%s'.\n"),
2228 if (section_is_compressed
)
2230 bfd_size_type size
= section
->size
;
2231 if (! bfd_uncompress_section_contents (§ion
->start
, &size
))
2233 free_debug_section (debug
);
2234 printf (_("\nCan't uncompress section '%s'.\n"), section
->name
);
2237 section
->size
= size
;
2244 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2246 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2247 bfd
*abfd
= (bfd
*) file
;
2250 /* If it is already loaded, do nothing. */
2251 if (section
->start
!= NULL
)
2254 /* Locate the debug section. */
2255 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2257 section
->name
= section
->uncompressed_name
;
2260 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2262 section
->name
= section
->compressed_name
;
2267 return load_specific_debug_section (debug
, sec
, file
);
2271 free_debug_section (enum dwarf_section_display_enum debug
)
2273 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2275 if (section
->start
== NULL
)
2278 free ((char *) section
->start
);
2279 section
->start
= NULL
;
2280 section
->address
= 0;
2285 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2286 void *arg ATTRIBUTE_UNUSED
)
2288 const char *name
= bfd_get_section_name (abfd
, section
);
2292 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2293 match
= ".debug_info";
2297 for (i
= 0; i
< max
; i
++)
2298 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2299 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2300 && debug_displays
[i
].enabled
!= NULL
2301 && *debug_displays
[i
].enabled
)
2303 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2305 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2306 sec
->name
= sec
->uncompressed_name
;
2308 sec
->name
= sec
->compressed_name
;
2309 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2312 debug_displays
[i
].display (sec
, abfd
);
2314 if (i
!= info
&& i
!= abbrev
)
2315 free_debug_section ((enum dwarf_section_display_enum
) i
);
2321 /* Dump the dwarf debugging information. */
2324 dump_dwarf (bfd
*abfd
)
2326 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2328 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2329 targets will return 64. */
2330 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2332 if (bfd_big_endian (abfd
))
2333 byte_get
= byte_get_big_endian
;
2334 else if (bfd_little_endian (abfd
))
2335 byte_get
= byte_get_little_endian
;
2339 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2341 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2342 init_dwarf_regnames (bed
->elf_machine_code
);
2345 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2347 free_debug_memory ();
2350 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2351 it. Return NULL on failure. */
2354 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2360 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2361 if (stabsect
== NULL
)
2363 printf (_("No %s section present\n\n"), sect_name
);
2367 size
= bfd_section_size (abfd
, stabsect
);
2368 contents
= (char *) xmalloc (size
);
2370 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2372 non_fatal (_("Reading %s section of %s failed: %s"),
2373 sect_name
, bfd_get_filename (abfd
),
2374 bfd_errmsg (bfd_get_error ()));
2385 /* Stabs entries use a 12 byte format:
2386 4 byte string table index
2388 1 byte stab other field
2389 2 byte stab desc field
2391 FIXME: This will have to change for a 64 bit object format. */
2393 #define STRDXOFF (0)
2395 #define OTHEROFF (5)
2398 #define STABSIZE (12)
2400 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2401 using string table section STRSECT_NAME (in `strtab'). */
2404 print_section_stabs (bfd
*abfd
,
2405 const char *stabsect_name
,
2406 unsigned *string_offset_ptr
)
2409 unsigned file_string_table_offset
= 0;
2410 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2411 bfd_byte
*stabp
, *stabs_end
;
2414 stabs_end
= stabp
+ stab_size
;
2416 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2417 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2419 /* Loop through all symbols and print them.
2421 We start the index at -1 because there is a dummy symbol on
2422 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2423 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2427 unsigned char type
, other
;
2428 unsigned short desc
;
2431 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2432 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2433 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2434 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2435 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2437 printf ("\n%-6d ", i
);
2438 /* Either print the stab name, or, if unnamed, print its number
2439 again (makes consistent formatting for tools like awk). */
2440 name
= bfd_get_stab_name (type
);
2442 printf ("%-6s", name
);
2443 else if (type
== N_UNDF
)
2446 printf ("%-6d", type
);
2447 printf (" %-6d %-6d ", other
, desc
);
2448 bfd_printf_vma (abfd
, value
);
2449 printf (" %-6lu", strx
);
2451 /* Symbols with type == 0 (N_UNDF) specify the length of the
2452 string table associated with this file. We use that info
2453 to know how to relocate the *next* file's string table indices. */
2456 file_string_table_offset
= next_file_string_table_offset
;
2457 next_file_string_table_offset
+= value
;
2461 /* Using the (possibly updated) string table offset, print the
2462 string (if any) associated with this symbol. */
2463 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2464 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2470 *string_offset_ptr
= next_file_string_table_offset
;
2475 const char * section_name
;
2476 const char * string_section_name
;
2477 unsigned string_offset
;
2482 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2485 stab_section_names
* sought
= (stab_section_names
*) names
;
2487 /* Check for section names for which stabsect_name is a prefix, to
2488 handle .stab.N, etc. */
2489 len
= strlen (sought
->section_name
);
2491 /* If the prefix matches, and the files section name ends with a
2492 nul or a digit, then we match. I.e., we want either an exact
2493 match or a section followed by a number. */
2494 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2495 && (section
->name
[len
] == 0
2496 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2499 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2504 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2507 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2513 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2515 stab_section_names s
;
2517 s
.section_name
= stabsect_name
;
2518 s
.string_section_name
= strsect_name
;
2519 s
.string_offset
= 0;
2521 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2527 /* Dump the any sections containing stabs debugging information. */
2530 dump_stabs (bfd
*abfd
)
2532 dump_stabs_section (abfd
, ".stab", ".stabstr");
2533 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2534 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2537 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2539 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2543 dump_bfd_header (bfd
*abfd
)
2547 printf (_("architecture: %s, "),
2548 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2549 bfd_get_mach (abfd
)));
2550 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2552 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2553 PF (HAS_RELOC
, "HAS_RELOC");
2554 PF (EXEC_P
, "EXEC_P");
2555 PF (HAS_LINENO
, "HAS_LINENO");
2556 PF (HAS_DEBUG
, "HAS_DEBUG");
2557 PF (HAS_SYMS
, "HAS_SYMS");
2558 PF (HAS_LOCALS
, "HAS_LOCALS");
2559 PF (DYNAMIC
, "DYNAMIC");
2560 PF (WP_TEXT
, "WP_TEXT");
2561 PF (D_PAGED
, "D_PAGED");
2562 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2563 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2564 printf (_("\nstart address 0x"));
2565 bfd_printf_vma (abfd
, abfd
->start_address
);
2571 dump_bfd_private_header (bfd
*abfd
)
2573 bfd_print_private_bfd_data (abfd
, stdout
);
2577 /* Display a section in hexadecimal format with associated characters.
2578 Each line prefixed by the zero padded address. */
2581 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2584 bfd_size_type datasize
;
2585 bfd_size_type addr_offset
;
2586 bfd_size_type start_offset
;
2587 bfd_size_type stop_offset
;
2588 unsigned int opb
= bfd_octets_per_byte (abfd
);
2589 /* Bytes per line. */
2590 const int onaline
= 16;
2595 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2598 if (! process_section_p (section
))
2601 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2604 /* Compute the address range to display. */
2605 if (start_address
== (bfd_vma
) -1
2606 || start_address
< section
->vma
)
2609 start_offset
= start_address
- section
->vma
;
2611 if (stop_address
== (bfd_vma
) -1)
2612 stop_offset
= datasize
/ opb
;
2615 if (stop_address
< section
->vma
)
2618 stop_offset
= stop_address
- section
->vma
;
2620 if (stop_offset
> datasize
/ opb
)
2621 stop_offset
= datasize
/ opb
;
2624 if (start_offset
>= stop_offset
)
2627 printf (_("Contents of section %s:"), section
->name
);
2628 if (display_file_offsets
)
2629 printf (_(" (Starting at file offset: 0x%lx)"),
2630 (unsigned long) (section
->filepos
+ start_offset
));
2633 data
= (bfd_byte
*) xmalloc (datasize
);
2635 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2639 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2640 if (strlen (buf
) >= sizeof (buf
))
2644 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2646 count
= strlen (buf
) - count
;
2650 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2651 if (strlen (buf
) >= sizeof (buf
))
2655 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2657 count
= strlen (buf
) - count
;
2661 for (addr_offset
= start_offset
;
2662 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2666 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2667 count
= strlen (buf
);
2668 if ((size_t) count
>= sizeof (buf
))
2672 while (count
< width
)
2677 fputs (buf
+ count
- width
, stdout
);
2680 for (j
= addr_offset
* opb
;
2681 j
< addr_offset
* opb
+ onaline
; j
++)
2683 if (j
< stop_offset
* opb
)
2684 printf ("%02x", (unsigned) (data
[j
]));
2692 for (j
= addr_offset
* opb
;
2693 j
< addr_offset
* opb
+ onaline
; j
++)
2695 if (j
>= stop_offset
* opb
)
2698 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2705 /* Actually display the various requested regions. */
2708 dump_data (bfd
*abfd
)
2710 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2713 /* Should perhaps share code and display with nm? */
2716 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2725 max_count
= dynsymcount
;
2726 printf ("DYNAMIC SYMBOL TABLE:\n");
2731 max_count
= symcount
;
2732 printf ("SYMBOL TABLE:\n");
2736 printf (_("no symbols\n"));
2738 for (count
= 0; count
< max_count
; count
++)
2742 if (*current
== NULL
)
2743 printf (_("no information for symbol number %ld\n"), count
);
2745 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2746 printf (_("could not determine the type of symbol number %ld\n"),
2749 else if (process_section_p ((* current
)->section
)
2750 && (dump_special_syms
2751 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2753 const char *name
= (*current
)->name
;
2755 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2759 /* If we want to demangle the name, we demangle it
2760 here, and temporarily clobber it while calling
2761 bfd_print_symbol. FIXME: This is a gross hack. */
2762 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2764 (*current
)->name
= alloc
;
2765 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2766 bfd_print_symbol_all
);
2769 (*current
)->name
= name
;
2774 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2775 bfd_print_symbol_all
);
2785 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2788 char *last_filename
, *last_functionname
;
2789 unsigned int last_line
;
2791 /* Get column headers lined up reasonably. */
2799 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2800 width
= strlen (buf
) - 7;
2802 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2805 last_filename
= NULL
;
2806 last_functionname
= NULL
;
2809 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2812 const char *filename
, *functionname
;
2813 unsigned int linenumber
;
2814 const char *sym_name
;
2815 const char *section_name
;
2817 if (start_address
!= (bfd_vma
) -1
2818 && q
->address
< start_address
)
2820 if (stop_address
!= (bfd_vma
) -1
2821 && q
->address
> stop_address
)
2824 if (with_line_numbers
2826 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2827 &filename
, &functionname
, &linenumber
))
2829 if (functionname
!= NULL
2830 && (last_functionname
== NULL
2831 || strcmp (functionname
, last_functionname
) != 0))
2833 printf ("%s():\n", functionname
);
2834 if (last_functionname
!= NULL
)
2835 free (last_functionname
);
2836 last_functionname
= xstrdup (functionname
);
2840 && (linenumber
!= last_line
2841 || (filename
!= NULL
2842 && last_filename
!= NULL
2843 && strcmp (filename
, last_filename
) != 0)))
2845 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2846 last_line
= linenumber
;
2847 if (last_filename
!= NULL
)
2848 free (last_filename
);
2849 if (filename
== NULL
)
2850 last_filename
= NULL
;
2852 last_filename
= xstrdup (filename
);
2856 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2858 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2859 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2864 section_name
= NULL
;
2867 bfd_printf_vma (abfd
, q
->address
);
2868 if (q
->howto
== NULL
)
2869 printf (" *unknown* ");
2870 else if (q
->howto
->name
)
2871 printf (" %-16s ", q
->howto
->name
);
2873 printf (" %-16d ", q
->howto
->type
);
2877 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2881 if (section_name
== NULL
)
2882 section_name
= "*unknown*";
2883 printf ("[%s]", section_name
);
2889 bfd_printf_vma (abfd
, q
->addend
);
2897 dump_relocs_in_section (bfd
*abfd
,
2899 void *dummy ATTRIBUTE_UNUSED
)
2905 if ( bfd_is_abs_section (section
)
2906 || bfd_is_und_section (section
)
2907 || bfd_is_com_section (section
)
2908 || (! process_section_p (section
))
2909 || ((section
->flags
& SEC_RELOC
) == 0))
2912 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2914 bfd_fatal (bfd_get_filename (abfd
));
2916 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2920 printf (" (none)\n\n");
2924 relpp
= (arelent
**) xmalloc (relsize
);
2925 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2928 bfd_fatal (bfd_get_filename (abfd
));
2929 else if (relcount
== 0)
2930 printf (" (none)\n\n");
2934 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2941 dump_relocs (bfd
*abfd
)
2943 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2947 dump_dynamic_relocs (bfd
*abfd
)
2953 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2955 bfd_fatal (bfd_get_filename (abfd
));
2957 printf ("DYNAMIC RELOCATION RECORDS");
2960 printf (" (none)\n\n");
2963 relpp
= (arelent
**) xmalloc (relsize
);
2964 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2967 bfd_fatal (bfd_get_filename (abfd
));
2968 else if (relcount
== 0)
2969 printf (" (none)\n\n");
2973 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2980 /* Creates a table of paths, to search for source files. */
2983 add_include_path (const char *path
)
2987 include_path_count
++;
2988 include_paths
= (const char **)
2989 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
2990 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2991 if (path
[1] == ':' && path
[2] == 0)
2992 path
= concat (path
, ".", (const char *) 0);
2994 include_paths
[include_path_count
- 1] = path
;
2998 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3002 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3004 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3005 section
->vma
+= adjust_section_vma
;
3007 section
->lma
+= adjust_section_vma
;
3011 /* Dump selected contents of ABFD. */
3014 dump_bfd (bfd
*abfd
)
3016 /* If we are adjusting section VMA's, change them all now. Changing
3017 the BFD information is a hack. However, we must do it, or
3018 bfd_find_nearest_line will not do the right thing. */
3019 if (adjust_section_vma
!= 0)
3021 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3022 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3025 if (! dump_debugging_tags
)
3026 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3029 print_arelt_descr (stdout
, abfd
, TRUE
);
3030 if (dump_file_header
)
3031 dump_bfd_header (abfd
);
3032 if (dump_private_headers
)
3033 dump_bfd_private_header (abfd
);
3034 if (! dump_debugging_tags
)
3036 if (dump_section_headers
)
3037 dump_headers (abfd
);
3043 || dump_dwarf_section_info
)
3044 syms
= slurp_symtab (abfd
);
3045 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3046 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3047 dynsyms
= slurp_dynamic_symtab (abfd
);
3050 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3051 dynsymcount
, dynsyms
, &synthsyms
);
3057 dump_symbols (abfd
, FALSE
);
3058 if (dump_dynamic_symtab
)
3059 dump_symbols (abfd
, TRUE
);
3060 if (dump_dwarf_section_info
)
3062 if (dump_stab_section_info
)
3064 if (dump_reloc_info
&& ! disassemble
)
3066 if (dump_dynamic_reloc_info
&& ! disassemble
)
3067 dump_dynamic_relocs (abfd
);
3068 if (dump_section_contents
)
3071 disassemble_data (abfd
);
3077 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3078 if (dhandle
!= NULL
)
3080 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3082 dump_debugging_tags
? TRUE
: FALSE
))
3084 non_fatal (_("%s: printing debugging information failed"),
3085 bfd_get_filename (abfd
));
3089 /* PR 6483: If there was no STABS or IEEE debug
3090 info in the file, try DWARF instead. */
3091 else if (! dump_dwarf_section_info
)
3121 display_bfd (bfd
*abfd
)
3125 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3131 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3133 nonfatal (bfd_get_filename (abfd
));
3134 list_matching_formats (matching
);
3139 if (bfd_get_error () != bfd_error_file_not_recognized
)
3141 nonfatal (bfd_get_filename (abfd
));
3145 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3151 nonfatal (bfd_get_filename (abfd
));
3153 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3155 list_matching_formats (matching
);
3161 display_file (char *filename
, char *target
)
3166 if (get_file_size (filename
) < 1)
3172 file
= bfd_openr (filename
, target
);
3175 nonfatal (filename
);
3179 /* If the file is an archive, process all of its elements. */
3180 if (bfd_check_format (file
, bfd_archive
))
3182 bfd
*last_arfile
= NULL
;
3184 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3187 bfd_set_error (bfd_error_no_error
);
3189 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3192 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3193 nonfatal (bfd_get_filename (file
));
3197 display_bfd (arfile
);
3199 if (last_arfile
!= NULL
)
3200 bfd_close (last_arfile
);
3201 last_arfile
= arfile
;
3204 if (last_arfile
!= NULL
)
3205 bfd_close (last_arfile
);
3214 main (int argc
, char **argv
)
3217 char *target
= default_target
;
3218 bfd_boolean seenflag
= FALSE
;
3220 #if defined (HAVE_SETLOCALE)
3221 #if defined (HAVE_LC_MESSAGES)
3222 setlocale (LC_MESSAGES
, "");
3224 setlocale (LC_CTYPE
, "");
3227 bindtextdomain (PACKAGE
, LOCALEDIR
);
3228 textdomain (PACKAGE
);
3230 program_name
= *argv
;
3231 xmalloc_set_program_name (program_name
);
3233 START_PROGRESS (program_name
, 0);
3235 expandargv (&argc
, &argv
);
3238 set_default_bfd_target ();
3240 while ((c
= getopt_long (argc
, argv
,
3241 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3242 long_options
, (int *) 0))
3248 break; /* We've been given a long option. */
3253 if (disassembler_options
)
3254 /* Ignore potential memory leak for now. */
3255 disassembler_options
= concat (disassembler_options
, ",",
3256 optarg
, (const char *) NULL
);
3258 disassembler_options
= optarg
;
3264 display_file_offsets
= TRUE
;
3267 with_line_numbers
= TRUE
;
3276 enum demangling_styles style
;
3278 style
= cplus_demangle_name_to_style (optarg
);
3279 if (style
== unknown_demangling
)
3280 fatal (_("unknown demangling style `%s'"),
3283 cplus_demangle_set_style (style
);
3289 case OPTION_ADJUST_VMA
:
3290 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3292 case OPTION_START_ADDRESS
:
3293 start_address
= parse_vma (optarg
, "--start-address");
3294 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3295 fatal (_("error: the start address should be before the end address"));
3297 case OPTION_STOP_ADDRESS
:
3298 stop_address
= parse_vma (optarg
, "--stop-address");
3299 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3300 fatal (_("error: the stop address should be after the start address"));
3304 prefix_length
= strlen (prefix
);
3305 /* Remove an unnecessary trailing '/' */
3306 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3309 case OPTION_PREFIX_STRIP
:
3310 prefix_strip
= atoi (optarg
);
3311 if (prefix_strip
< 0)
3312 fatal (_("error: prefix strip must be non-negative"));
3314 case OPTION_INSN_WIDTH
:
3315 insn_width
= strtoul (optarg
, NULL
, 0);
3316 if (insn_width
<= 0)
3317 fatal (_("error: instruction width must be positive"));
3320 if (strcmp (optarg
, "B") == 0)
3321 endian
= BFD_ENDIAN_BIG
;
3322 else if (strcmp (optarg
, "L") == 0)
3323 endian
= BFD_ENDIAN_LITTLE
;
3326 non_fatal (_("unrecognized -E option"));
3331 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3332 endian
= BFD_ENDIAN_BIG
;
3333 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3334 endian
= BFD_ENDIAN_LITTLE
;
3337 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3343 dump_file_header
= TRUE
;
3347 formats_info
= TRUE
;
3351 add_include_path (optarg
);
3354 dump_private_headers
= TRUE
;
3358 dump_private_headers
= TRUE
;
3360 dump_reloc_info
= TRUE
;
3361 dump_file_header
= TRUE
;
3362 dump_ar_hdrs
= TRUE
;
3363 dump_section_headers
= TRUE
;
3371 dump_dynamic_symtab
= TRUE
;
3379 disassemble_zeroes
= TRUE
;
3383 disassemble_all
= TRUE
;
3388 with_source_code
= TRUE
;
3397 dump_debugging_tags
= 1;
3402 dump_dwarf_section_info
= TRUE
;
3405 dwarf_select_sections_by_letters (optarg
);
3407 dwarf_select_sections_all ();
3410 dump_dwarf_section_info
= TRUE
;
3413 dwarf_select_sections_by_names (optarg
);
3415 dwarf_select_sections_all ();
3418 dump_stab_section_info
= TRUE
;
3422 dump_section_contents
= TRUE
;
3426 dump_reloc_info
= TRUE
;
3430 dump_dynamic_reloc_info
= TRUE
;
3434 dump_ar_hdrs
= TRUE
;
3438 dump_section_headers
= TRUE
;
3446 show_version
= TRUE
;
3456 print_version ("objdump");
3462 exit_status
= display_info ();
3466 display_file ("a.out", target
);
3468 for (; optind
< argc
;)
3469 display_file (argv
[optind
++], target
);
3474 END_PROGRESS (program_name
);