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 =trace_info,=trace_abbrev,=trace_aranges]\n\
210 Display DWARF info in the file\n\
211 -t, --syms Display the contents of the symbol table(s)\n\
212 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
213 -r, --reloc Display the relocation entries in the file\n\
214 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
215 @<file> Read options from <file>\n\
216 -v, --version Display this program's version number\n\
217 -i, --info List object formats and architectures supported\n\
218 -H, --help Display this information\n\
222 fprintf (stream
, _("\n The following switches are optional:\n"));
223 fprintf (stream
, _("\
224 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
225 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
226 -j, --section=NAME Only display information for section NAME\n\
227 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
228 -EB --endian=big Assume big endian format when disassembling\n\
229 -EL --endian=little Assume little endian format when disassembling\n\
230 --file-start-context Include context from start of file (with -S)\n\
231 -I, --include=DIR Add DIR to search list for source files\n\
232 -l, --line-numbers Include line numbers and filenames in output\n\
233 -F, --file-offsets Include file offsets when displaying information\n\
234 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
235 The STYLE, if specified, can be `auto', `gnu',\n\
236 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
238 -w, --wide Format output for more than 80 columns\n\
239 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
240 --start-address=ADDR Only process data whose address is >= ADDR\n\
241 --stop-address=ADDR Only process data whose address is <= ADDR\n\
242 --prefix-addresses Print complete address alongside disassembly\n\
243 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
244 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
245 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
246 --special-syms Include special symbols in symbol dumps\n\
247 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
248 --prefix-strip=LEVEL Strip initial directory names for -S\n\
250 list_supported_targets (program_name
, stream
);
251 list_supported_architectures (program_name
, stream
);
253 disassembler_usage (stream
);
255 if (REPORT_BUGS_TO
[0] && status
== 0)
256 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
260 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
264 OPTION_START_ADDRESS
,
273 static struct option long_options
[]=
275 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
276 {"all-headers", no_argument
, NULL
, 'x'},
277 {"private-headers", no_argument
, NULL
, 'p'},
278 {"architecture", required_argument
, NULL
, 'm'},
279 {"archive-headers", no_argument
, NULL
, 'a'},
280 {"debugging", no_argument
, NULL
, 'g'},
281 {"debugging-tags", no_argument
, NULL
, 'e'},
282 {"demangle", optional_argument
, NULL
, 'C'},
283 {"disassemble", no_argument
, NULL
, 'd'},
284 {"disassemble-all", no_argument
, NULL
, 'D'},
285 {"disassembler-options", required_argument
, NULL
, 'M'},
286 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
287 {"dynamic-reloc", no_argument
, NULL
, 'R'},
288 {"dynamic-syms", no_argument
, NULL
, 'T'},
289 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
290 {"file-headers", no_argument
, NULL
, 'f'},
291 {"file-offsets", no_argument
, NULL
, 'F'},
292 {"file-start-context", no_argument
, &file_start_context
, 1},
293 {"full-contents", no_argument
, NULL
, 's'},
294 {"headers", no_argument
, NULL
, 'h'},
295 {"help", no_argument
, NULL
, 'H'},
296 {"info", no_argument
, NULL
, 'i'},
297 {"line-numbers", no_argument
, NULL
, 'l'},
298 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
299 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
300 {"reloc", no_argument
, NULL
, 'r'},
301 {"section", required_argument
, NULL
, 'j'},
302 {"section-headers", no_argument
, NULL
, 'h'},
303 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
304 {"source", no_argument
, NULL
, 'S'},
305 {"special-syms", no_argument
, &dump_special_syms
, 1},
306 {"include", required_argument
, NULL
, 'I'},
307 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
308 {"stabs", no_argument
, NULL
, 'G'},
309 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
310 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
311 {"syms", no_argument
, NULL
, 't'},
312 {"target", required_argument
, NULL
, 'b'},
313 {"version", no_argument
, NULL
, 'V'},
314 {"wide", no_argument
, NULL
, 'w'},
315 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
316 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
317 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
318 {0, no_argument
, 0, 0}
322 nonfatal (const char *msg
)
328 /* Returns TRUE if the specified section should be dumped. */
331 process_section_p (asection
* section
)
335 if (only_list
== NULL
)
338 for (only
= only_list
; only
; only
= only
->next
)
339 if (strcmp (only
->name
, section
->name
) == 0)
348 /* Add an entry to the 'only' list. */
351 add_only (char * name
)
355 /* First check to make sure that we do not
356 already have an entry for this name. */
357 for (only
= only_list
; only
; only
= only
->next
)
358 if (strcmp (only
->name
, name
) == 0)
361 only
= xmalloc (sizeof * only
);
364 only
->next
= only_list
;
368 /* Release the memory used by the 'only' list.
369 PR 11225: Issue a warning message for unseen sections.
370 Only do this if none of the sections were seen. This is mainly to support
371 tools like the GAS testsuite where an object file is dumped with a list of
372 generic section names known to be present in a range of different file
376 free_only_list (void)
378 bfd_boolean at_least_one_seen
= FALSE
;
382 if (only_list
== NULL
)
385 for (only
= only_list
; only
; only
= only
->next
)
388 at_least_one_seen
= TRUE
;
392 for (only
= only_list
; only
; only
= next
)
394 if (! at_least_one_seen
)
396 non_fatal (_("section '%s' mentioned in a -j option, "
397 "but not found in any input file"),
408 dump_section_header (bfd
*abfd
, asection
*section
,
409 void *ignored ATTRIBUTE_UNUSED
)
412 unsigned int opb
= bfd_octets_per_byte (abfd
);
414 /* Ignore linker created section. See elfNN_ia64_object_p in
416 if (section
->flags
& SEC_LINKER_CREATED
)
419 /* PR 10413: Skip sections that we are ignoring. */
420 if (! process_section_p (section
))
423 printf ("%3d %-13s %08lx ", section
->index
,
424 bfd_get_section_name (abfd
, section
),
425 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
426 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
428 bfd_printf_vma (abfd
, section
->lma
);
429 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
430 bfd_get_section_alignment (abfd
, section
));
436 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
438 PF (SEC_HAS_CONTENTS
, "CONTENTS");
439 PF (SEC_ALLOC
, "ALLOC");
440 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
441 PF (SEC_LOAD
, "LOAD");
442 PF (SEC_RELOC
, "RELOC");
443 PF (SEC_READONLY
, "READONLY");
444 PF (SEC_CODE
, "CODE");
445 PF (SEC_DATA
, "DATA");
447 PF (SEC_DEBUGGING
, "DEBUGGING");
448 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
449 PF (SEC_EXCLUDE
, "EXCLUDE");
450 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
451 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
453 PF (SEC_TIC54X_BLOCK
, "BLOCK");
454 PF (SEC_TIC54X_CLINK
, "CLINK");
456 PF (SEC_SMALL_DATA
, "SMALL_DATA");
457 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
458 PF (SEC_COFF_SHARED
, "SHARED");
459 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
460 PF (SEC_GROUP
, "GROUP");
462 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
465 struct coff_comdat_info
*comdat
;
467 switch (section
->flags
& SEC_LINK_DUPLICATES
)
471 case SEC_LINK_DUPLICATES_DISCARD
:
472 ls
= "LINK_ONCE_DISCARD";
474 case SEC_LINK_DUPLICATES_ONE_ONLY
:
475 ls
= "LINK_ONCE_ONE_ONLY";
477 case SEC_LINK_DUPLICATES_SAME_SIZE
:
478 ls
= "LINK_ONCE_SAME_SIZE";
480 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
481 ls
= "LINK_ONCE_SAME_CONTENTS";
484 printf ("%s%s", comma
, ls
);
486 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
488 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
498 dump_headers (bfd
*abfd
)
500 printf (_("Sections:\n"));
503 printf (_("Idx Name Size VMA LMA File off Algn"));
505 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
506 if (bfd_get_arch_size (abfd
) == 32)
507 printf (_("Idx Name Size VMA LMA File off Algn"));
509 printf (_("Idx Name Size VMA LMA File off Algn"));
513 printf (_(" Flags"));
514 if (abfd
->flags
& HAS_LOAD_PAGE
)
518 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
522 slurp_symtab (bfd
*abfd
)
527 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
533 storage
= bfd_get_symtab_upper_bound (abfd
);
535 bfd_fatal (bfd_get_filename (abfd
));
537 sy
= (asymbol
**) xmalloc (storage
);
539 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
541 bfd_fatal (bfd_get_filename (abfd
));
545 /* Read in the dynamic symbols. */
548 slurp_dynamic_symtab (bfd
*abfd
)
553 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
556 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
558 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
564 bfd_fatal (bfd_get_filename (abfd
));
567 sy
= (asymbol
**) xmalloc (storage
);
569 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
571 bfd_fatal (bfd_get_filename (abfd
));
575 /* Filter out (in place) symbols that are useless for disassembly.
576 COUNT is the number of elements in SYMBOLS.
577 Return the number of useful symbols. */
580 remove_useless_symbols (asymbol
**symbols
, long count
)
582 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
586 asymbol
*sym
= *in_ptr
++;
588 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
590 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
592 if (bfd_is_und_section (sym
->section
)
593 || bfd_is_com_section (sym
->section
))
598 return out_ptr
- symbols
;
601 /* Sort symbols into value order. */
604 compare_symbols (const void *ap
, const void *bp
)
606 const asymbol
*a
= * (const asymbol
**) ap
;
607 const asymbol
*b
= * (const asymbol
**) bp
;
617 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
619 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
622 if (a
->section
> b
->section
)
624 else if (a
->section
< b
->section
)
627 an
= bfd_asymbol_name (a
);
628 bn
= bfd_asymbol_name (b
);
632 /* The symbols gnu_compiled and gcc2_compiled convey no real
633 information, so put them after other symbols with the same value. */
634 af
= (strstr (an
, "gnu_compiled") != NULL
635 || strstr (an
, "gcc2_compiled") != NULL
);
636 bf
= (strstr (bn
, "gnu_compiled") != NULL
637 || strstr (bn
, "gcc2_compiled") != NULL
);
644 /* We use a heuristic for the file name, to try to sort it after
645 more useful symbols. It may not work on non Unix systems, but it
646 doesn't really matter; the only difference is precisely which
647 symbol names get printed. */
649 #define file_symbol(s, sn, snl) \
650 (((s)->flags & BSF_FILE) != 0 \
651 || ((sn)[(snl) - 2] == '.' \
652 && ((sn)[(snl) - 1] == 'o' \
653 || (sn)[(snl) - 1] == 'a')))
655 af
= file_symbol (a
, an
, anl
);
656 bf
= file_symbol (b
, bn
, bnl
);
663 /* Try to sort global symbols before local symbols before function
664 symbols before debugging symbols. */
669 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
671 if ((aflags
& BSF_DEBUGGING
) != 0)
676 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
678 if ((aflags
& BSF_FUNCTION
) != 0)
683 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
685 if ((aflags
& BSF_LOCAL
) != 0)
690 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
692 if ((aflags
& BSF_GLOBAL
) != 0)
698 /* Symbols that start with '.' might be section names, so sort them
699 after symbols that don't start with '.'. */
700 if (an
[0] == '.' && bn
[0] != '.')
702 if (an
[0] != '.' && bn
[0] == '.')
705 /* Finally, if we can't distinguish them in any other way, try to
706 get consistent results by sorting the symbols by name. */
707 return strcmp (an
, bn
);
710 /* Sort relocs into address order. */
713 compare_relocs (const void *ap
, const void *bp
)
715 const arelent
*a
= * (const arelent
**) ap
;
716 const arelent
*b
= * (const arelent
**) bp
;
718 if (a
->address
> b
->address
)
720 else if (a
->address
< b
->address
)
723 /* So that associated relocations tied to the same address show up
724 in the correct order, we don't do any further sorting. */
733 /* Print an address (VMA) to the output stream in INFO.
734 If SKIP_ZEROES is TRUE, omit leading zeroes. */
737 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
738 bfd_boolean skip_zeroes
)
742 struct objdump_disasm_info
*aux
;
744 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
745 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
750 for (p
= buf
; *p
== '0'; ++p
)
755 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
758 /* Print the name of a symbol. */
761 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
768 name
= bfd_asymbol_name (sym
);
769 if (do_demangle
&& name
[0] != '\0')
771 /* Demangle the name. */
772 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
778 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
786 /* Locate a symbol given a bfd and a section (from INFO->application_data),
787 and a VMA. If INFO->application_data->require_sec is TRUE, then always
788 require the symbol to be in the section. Returns NULL if there is no
789 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
790 of the symbol in sorted_syms. */
793 find_symbol_for_address (bfd_vma vma
,
794 struct disassemble_info
*inf
,
797 /* @@ Would it speed things up to cache the last two symbols returned,
798 and maybe their address ranges? For many processors, only one memory
799 operand can be present at a time, so the 2-entry cache wouldn't be
800 constantly churned by code doing heavy memory accesses. */
802 /* Indices in `sorted_syms'. */
804 long max_count
= sorted_symcount
;
806 struct objdump_disasm_info
*aux
;
810 bfd_boolean want_section
;
812 if (sorted_symcount
< 1)
815 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
818 opb
= inf
->octets_per_byte
;
820 /* Perform a binary search looking for the closest symbol to the
821 required value. We are searching the range (min, max_count]. */
822 while (min
+ 1 < max_count
)
826 thisplace
= (max_count
+ min
) / 2;
827 sym
= sorted_syms
[thisplace
];
829 if (bfd_asymbol_value (sym
) > vma
)
830 max_count
= thisplace
;
831 else if (bfd_asymbol_value (sym
) < vma
)
840 /* The symbol we want is now in min, the low end of the range we
841 were searching. If there are several symbols with the same
842 value, we want the first one. */
845 && (bfd_asymbol_value (sorted_syms
[thisplace
])
846 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
849 /* Prefer a symbol in the current section if we have multple symbols
850 with the same value, as can occur with overlays or zero size
853 while (min
< max_count
854 && (bfd_asymbol_value (sorted_syms
[min
])
855 == bfd_asymbol_value (sorted_syms
[thisplace
])))
857 if (sorted_syms
[min
]->section
== sec
858 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
865 return sorted_syms
[thisplace
];
870 /* If the file is relocatable, and the symbol could be from this
871 section, prefer a symbol from this section over symbols from
872 others, even if the other symbol's value might be closer.
874 Note that this may be wrong for some symbol references if the
875 sections have overlapping memory ranges, but in that case there's
876 no way to tell what's desired without looking at the relocation
879 Also give the target a chance to reject symbols. */
880 want_section
= (aux
->require_sec
881 || ((abfd
->flags
& HAS_RELOC
) != 0
882 && vma
>= bfd_get_section_vma (abfd
, sec
)
883 && vma
< (bfd_get_section_vma (abfd
, sec
)
884 + bfd_section_size (abfd
, sec
) / opb
)));
885 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
886 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
889 long newplace
= sorted_symcount
;
891 for (i
= min
- 1; i
>= 0; i
--)
893 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
894 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
896 if (newplace
== sorted_symcount
)
899 if (bfd_asymbol_value (sorted_syms
[i
])
900 != bfd_asymbol_value (sorted_syms
[newplace
]))
903 /* Remember this symbol and keep searching until we reach
904 an earlier address. */
909 if (newplace
!= sorted_symcount
)
910 thisplace
= newplace
;
913 /* We didn't find a good symbol with a smaller value.
914 Look for one with a larger value. */
915 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
917 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
918 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
926 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
927 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
928 /* There is no suitable symbol. */
935 return sorted_syms
[thisplace
];
938 /* Print an address and the offset to the nearest symbol. */
941 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
942 bfd_vma vma
, struct disassemble_info
*inf
,
943 bfd_boolean skip_zeroes
)
945 objdump_print_value (vma
, inf
, skip_zeroes
);
951 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
952 bfd_get_section_name (abfd
, sec
));
953 secaddr
= bfd_get_section_vma (abfd
, sec
);
956 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
957 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
959 else if (vma
> secaddr
)
961 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
962 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
964 (*inf
->fprintf_func
) (inf
->stream
, ">");
968 (*inf
->fprintf_func
) (inf
->stream
, " <");
969 objdump_print_symname (abfd
, inf
, sym
);
970 if (bfd_asymbol_value (sym
) > vma
)
972 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
973 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
975 else if (vma
> bfd_asymbol_value (sym
))
977 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
978 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
980 (*inf
->fprintf_func
) (inf
->stream
, ">");
983 if (display_file_offsets
)
984 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
985 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
988 /* Print an address (VMA), symbolically if possible.
989 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
992 objdump_print_addr (bfd_vma vma
,
993 struct disassemble_info
*inf
,
994 bfd_boolean skip_zeroes
)
996 struct objdump_disasm_info
*aux
;
998 bfd_boolean skip_find
= FALSE
;
1000 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1002 if (sorted_symcount
< 1)
1004 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1005 objdump_print_value (vma
, inf
, skip_zeroes
);
1007 if (display_file_offsets
)
1008 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1009 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1013 if (aux
->reloc
!= NULL
1014 && aux
->reloc
->sym_ptr_ptr
!= NULL
1015 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1017 sym
= * aux
->reloc
->sym_ptr_ptr
;
1019 /* Adjust the vma to the reloc. */
1020 vma
+= bfd_asymbol_value (sym
);
1022 if (bfd_is_und_section (bfd_get_section (sym
)))
1027 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1029 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1033 /* Print VMA to INFO. This function is passed to the disassembler
1037 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1039 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1042 /* Determine if the given address has a symbol associated with it. */
1045 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1049 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1051 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1054 /* Hold the last function name and the last line number we displayed
1055 in a disassembly. */
1057 static char *prev_functionname
;
1058 static unsigned int prev_line
;
1060 /* We keep a list of all files that we have seen when doing a
1061 disassembly with source, so that we know how much of the file to
1062 display. This can be important for inlined functions. */
1064 struct print_file_list
1066 struct print_file_list
*next
;
1067 const char *filename
;
1068 const char *modname
;
1071 const char **linemap
;
1077 static struct print_file_list
*print_files
;
1079 /* The number of preceding context lines to show when we start
1080 displaying a file for the first time. */
1082 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1084 /* Read a complete file into memory. */
1087 slurp_file (const char *fn
, size_t *size
)
1090 int ps
= getpagesize ();
1095 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1099 if (fstat (fd
, &st
) < 0)
1103 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1104 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1105 if (map
!= (char *)-1L)
1111 map
= (const char *) malloc (*size
);
1112 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1121 #define line_map_decrease 5
1123 /* Precompute array of lines for a mapped file. */
1125 static const char **
1126 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1128 const char *p
, *lstart
, *end
;
1129 int chars_per_line
= 45; /* First iteration will use 40. */
1130 unsigned int lineno
;
1131 const char **linemap
= NULL
;
1132 unsigned long line_map_size
= 0;
1138 for (p
= map
; p
< end
; p
++)
1142 if (p
+ 1 < end
&& p
[1] == '\r')
1145 else if (*p
== '\r')
1147 if (p
+ 1 < end
&& p
[1] == '\n')
1153 /* End of line found. */
1155 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1157 unsigned long newsize
;
1159 chars_per_line
-= line_map_decrease
;
1160 if (chars_per_line
<= 1)
1162 line_map_size
= size
/ chars_per_line
+ 1;
1163 if (line_map_size
< lineno
+ 1)
1164 line_map_size
= lineno
+ 1;
1165 newsize
= line_map_size
* sizeof (char *);
1166 linemap
= (const char **) xrealloc (linemap
, newsize
);
1169 linemap
[lineno
++] = lstart
;
1177 /* Tries to open MODNAME, and if successful adds a node to print_files
1178 linked list and returns that node. Returns NULL on failure. */
1180 static struct print_file_list
*
1181 try_print_file_open (const char *origname
, const char *modname
)
1183 struct print_file_list
*p
;
1185 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1187 p
->map
= slurp_file (modname
, &p
->mapsize
);
1194 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1196 p
->filename
= origname
;
1197 p
->modname
= modname
;
1198 p
->next
= print_files
;
1204 /* If the the source file, as described in the symtab, is not found
1205 try to locate it in one of the paths specified with -I
1206 If found, add location to print_files linked list. */
1208 static struct print_file_list
*
1209 update_source_path (const char *filename
)
1211 struct print_file_list
*p
;
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 int skip_addr_chars
;
1461 bfd_vma addr_offset
;
1462 unsigned int opb
= inf
->octets_per_byte
;
1463 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1464 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1468 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1472 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1476 octets_per_line
= insn_width
;
1478 octets_per_line
= 4;
1480 octets_per_line
= 16;
1482 /* Figure out how many characters to skip at the start of an
1483 address, to make the disassembly look nicer. We discard leading
1484 zeroes in chunks of 4, ensuring that there is always a leading
1486 skip_addr_chars
= 0;
1487 if (! prefix_addresses
)
1491 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1493 while (buf
[skip_addr_chars
] == '0')
1496 /* Don't discard zeros on overflow. */
1497 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1498 skip_addr_chars
= 0;
1500 if (skip_addr_chars
!= 0)
1501 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1504 inf
->insn_info_valid
= 0;
1506 addr_offset
= start_offset
;
1507 while (addr_offset
< stop_offset
)
1510 bfd_boolean need_nl
= FALSE
;
1511 int previous_octets
;
1513 /* Remember the length of the previous instruction. */
1514 previous_octets
= octets
;
1517 /* Make sure we don't use relocs from previous instructions. */
1520 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1522 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1525 if (! disassemble_zeroes
1526 && (inf
->insn_info_valid
== 0
1527 || inf
->branch_delay_insns
== 0)
1528 && (z
- addr_offset
* opb
>= skip_zeroes
1529 || (z
== stop_offset
* opb
&&
1530 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1532 /* If there are more nonzero octets to follow, we only skip
1533 zeroes in multiples of 4, to try to avoid running over
1534 the start of an instruction which happens to start with
1536 if (z
!= stop_offset
* opb
)
1537 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1539 octets
= z
- addr_offset
* opb
;
1541 /* If we are going to display more data, and we are displaying
1542 file offsets, then tell the user how many zeroes we skip
1543 and the file offset from where we resume dumping. */
1544 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1545 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1547 (unsigned long) (section
->filepos
1548 + (addr_offset
+ (octets
/ opb
))));
1558 if (with_line_numbers
|| with_source_code
)
1559 show_line (aux
->abfd
, section
, addr_offset
);
1561 if (! prefix_addresses
)
1565 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1566 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1570 printf ("%s:\t", buf
+ skip_addr_chars
);
1574 aux
->require_sec
= TRUE
;
1575 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1576 aux
->require_sec
= FALSE
;
1583 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1584 inf
->stream
= &sfile
;
1585 inf
->bytes_per_line
= 0;
1586 inf
->bytes_per_chunk
= 0;
1587 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1589 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1591 if (inf
->disassembler_needs_relocs
1592 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1593 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1594 && *relppp
< relppend
)
1596 bfd_signed_vma distance_to_rel
;
1598 distance_to_rel
= (**relppp
)->address
1599 - (rel_offset
+ addr_offset
);
1601 /* Check to see if the current reloc is associated with
1602 the instruction that we are about to disassemble. */
1603 if (distance_to_rel
== 0
1604 /* FIXME: This is wrong. We are trying to catch
1605 relocs that are addressed part way through the
1606 current instruction, as might happen with a packed
1607 VLIW instruction. Unfortunately we do not know the
1608 length of the current instruction since we have not
1609 disassembled it yet. Instead we take a guess based
1610 upon the length of the previous instruction. The
1611 proper solution is to have a new target-specific
1612 disassembler function which just returns the length
1613 of an instruction at a given address without trying
1614 to display its disassembly. */
1615 || (distance_to_rel
> 0
1616 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1618 inf
->flags
|= INSN_HAS_RELOC
;
1619 aux
->reloc
= **relppp
;
1623 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1624 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1625 inf
->stream
= stdout
;
1626 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1627 octets_per_line
= inf
->bytes_per_line
;
1628 if (octets
< (int) opb
)
1631 printf ("%s\n", sfile
.buffer
);
1634 non_fatal (_("disassemble_fn returned length %d"),
1645 octets
= octets_per_line
;
1646 if (addr_offset
+ octets
/ opb
> stop_offset
)
1647 octets
= (stop_offset
- addr_offset
) * opb
;
1649 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1651 if (ISPRINT (data
[j
]))
1652 buf
[j
- addr_offset
* opb
] = data
[j
];
1654 buf
[j
- addr_offset
* opb
] = '.';
1656 buf
[j
- addr_offset
* opb
] = '\0';
1659 if (prefix_addresses
1661 : show_raw_insn
>= 0)
1665 /* If ! prefix_addresses and ! wide_output, we print
1666 octets_per_line octets per line. */
1668 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1669 pb
= octets_per_line
;
1671 if (inf
->bytes_per_chunk
)
1672 bpc
= inf
->bytes_per_chunk
;
1676 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1680 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1682 for (k
= bpc
- 1; k
>= 0; k
--)
1683 printf ("%02x", (unsigned) data
[j
+ k
]);
1688 for (k
= 0; k
< bpc
; k
++)
1689 printf ("%02x", (unsigned) data
[j
+ k
]);
1694 for (; pb
< octets_per_line
; pb
+= bpc
)
1698 for (k
= 0; k
< bpc
; k
++)
1703 /* Separate raw data from instruction by extra space. */
1713 printf ("%s", sfile
.buffer
);
1715 if (prefix_addresses
1717 : show_raw_insn
>= 0)
1725 j
= addr_offset
* opb
+ pb
;
1727 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1728 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1732 printf ("%s:\t", buf
+ skip_addr_chars
);
1734 pb
+= octets_per_line
;
1737 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1741 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1743 for (k
= bpc
- 1; k
>= 0; k
--)
1744 printf ("%02x", (unsigned) data
[j
+ k
]);
1749 for (k
= 0; k
< bpc
; k
++)
1750 printf ("%02x", (unsigned) data
[j
+ k
]);
1763 while ((*relppp
) < relppend
1764 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1766 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1777 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1780 if (q
->howto
== NULL
)
1781 printf (": *unknown*\t");
1782 else if (q
->howto
->name
)
1783 printf (": %s\t", q
->howto
->name
);
1785 printf (": %d\t", q
->howto
->type
);
1787 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1788 printf ("*unknown*");
1791 const char *sym_name
;
1793 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1794 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1795 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1800 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1801 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1802 if (sym_name
== NULL
|| *sym_name
== '\0')
1803 sym_name
= "*unknown*";
1804 printf ("%s", sym_name
);
1811 objdump_print_value (q
->addend
, inf
, TRUE
);
1823 addr_offset
+= octets
/ opb
;
1826 free (sfile
.buffer
);
1830 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1832 const struct elf_backend_data
* bed
;
1833 bfd_vma sign_adjust
= 0;
1834 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1835 struct objdump_disasm_info
* paux
;
1836 unsigned int opb
= pinfo
->octets_per_byte
;
1837 bfd_byte
* data
= NULL
;
1838 bfd_size_type datasize
= 0;
1839 arelent
** rel_pp
= NULL
;
1840 arelent
** rel_ppstart
= NULL
;
1841 arelent
** rel_ppend
;
1842 unsigned long stop_offset
;
1843 asymbol
* sym
= NULL
;
1847 unsigned long addr_offset
;
1849 /* Sections that do not contain machine
1850 code are not normally disassembled. */
1851 if (! disassemble_all
1852 && only_list
== NULL
1853 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1854 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1857 if (! process_section_p (section
))
1860 datasize
= bfd_get_section_size (section
);
1864 /* Decide which set of relocs to use. Load them if necessary. */
1865 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1866 if (paux
->dynrelbuf
)
1868 rel_pp
= paux
->dynrelbuf
;
1869 rel_count
= paux
->dynrelcount
;
1870 /* Dynamic reloc addresses are absolute, non-dynamic are section
1871 relative. REL_OFFSET specifies the reloc address corresponding
1872 to the start of this section. */
1873 rel_offset
= section
->vma
;
1881 if ((section
->flags
& SEC_RELOC
) != 0
1882 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1886 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1888 bfd_fatal (bfd_get_filename (abfd
));
1892 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1893 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1895 bfd_fatal (bfd_get_filename (abfd
));
1897 /* Sort the relocs by address. */
1898 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1902 rel_ppend
= rel_pp
+ rel_count
;
1904 data
= (bfd_byte
*) xmalloc (datasize
);
1906 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1908 paux
->sec
= section
;
1909 pinfo
->buffer
= data
;
1910 pinfo
->buffer_vma
= section
->vma
;
1911 pinfo
->buffer_length
= datasize
;
1912 pinfo
->section
= section
;
1914 if (start_address
== (bfd_vma
) -1
1915 || start_address
< pinfo
->buffer_vma
)
1918 addr_offset
= start_address
- pinfo
->buffer_vma
;
1920 if (stop_address
== (bfd_vma
) -1)
1921 stop_offset
= datasize
/ opb
;
1924 if (stop_address
< pinfo
->buffer_vma
)
1927 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1928 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1929 stop_offset
= pinfo
->buffer_length
/ opb
;
1932 /* Skip over the relocs belonging to addresses below the
1934 while (rel_pp
< rel_ppend
1935 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1938 if (addr_offset
< stop_offset
)
1939 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1941 /* Find the nearest symbol forwards from our current position. */
1942 paux
->require_sec
= TRUE
;
1943 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1944 (struct disassemble_info
*) inf
,
1946 paux
->require_sec
= FALSE
;
1948 /* PR 9774: If the target used signed addresses then we must make
1949 sure that we sign extend the value that we calculate for 'addr'
1950 in the loop below. */
1951 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1952 && (bed
= get_elf_backend_data (abfd
)) != NULL
1953 && bed
->sign_extend_vma
)
1954 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
1956 /* Disassemble a block of instructions up to the address associated with
1957 the symbol we have just found. Then print the symbol and find the
1958 next symbol on. Repeat until we have disassembled the entire section
1959 or we have reached the end of the address range we are interested in. */
1960 while (addr_offset
< stop_offset
)
1964 unsigned long nextstop_offset
;
1967 addr
= section
->vma
+ addr_offset
;
1968 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
1970 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1975 (x
< sorted_symcount
1976 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1980 pinfo
->symbols
= sorted_syms
+ place
;
1981 pinfo
->num_symbols
= x
- place
;
1982 pinfo
->symtab_pos
= place
;
1986 pinfo
->symbols
= NULL
;
1987 pinfo
->num_symbols
= 0;
1988 pinfo
->symtab_pos
= -1;
1991 if (! prefix_addresses
)
1993 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1994 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1996 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1999 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2001 else if (sym
== NULL
)
2005 #define is_valid_next_sym(SYM) \
2006 ((SYM)->section == section \
2007 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2008 && pinfo->symbol_is_valid (SYM, pinfo))
2010 /* Search forward for the next appropriate symbol in
2011 SECTION. Note that all the symbols are sorted
2012 together into one big array, and that some sections
2013 may have overlapping addresses. */
2014 while (place
< sorted_symcount
2015 && ! is_valid_next_sym (sorted_syms
[place
]))
2018 if (place
>= sorted_symcount
)
2021 nextsym
= sorted_syms
[place
];
2024 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2025 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2026 else if (nextsym
== NULL
)
2027 nextstop_offset
= stop_offset
;
2029 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2031 if (nextstop_offset
> stop_offset
2032 || nextstop_offset
<= addr_offset
)
2033 nextstop_offset
= stop_offset
;
2035 /* If a symbol is explicitly marked as being an object
2036 rather than a function, just dump the bytes without
2037 disassembling them. */
2040 || sym
->section
!= section
2041 || bfd_asymbol_value (sym
) > addr
2042 || ((sym
->flags
& BSF_OBJECT
) == 0
2043 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2045 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2047 || (sym
->flags
& BSF_FUNCTION
) != 0)
2052 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2053 addr_offset
, nextstop_offset
,
2054 rel_offset
, &rel_pp
, rel_ppend
);
2056 addr_offset
= nextstop_offset
;
2062 if (rel_ppstart
!= NULL
)
2066 /* Disassemble the contents of an object file. */
2069 disassemble_data (bfd
*abfd
)
2071 struct disassemble_info disasm_info
;
2072 struct objdump_disasm_info aux
;
2076 prev_functionname
= NULL
;
2079 /* We make a copy of syms to sort. We don't want to sort syms
2080 because that will screw up the relocs. */
2081 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2082 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2083 * sizeof (asymbol
*));
2084 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2085 sorted_symcount
* sizeof (asymbol
*));
2087 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2089 for (i
= 0; i
< synthcount
; ++i
)
2091 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2095 /* Sort the symbols into section and symbol order. */
2096 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2098 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2100 disasm_info
.application_data
= (void *) &aux
;
2102 aux
.require_sec
= FALSE
;
2103 aux
.dynrelbuf
= NULL
;
2104 aux
.dynrelcount
= 0;
2107 disasm_info
.print_address_func
= objdump_print_address
;
2108 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2110 if (machine
!= NULL
)
2112 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2115 fatal (_("can't use supplied machine %s"), machine
);
2117 abfd
->arch_info
= inf
;
2120 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2122 struct bfd_target
*xvec
;
2124 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2125 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2126 xvec
->byteorder
= endian
;
2130 /* Use libopcodes to locate a suitable disassembler. */
2131 aux
.disassemble_fn
= disassembler (abfd
);
2132 if (!aux
.disassemble_fn
)
2134 non_fatal (_("can't disassemble for architecture %s\n"),
2135 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2140 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2141 disasm_info
.arch
= bfd_get_arch (abfd
);
2142 disasm_info
.mach
= bfd_get_mach (abfd
);
2143 disasm_info
.disassembler_options
= disassembler_options
;
2144 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2145 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2146 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2147 disasm_info
.disassembler_needs_relocs
= FALSE
;
2149 if (bfd_big_endian (abfd
))
2150 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2151 else if (bfd_little_endian (abfd
))
2152 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2154 /* ??? Aborting here seems too drastic. We could default to big or little
2156 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2158 /* Allow the target to customize the info structure. */
2159 disassemble_init_for_target (& disasm_info
);
2161 /* Pre-load the dynamic relocs if we are going
2162 to be dumping them along with the disassembly. */
2163 if (dump_dynamic_reloc_info
)
2165 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2168 bfd_fatal (bfd_get_filename (abfd
));
2172 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2173 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2176 if (aux
.dynrelcount
< 0)
2177 bfd_fatal (bfd_get_filename (abfd
));
2179 /* Sort the relocs by address. */
2180 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2184 disasm_info
.symtab
= sorted_syms
;
2185 disasm_info
.symtab_size
= sorted_symcount
;
2187 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2189 if (aux
.dynrelbuf
!= NULL
)
2190 free (aux
.dynrelbuf
);
2195 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2196 asection
*sec
, void *file
)
2198 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2199 bfd
*abfd
= (bfd
*) file
;
2202 /* If it is already loaded, do nothing. */
2203 if (section
->start
!= NULL
)
2206 section
->address
= 0;
2207 section
->size
= bfd_get_section_size (sec
);
2208 section
->start
= NULL
;
2209 ret
= bfd_get_full_section_contents (abfd
, sec
, §ion
->start
);
2213 free_debug_section (debug
);
2214 printf (_("\nCan't get contents for section '%s'.\n"),
2219 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2221 /* We want to relocate the data we've already read (and
2222 decompressed), so we store a pointer to the data in
2223 the bfd_section, and tell it that the contents are
2224 already in memory. */
2225 sec
->contents
= section
->start
;
2226 sec
->flags
|= SEC_IN_MEMORY
;
2227 sec
->size
= section
->size
;
2229 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2236 free_debug_section (debug
);
2237 printf (_("\nCan't get contents for section '%s'.\n"),
2247 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2249 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2250 bfd
*abfd
= (bfd
*) file
;
2253 /* If it is already loaded, do nothing. */
2254 if (section
->start
!= NULL
)
2257 /* Locate the debug section. */
2258 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2260 section
->name
= section
->uncompressed_name
;
2263 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2265 section
->name
= section
->compressed_name
;
2270 return load_specific_debug_section (debug
, sec
, file
);
2274 free_debug_section (enum dwarf_section_display_enum debug
)
2276 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2278 if (section
->start
== NULL
)
2281 free ((char *) section
->start
);
2282 section
->start
= NULL
;
2283 section
->address
= 0;
2288 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2289 void *arg ATTRIBUTE_UNUSED
)
2291 const char *name
= bfd_get_section_name (abfd
, section
);
2295 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2296 match
= ".debug_info";
2300 for (i
= 0; i
< max
; i
++)
2301 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2302 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2303 && debug_displays
[i
].enabled
!= NULL
2304 && *debug_displays
[i
].enabled
)
2306 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2308 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2309 sec
->name
= sec
->uncompressed_name
;
2311 sec
->name
= sec
->compressed_name
;
2312 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2315 debug_displays
[i
].display (sec
, abfd
);
2317 if (i
!= info
&& i
!= abbrev
)
2318 free_debug_section ((enum dwarf_section_display_enum
) i
);
2324 /* Dump the dwarf debugging information. */
2327 dump_dwarf (bfd
*abfd
)
2329 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2331 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2333 if (bfd_big_endian (abfd
))
2334 byte_get
= byte_get_big_endian
;
2335 else if (bfd_little_endian (abfd
))
2336 byte_get
= byte_get_little_endian
;
2340 switch (bfd_get_arch (abfd
))
2343 switch (bfd_get_mach (abfd
))
2345 case bfd_mach_x86_64
:
2346 case bfd_mach_x86_64_intel_syntax
:
2347 init_dwarf_regnames_x86_64 ();
2351 init_dwarf_regnames_i386 ();
2360 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2362 free_debug_memory ();
2365 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2366 it. Return NULL on failure. */
2369 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2375 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2376 if (stabsect
== NULL
)
2378 printf (_("No %s section present\n\n"), sect_name
);
2382 size
= bfd_section_size (abfd
, stabsect
);
2383 contents
= (char *) xmalloc (size
);
2385 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2387 non_fatal (_("reading %s section of %s failed: %s"),
2388 sect_name
, bfd_get_filename (abfd
),
2389 bfd_errmsg (bfd_get_error ()));
2400 /* Stabs entries use a 12 byte format:
2401 4 byte string table index
2403 1 byte stab other field
2404 2 byte stab desc field
2406 FIXME: This will have to change for a 64 bit object format. */
2408 #define STRDXOFF (0)
2410 #define OTHEROFF (5)
2413 #define STABSIZE (12)
2415 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2416 using string table section STRSECT_NAME (in `strtab'). */
2419 print_section_stabs (bfd
*abfd
,
2420 const char *stabsect_name
,
2421 unsigned *string_offset_ptr
)
2424 unsigned file_string_table_offset
= 0;
2425 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2426 bfd_byte
*stabp
, *stabs_end
;
2429 stabs_end
= stabp
+ stab_size
;
2431 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2432 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2434 /* Loop through all symbols and print them.
2436 We start the index at -1 because there is a dummy symbol on
2437 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2438 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2442 unsigned char type
, other
;
2443 unsigned short desc
;
2446 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2447 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2448 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2449 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2450 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2452 printf ("\n%-6d ", i
);
2453 /* Either print the stab name, or, if unnamed, print its number
2454 again (makes consistent formatting for tools like awk). */
2455 name
= bfd_get_stab_name (type
);
2457 printf ("%-6s", name
);
2458 else if (type
== N_UNDF
)
2461 printf ("%-6d", type
);
2462 printf (" %-6d %-6d ", other
, desc
);
2463 bfd_printf_vma (abfd
, value
);
2464 printf (" %-6lu", strx
);
2466 /* Symbols with type == 0 (N_UNDF) specify the length of the
2467 string table associated with this file. We use that info
2468 to know how to relocate the *next* file's string table indices. */
2471 file_string_table_offset
= next_file_string_table_offset
;
2472 next_file_string_table_offset
+= value
;
2476 /* Using the (possibly updated) string table offset, print the
2477 string (if any) associated with this symbol. */
2478 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2479 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2485 *string_offset_ptr
= next_file_string_table_offset
;
2490 const char * section_name
;
2491 const char * string_section_name
;
2492 unsigned string_offset
;
2497 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2500 stab_section_names
* sought
= (stab_section_names
*) names
;
2502 /* Check for section names for which stabsect_name is a prefix, to
2503 handle .stab.N, etc. */
2504 len
= strlen (sought
->section_name
);
2506 /* If the prefix matches, and the files section name ends with a
2507 nul or a digit, then we match. I.e., we want either an exact
2508 match or a section followed by a number. */
2509 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2510 && (section
->name
[len
] == 0
2511 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2514 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2519 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2522 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2528 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2530 stab_section_names s
;
2532 s
.section_name
= stabsect_name
;
2533 s
.string_section_name
= strsect_name
;
2534 s
.string_offset
= 0;
2536 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2542 /* Dump the any sections containing stabs debugging information. */
2545 dump_stabs (bfd
*abfd
)
2547 dump_stabs_section (abfd
, ".stab", ".stabstr");
2548 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2549 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2552 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2554 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2558 dump_bfd_header (bfd
*abfd
)
2562 printf (_("architecture: %s, "),
2563 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2564 bfd_get_mach (abfd
)));
2565 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2567 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2568 PF (HAS_RELOC
, "HAS_RELOC");
2569 PF (EXEC_P
, "EXEC_P");
2570 PF (HAS_LINENO
, "HAS_LINENO");
2571 PF (HAS_DEBUG
, "HAS_DEBUG");
2572 PF (HAS_SYMS
, "HAS_SYMS");
2573 PF (HAS_LOCALS
, "HAS_LOCALS");
2574 PF (DYNAMIC
, "DYNAMIC");
2575 PF (WP_TEXT
, "WP_TEXT");
2576 PF (D_PAGED
, "D_PAGED");
2577 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2578 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2579 printf (_("\nstart address 0x"));
2580 bfd_printf_vma (abfd
, abfd
->start_address
);
2586 dump_bfd_private_header (bfd
*abfd
)
2588 bfd_print_private_bfd_data (abfd
, stdout
);
2592 /* Display a section in hexadecimal format with associated characters.
2593 Each line prefixed by the zero padded address. */
2596 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2599 bfd_size_type datasize
;
2600 bfd_size_type addr_offset
;
2601 bfd_size_type start_offset
;
2602 bfd_size_type stop_offset
;
2603 unsigned int opb
= bfd_octets_per_byte (abfd
);
2604 /* Bytes per line. */
2605 const int onaline
= 16;
2610 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2613 if (! process_section_p (section
))
2616 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2619 /* Compute the address range to display. */
2620 if (start_address
== (bfd_vma
) -1
2621 || start_address
< section
->vma
)
2624 start_offset
= start_address
- section
->vma
;
2626 if (stop_address
== (bfd_vma
) -1)
2627 stop_offset
= datasize
/ opb
;
2630 if (stop_address
< section
->vma
)
2633 stop_offset
= stop_address
- section
->vma
;
2635 if (stop_offset
> datasize
/ opb
)
2636 stop_offset
= datasize
/ opb
;
2639 if (start_offset
>= stop_offset
)
2642 printf (_("Contents of section %s:"), section
->name
);
2643 if (display_file_offsets
)
2644 printf (_(" (Starting at file offset: 0x%lx)"),
2645 (unsigned long) (section
->filepos
+ start_offset
));
2648 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
2650 non_fatal (_("Reading section failed"));
2656 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2657 if (strlen (buf
) >= sizeof (buf
))
2661 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2663 count
= strlen (buf
) - count
;
2667 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2668 if (strlen (buf
) >= sizeof (buf
))
2672 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2674 count
= strlen (buf
) - count
;
2678 for (addr_offset
= start_offset
;
2679 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2683 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2684 count
= strlen (buf
);
2685 if ((size_t) count
>= sizeof (buf
))
2689 while (count
< width
)
2694 fputs (buf
+ count
- width
, stdout
);
2697 for (j
= addr_offset
* opb
;
2698 j
< addr_offset
* opb
+ onaline
; j
++)
2700 if (j
< stop_offset
* opb
)
2701 printf ("%02x", (unsigned) (data
[j
]));
2709 for (j
= addr_offset
* opb
;
2710 j
< addr_offset
* opb
+ onaline
; j
++)
2712 if (j
>= stop_offset
* opb
)
2715 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2722 /* Actually display the various requested regions. */
2725 dump_data (bfd
*abfd
)
2727 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2730 /* Should perhaps share code and display with nm? */
2733 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2742 max_count
= dynsymcount
;
2743 printf ("DYNAMIC SYMBOL TABLE:\n");
2748 max_count
= symcount
;
2749 printf ("SYMBOL TABLE:\n");
2753 printf (_("no symbols\n"));
2755 for (count
= 0; count
< max_count
; count
++)
2759 if (*current
== NULL
)
2760 printf (_("no information for symbol number %ld\n"), count
);
2762 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2763 printf (_("could not determine the type of symbol number %ld\n"),
2766 else if (process_section_p ((* current
)->section
)
2767 && (dump_special_syms
2768 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2770 const char *name
= (*current
)->name
;
2772 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2776 /* If we want to demangle the name, we demangle it
2777 here, and temporarily clobber it while calling
2778 bfd_print_symbol. FIXME: This is a gross hack. */
2779 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2781 (*current
)->name
= alloc
;
2782 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2783 bfd_print_symbol_all
);
2786 (*current
)->name
= name
;
2791 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2792 bfd_print_symbol_all
);
2802 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2805 char *last_filename
, *last_functionname
;
2806 unsigned int last_line
;
2808 /* Get column headers lined up reasonably. */
2816 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2817 width
= strlen (buf
) - 7;
2819 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2822 last_filename
= NULL
;
2823 last_functionname
= NULL
;
2826 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2829 const char *filename
, *functionname
;
2830 unsigned int linenumber
;
2831 const char *sym_name
;
2832 const char *section_name
;
2834 if (start_address
!= (bfd_vma
) -1
2835 && q
->address
< start_address
)
2837 if (stop_address
!= (bfd_vma
) -1
2838 && q
->address
> stop_address
)
2841 if (with_line_numbers
2843 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2844 &filename
, &functionname
, &linenumber
))
2846 if (functionname
!= NULL
2847 && (last_functionname
== NULL
2848 || strcmp (functionname
, last_functionname
) != 0))
2850 printf ("%s():\n", functionname
);
2851 if (last_functionname
!= NULL
)
2852 free (last_functionname
);
2853 last_functionname
= xstrdup (functionname
);
2857 && (linenumber
!= last_line
2858 || (filename
!= NULL
2859 && last_filename
!= NULL
2860 && strcmp (filename
, last_filename
) != 0)))
2862 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2863 last_line
= linenumber
;
2864 if (last_filename
!= NULL
)
2865 free (last_filename
);
2866 if (filename
== NULL
)
2867 last_filename
= NULL
;
2869 last_filename
= xstrdup (filename
);
2873 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2875 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2876 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2881 section_name
= NULL
;
2884 bfd_printf_vma (abfd
, q
->address
);
2885 if (q
->howto
== NULL
)
2886 printf (" *unknown* ");
2887 else if (q
->howto
->name
)
2888 printf (" %-16s ", q
->howto
->name
);
2890 printf (" %-16d ", q
->howto
->type
);
2894 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2898 if (section_name
== NULL
)
2899 section_name
= "*unknown*";
2900 printf ("[%s]", section_name
);
2906 bfd_printf_vma (abfd
, q
->addend
);
2914 dump_relocs_in_section (bfd
*abfd
,
2916 void *dummy ATTRIBUTE_UNUSED
)
2922 if ( bfd_is_abs_section (section
)
2923 || bfd_is_und_section (section
)
2924 || bfd_is_com_section (section
)
2925 || (! process_section_p (section
))
2926 || ((section
->flags
& SEC_RELOC
) == 0))
2929 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2931 bfd_fatal (bfd_get_filename (abfd
));
2933 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2937 printf (" (none)\n\n");
2941 relpp
= (arelent
**) xmalloc (relsize
);
2942 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2945 bfd_fatal (bfd_get_filename (abfd
));
2946 else if (relcount
== 0)
2947 printf (" (none)\n\n");
2951 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2958 dump_relocs (bfd
*abfd
)
2960 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2964 dump_dynamic_relocs (bfd
*abfd
)
2970 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2972 bfd_fatal (bfd_get_filename (abfd
));
2974 printf ("DYNAMIC RELOCATION RECORDS");
2977 printf (" (none)\n\n");
2980 relpp
= (arelent
**) xmalloc (relsize
);
2981 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2984 bfd_fatal (bfd_get_filename (abfd
));
2985 else if (relcount
== 0)
2986 printf (" (none)\n\n");
2990 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2997 /* Creates a table of paths, to search for source files. */
3000 add_include_path (const char *path
)
3004 include_path_count
++;
3005 include_paths
= (const char **)
3006 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3007 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3008 if (path
[1] == ':' && path
[2] == 0)
3009 path
= concat (path
, ".", (const char *) 0);
3011 include_paths
[include_path_count
- 1] = path
;
3015 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3019 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3021 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3022 section
->vma
+= adjust_section_vma
;
3024 section
->lma
+= adjust_section_vma
;
3028 /* Dump selected contents of ABFD. */
3031 dump_bfd (bfd
*abfd
)
3033 /* If we are adjusting section VMA's, change them all now. Changing
3034 the BFD information is a hack. However, we must do it, or
3035 bfd_find_nearest_line will not do the right thing. */
3036 if (adjust_section_vma
!= 0)
3038 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3039 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3042 if (! dump_debugging_tags
)
3043 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3046 print_arelt_descr (stdout
, abfd
, TRUE
);
3047 if (dump_file_header
)
3048 dump_bfd_header (abfd
);
3049 if (dump_private_headers
)
3050 dump_bfd_private_header (abfd
);
3051 if (! dump_debugging_tags
)
3053 if (dump_section_headers
)
3054 dump_headers (abfd
);
3060 || dump_dwarf_section_info
)
3061 syms
= slurp_symtab (abfd
);
3062 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3063 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3064 dynsyms
= slurp_dynamic_symtab (abfd
);
3067 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3068 dynsymcount
, dynsyms
, &synthsyms
);
3074 dump_symbols (abfd
, FALSE
);
3075 if (dump_dynamic_symtab
)
3076 dump_symbols (abfd
, TRUE
);
3077 if (dump_dwarf_section_info
)
3079 if (dump_stab_section_info
)
3081 if (dump_reloc_info
&& ! disassemble
)
3083 if (dump_dynamic_reloc_info
&& ! disassemble
)
3084 dump_dynamic_relocs (abfd
);
3085 if (dump_section_contents
)
3088 disassemble_data (abfd
);
3094 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3095 if (dhandle
!= NULL
)
3097 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3099 dump_debugging_tags
? TRUE
: FALSE
))
3101 non_fatal (_("%s: printing debugging information failed"),
3102 bfd_get_filename (abfd
));
3106 /* PR 6483: If there was no STABS or IEEE debug
3107 info in the file, try DWARF instead. */
3108 else if (! dump_dwarf_section_info
)
3138 display_bfd (bfd
*abfd
)
3142 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3148 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3150 nonfatal (bfd_get_filename (abfd
));
3151 list_matching_formats (matching
);
3156 if (bfd_get_error () != bfd_error_file_not_recognized
)
3158 nonfatal (bfd_get_filename (abfd
));
3162 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3168 nonfatal (bfd_get_filename (abfd
));
3170 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3172 list_matching_formats (matching
);
3178 display_file (char *filename
, char *target
)
3183 if (get_file_size (filename
) < 1)
3189 file
= bfd_openr (filename
, target
);
3192 nonfatal (filename
);
3196 /* Decompress sections unless dumping the section contents. */
3197 if (!dump_section_contents
)
3198 file
->flags
|= BFD_DECOMPRESS
;
3200 /* If the file is an archive, process all of its elements. */
3201 if (bfd_check_format (file
, bfd_archive
))
3203 bfd
*last_arfile
= NULL
;
3205 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3208 bfd_set_error (bfd_error_no_error
);
3210 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3213 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3214 nonfatal (bfd_get_filename (file
));
3218 display_bfd (arfile
);
3220 if (last_arfile
!= NULL
)
3221 bfd_close (last_arfile
);
3222 last_arfile
= arfile
;
3225 if (last_arfile
!= NULL
)
3226 bfd_close (last_arfile
);
3235 main (int argc
, char **argv
)
3238 char *target
= default_target
;
3239 bfd_boolean seenflag
= FALSE
;
3241 #if defined (HAVE_SETLOCALE)
3242 #if defined (HAVE_LC_MESSAGES)
3243 setlocale (LC_MESSAGES
, "");
3245 setlocale (LC_CTYPE
, "");
3248 bindtextdomain (PACKAGE
, LOCALEDIR
);
3249 textdomain (PACKAGE
);
3251 program_name
= *argv
;
3252 xmalloc_set_program_name (program_name
);
3254 START_PROGRESS (program_name
, 0);
3256 expandargv (&argc
, &argv
);
3259 set_default_bfd_target ();
3261 while ((c
= getopt_long (argc
, argv
,
3262 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3263 long_options
, (int *) 0))
3269 break; /* We've been given a long option. */
3274 if (disassembler_options
)
3275 /* Ignore potential memory leak for now. */
3276 disassembler_options
= concat (disassembler_options
, ",",
3277 optarg
, (const char *) NULL
);
3279 disassembler_options
= optarg
;
3285 display_file_offsets
= TRUE
;
3288 with_line_numbers
= TRUE
;
3297 enum demangling_styles style
;
3299 style
= cplus_demangle_name_to_style (optarg
);
3300 if (style
== unknown_demangling
)
3301 fatal (_("unknown demangling style `%s'"),
3304 cplus_demangle_set_style (style
);
3310 case OPTION_ADJUST_VMA
:
3311 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3313 case OPTION_START_ADDRESS
:
3314 start_address
= parse_vma (optarg
, "--start-address");
3315 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3316 fatal (_("error: the start address should be before the end address"));
3318 case OPTION_STOP_ADDRESS
:
3319 stop_address
= parse_vma (optarg
, "--stop-address");
3320 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3321 fatal (_("error: the stop address should be after the start address"));
3325 prefix_length
= strlen (prefix
);
3326 /* Remove an unnecessary trailing '/' */
3327 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3330 case OPTION_PREFIX_STRIP
:
3331 prefix_strip
= atoi (optarg
);
3332 if (prefix_strip
< 0)
3333 fatal (_("error: prefix strip must be non-negative"));
3335 case OPTION_INSN_WIDTH
:
3336 insn_width
= strtoul (optarg
, NULL
, 0);
3337 if (insn_width
<= 0)
3338 fatal (_("error: instruction width must be positive"));
3341 if (strcmp (optarg
, "B") == 0)
3342 endian
= BFD_ENDIAN_BIG
;
3343 else if (strcmp (optarg
, "L") == 0)
3344 endian
= BFD_ENDIAN_LITTLE
;
3347 nonfatal (_("unrecognized -E option"));
3352 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3353 endian
= BFD_ENDIAN_BIG
;
3354 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3355 endian
= BFD_ENDIAN_LITTLE
;
3358 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3365 dump_file_header
= TRUE
;
3369 formats_info
= TRUE
;
3373 add_include_path (optarg
);
3376 dump_private_headers
= TRUE
;
3380 dump_private_headers
= TRUE
;
3382 dump_reloc_info
= TRUE
;
3383 dump_file_header
= TRUE
;
3384 dump_ar_hdrs
= TRUE
;
3385 dump_section_headers
= TRUE
;
3393 dump_dynamic_symtab
= TRUE
;
3401 disassemble_zeroes
= TRUE
;
3405 disassemble_all
= TRUE
;
3410 with_source_code
= TRUE
;
3419 dump_debugging_tags
= 1;
3424 dump_dwarf_section_info
= TRUE
;
3427 dwarf_select_sections_by_letters (optarg
);
3429 dwarf_select_sections_all ();
3432 dump_dwarf_section_info
= TRUE
;
3435 dwarf_select_sections_by_names (optarg
);
3437 dwarf_select_sections_all ();
3440 dump_stab_section_info
= TRUE
;
3444 dump_section_contents
= TRUE
;
3448 dump_reloc_info
= TRUE
;
3452 dump_dynamic_reloc_info
= TRUE
;
3456 dump_ar_hdrs
= TRUE
;
3460 dump_section_headers
= TRUE
;
3468 show_version
= TRUE
;
3478 print_version ("objdump");
3484 exit_status
= display_info ();
3488 display_file ("a.out", target
);
3490 for (; optind
< argc
;)
3491 display_file (argv
[optind
++], target
);
3496 END_PROGRESS (program_name
);