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, but not found in any input file"),
407 dump_section_header (bfd
*abfd
, asection
*section
,
408 void *ignored ATTRIBUTE_UNUSED
)
411 unsigned int opb
= bfd_octets_per_byte (abfd
);
413 /* Ignore linker created section. See elfNN_ia64_object_p in
415 if (section
->flags
& SEC_LINKER_CREATED
)
418 /* PR 10413: Skip sections that we are ignoring. */
419 if (! process_section_p (section
))
422 printf ("%3d %-13s %08lx ", section
->index
,
423 bfd_get_section_name (abfd
, section
),
424 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
425 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
427 bfd_printf_vma (abfd
, section
->lma
);
428 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
429 bfd_get_section_alignment (abfd
, section
));
435 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
437 PF (SEC_HAS_CONTENTS
, "CONTENTS");
438 PF (SEC_ALLOC
, "ALLOC");
439 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
440 PF (SEC_LOAD
, "LOAD");
441 PF (SEC_RELOC
, "RELOC");
442 PF (SEC_READONLY
, "READONLY");
443 PF (SEC_CODE
, "CODE");
444 PF (SEC_DATA
, "DATA");
446 PF (SEC_DEBUGGING
, "DEBUGGING");
447 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
448 PF (SEC_EXCLUDE
, "EXCLUDE");
449 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
450 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
452 PF (SEC_TIC54X_BLOCK
, "BLOCK");
453 PF (SEC_TIC54X_CLINK
, "CLINK");
455 PF (SEC_SMALL_DATA
, "SMALL_DATA");
456 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
457 PF (SEC_COFF_SHARED
, "SHARED");
458 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
459 PF (SEC_GROUP
, "GROUP");
461 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
464 struct coff_comdat_info
*comdat
;
466 switch (section
->flags
& SEC_LINK_DUPLICATES
)
470 case SEC_LINK_DUPLICATES_DISCARD
:
471 ls
= "LINK_ONCE_DISCARD";
473 case SEC_LINK_DUPLICATES_ONE_ONLY
:
474 ls
= "LINK_ONCE_ONE_ONLY";
476 case SEC_LINK_DUPLICATES_SAME_SIZE
:
477 ls
= "LINK_ONCE_SAME_SIZE";
479 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
480 ls
= "LINK_ONCE_SAME_CONTENTS";
483 printf ("%s%s", comma
, ls
);
485 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
487 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
497 dump_headers (bfd
*abfd
)
499 printf (_("Sections:\n"));
502 printf (_("Idx Name Size VMA LMA File off Algn"));
504 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
505 if (bfd_get_arch_size (abfd
) == 32)
506 printf (_("Idx Name Size VMA LMA File off Algn"));
508 printf (_("Idx Name Size VMA LMA File off Algn"));
512 printf (_(" Flags"));
513 if (abfd
->flags
& HAS_LOAD_PAGE
)
517 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
521 slurp_symtab (bfd
*abfd
)
526 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
532 storage
= bfd_get_symtab_upper_bound (abfd
);
534 bfd_fatal (bfd_get_filename (abfd
));
536 sy
= (asymbol
**) xmalloc (storage
);
538 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
540 bfd_fatal (bfd_get_filename (abfd
));
544 /* Read in the dynamic symbols. */
547 slurp_dynamic_symtab (bfd
*abfd
)
552 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
555 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
557 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
562 bfd_fatal (bfd_get_filename (abfd
));
565 sy
= (asymbol
**) xmalloc (storage
);
567 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
569 bfd_fatal (bfd_get_filename (abfd
));
573 /* Filter out (in place) symbols that are useless for disassembly.
574 COUNT is the number of elements in SYMBOLS.
575 Return the number of useful symbols. */
578 remove_useless_symbols (asymbol
**symbols
, long count
)
580 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
584 asymbol
*sym
= *in_ptr
++;
586 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
588 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
590 if (bfd_is_und_section (sym
->section
)
591 || bfd_is_com_section (sym
->section
))
596 return out_ptr
- symbols
;
599 /* Sort symbols into value order. */
602 compare_symbols (const void *ap
, const void *bp
)
604 const asymbol
*a
= * (const asymbol
**) ap
;
605 const asymbol
*b
= * (const asymbol
**) bp
;
615 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
617 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
620 if (a
->section
> b
->section
)
622 else if (a
->section
< b
->section
)
625 an
= bfd_asymbol_name (a
);
626 bn
= bfd_asymbol_name (b
);
630 /* The symbols gnu_compiled and gcc2_compiled convey no real
631 information, so put them after other symbols with the same value. */
632 af
= (strstr (an
, "gnu_compiled") != NULL
633 || strstr (an
, "gcc2_compiled") != NULL
);
634 bf
= (strstr (bn
, "gnu_compiled") != NULL
635 || strstr (bn
, "gcc2_compiled") != NULL
);
642 /* We use a heuristic for the file name, to try to sort it after
643 more useful symbols. It may not work on non Unix systems, but it
644 doesn't really matter; the only difference is precisely which
645 symbol names get printed. */
647 #define file_symbol(s, sn, snl) \
648 (((s)->flags & BSF_FILE) != 0 \
649 || ((sn)[(snl) - 2] == '.' \
650 && ((sn)[(snl) - 1] == 'o' \
651 || (sn)[(snl) - 1] == 'a')))
653 af
= file_symbol (a
, an
, anl
);
654 bf
= file_symbol (b
, bn
, bnl
);
661 /* Try to sort global symbols before local symbols before function
662 symbols before debugging symbols. */
667 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
669 if ((aflags
& BSF_DEBUGGING
) != 0)
674 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
676 if ((aflags
& BSF_FUNCTION
) != 0)
681 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
683 if ((aflags
& BSF_LOCAL
) != 0)
688 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
690 if ((aflags
& BSF_GLOBAL
) != 0)
696 /* Symbols that start with '.' might be section names, so sort them
697 after symbols that don't start with '.'. */
698 if (an
[0] == '.' && bn
[0] != '.')
700 if (an
[0] != '.' && bn
[0] == '.')
703 /* Finally, if we can't distinguish them in any other way, try to
704 get consistent results by sorting the symbols by name. */
705 return strcmp (an
, bn
);
708 /* Sort relocs into address order. */
711 compare_relocs (const void *ap
, const void *bp
)
713 const arelent
*a
= * (const arelent
**) ap
;
714 const arelent
*b
= * (const arelent
**) bp
;
716 if (a
->address
> b
->address
)
718 else if (a
->address
< b
->address
)
721 /* So that associated relocations tied to the same address show up
722 in the correct order, we don't do any further sorting. */
731 /* Print an address (VMA) to the output stream in INFO.
732 If SKIP_ZEROES is TRUE, omit leading zeroes. */
735 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
736 bfd_boolean skip_zeroes
)
740 struct objdump_disasm_info
*aux
;
742 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
743 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
748 for (p
= buf
; *p
== '0'; ++p
)
753 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
756 /* Print the name of a symbol. */
759 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
766 name
= bfd_asymbol_name (sym
);
767 if (do_demangle
&& name
[0] != '\0')
769 /* Demangle the name. */
770 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
776 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
784 /* Locate a symbol given a bfd and a section (from INFO->application_data),
785 and a VMA. If INFO->application_data->require_sec is TRUE, then always
786 require the symbol to be in the section. Returns NULL if there is no
787 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
788 of the symbol in sorted_syms. */
791 find_symbol_for_address (bfd_vma vma
,
792 struct disassemble_info
*inf
,
795 /* @@ Would it speed things up to cache the last two symbols returned,
796 and maybe their address ranges? For many processors, only one memory
797 operand can be present at a time, so the 2-entry cache wouldn't be
798 constantly churned by code doing heavy memory accesses. */
800 /* Indices in `sorted_syms'. */
802 long max_count
= sorted_symcount
;
804 struct objdump_disasm_info
*aux
;
808 bfd_boolean want_section
;
810 if (sorted_symcount
< 1)
813 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
816 opb
= inf
->octets_per_byte
;
818 /* Perform a binary search looking for the closest symbol to the
819 required value. We are searching the range (min, max_count]. */
820 while (min
+ 1 < max_count
)
824 thisplace
= (max_count
+ min
) / 2;
825 sym
= sorted_syms
[thisplace
];
827 if (bfd_asymbol_value (sym
) > vma
)
828 max_count
= thisplace
;
829 else if (bfd_asymbol_value (sym
) < vma
)
838 /* The symbol we want is now in min, the low end of the range we
839 were searching. If there are several symbols with the same
840 value, we want the first one. */
843 && (bfd_asymbol_value (sorted_syms
[thisplace
])
844 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
847 /* Prefer a symbol in the current section if we have multple symbols
848 with the same value, as can occur with overlays or zero size
851 while (min
< max_count
852 && (bfd_asymbol_value (sorted_syms
[min
])
853 == bfd_asymbol_value (sorted_syms
[thisplace
])))
855 if (sorted_syms
[min
]->section
== sec
856 && inf
->symbol_is_valid (sorted_syms
[min
], inf
))
863 return sorted_syms
[thisplace
];
868 /* If the file is relocatable, and the symbol could be from this
869 section, prefer a symbol from this section over symbols from
870 others, even if the other symbol's value might be closer.
872 Note that this may be wrong for some symbol references if the
873 sections have overlapping memory ranges, but in that case there's
874 no way to tell what's desired without looking at the relocation
877 Also give the target a chance to reject symbols. */
878 want_section
= (aux
->require_sec
879 || ((abfd
->flags
& HAS_RELOC
) != 0
880 && vma
>= bfd_get_section_vma (abfd
, sec
)
881 && vma
< (bfd_get_section_vma (abfd
, sec
)
882 + bfd_section_size (abfd
, sec
) / opb
)));
883 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
884 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
887 long newplace
= sorted_symcount
;
889 for (i
= min
- 1; i
>= 0; i
--)
891 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
892 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
894 if (newplace
== sorted_symcount
)
897 if (bfd_asymbol_value (sorted_syms
[i
])
898 != bfd_asymbol_value (sorted_syms
[newplace
]))
901 /* Remember this symbol and keep searching until we reach
902 an earlier address. */
907 if (newplace
!= sorted_symcount
)
908 thisplace
= newplace
;
911 /* We didn't find a good symbol with a smaller value.
912 Look for one with a larger value. */
913 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
915 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
916 && inf
->symbol_is_valid (sorted_syms
[i
], inf
))
924 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
925 || ! inf
->symbol_is_valid (sorted_syms
[thisplace
], inf
))
926 /* There is no suitable symbol. */
933 return sorted_syms
[thisplace
];
936 /* Print an address and the offset to the nearest symbol. */
939 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
940 bfd_vma vma
, struct disassemble_info
*inf
,
941 bfd_boolean skip_zeroes
)
943 objdump_print_value (vma
, inf
, skip_zeroes
);
949 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
950 bfd_get_section_name (abfd
, sec
));
951 secaddr
= bfd_get_section_vma (abfd
, sec
);
954 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
955 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
957 else if (vma
> secaddr
)
959 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
960 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
962 (*inf
->fprintf_func
) (inf
->stream
, ">");
966 (*inf
->fprintf_func
) (inf
->stream
, " <");
967 objdump_print_symname (abfd
, inf
, sym
);
968 if (bfd_asymbol_value (sym
) > vma
)
970 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
971 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
973 else if (vma
> bfd_asymbol_value (sym
))
975 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
976 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
978 (*inf
->fprintf_func
) (inf
->stream
, ">");
981 if (display_file_offsets
)
982 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
983 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
986 /* Print an address (VMA), symbolically if possible.
987 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
990 objdump_print_addr (bfd_vma vma
,
991 struct disassemble_info
*inf
,
992 bfd_boolean skip_zeroes
)
994 struct objdump_disasm_info
*aux
;
996 bfd_boolean skip_find
= FALSE
;
998 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1000 if (sorted_symcount
< 1)
1002 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1003 objdump_print_value (vma
, inf
, skip_zeroes
);
1005 if (display_file_offsets
)
1006 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1007 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1011 if (aux
->reloc
!= NULL
1012 && aux
->reloc
->sym_ptr_ptr
!= NULL
1013 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1015 sym
= * aux
->reloc
->sym_ptr_ptr
;
1017 /* Adjust the vma to the reloc. */
1018 vma
+= bfd_asymbol_value (sym
);
1020 if (bfd_is_und_section (bfd_get_section (sym
)))
1025 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1027 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1031 /* Print VMA to INFO. This function is passed to the disassembler
1035 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1037 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1040 /* Determine if the given address has a symbol associated with it. */
1043 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1047 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1049 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1052 /* Hold the last function name and the last line number we displayed
1053 in a disassembly. */
1055 static char *prev_functionname
;
1056 static unsigned int prev_line
;
1058 /* We keep a list of all files that we have seen when doing a
1059 disassembly with source, so that we know how much of the file to
1060 display. This can be important for inlined functions. */
1062 struct print_file_list
1064 struct print_file_list
*next
;
1065 const char *filename
;
1066 const char *modname
;
1069 const char **linemap
;
1075 static struct print_file_list
*print_files
;
1077 /* The number of preceding context lines to show when we start
1078 displaying a file for the first time. */
1080 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1082 /* Read a complete file into memory. */
1085 slurp_file (const char *fn
, size_t *size
)
1088 int ps
= getpagesize ();
1093 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1097 if (fstat (fd
, &st
) < 0)
1101 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1102 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1103 if (map
!= (char *)-1L)
1109 map
= (const char *) malloc (*size
);
1110 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1119 #define line_map_decrease 5
1121 /* Precompute array of lines for a mapped file. */
1123 static const char **
1124 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1126 const char *p
, *lstart
, *end
;
1127 int chars_per_line
= 45; /* First iteration will use 40. */
1128 unsigned int lineno
;
1129 const char **linemap
= NULL
;
1130 unsigned long line_map_size
= 0;
1136 for (p
= map
; p
< end
; p
++)
1140 if (p
+ 1 < end
&& p
[1] == '\r')
1143 else if (*p
== '\r')
1145 if (p
+ 1 < end
&& p
[1] == '\n')
1151 /* End of line found. */
1153 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1155 unsigned long newsize
;
1157 chars_per_line
-= line_map_decrease
;
1158 if (chars_per_line
<= 1)
1160 line_map_size
= size
/ chars_per_line
+ 1;
1161 if (line_map_size
< lineno
+ 1)
1162 line_map_size
= lineno
+ 1;
1163 newsize
= line_map_size
* sizeof (char *);
1164 linemap
= (const char **) xrealloc (linemap
, newsize
);
1167 linemap
[lineno
++] = lstart
;
1175 /* Tries to open MODNAME, and if successful adds a node to print_files
1176 linked list and returns that node. Returns NULL on failure. */
1178 static struct print_file_list
*
1179 try_print_file_open (const char *origname
, const char *modname
)
1181 struct print_file_list
*p
;
1183 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1185 p
->map
= slurp_file (modname
, &p
->mapsize
);
1192 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1194 p
->filename
= origname
;
1195 p
->modname
= modname
;
1196 p
->next
= print_files
;
1202 /* If the the source file, as described in the symtab, is not found
1203 try to locate it in one of the paths specified with -I
1204 If found, add location to print_files linked list. */
1206 static struct print_file_list
*
1207 update_source_path (const char *filename
)
1209 struct print_file_list
*p
;
1213 if (filename
== NULL
)
1216 p
= try_print_file_open (filename
, filename
);
1220 if (include_path_count
== 0)
1223 /* Get the name of the file. */
1224 fname
= lbasename (filename
);
1226 /* If file exists under a new path, we need to add it to the list
1227 so that show_line knows about it. */
1228 for (i
= 0; i
< include_path_count
; i
++)
1230 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1232 p
= try_print_file_open (filename
, modname
);
1242 /* Print a source file line. */
1245 print_line (struct print_file_list
*p
, unsigned int linenum
)
1251 if (linenum
>= p
->maxline
)
1253 l
= p
->linemap
[linenum
];
1254 /* Test fwrite return value to quiet glibc warning. */
1255 len
= strcspn (l
, "\n\r");
1256 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1260 /* Print a range of source code lines. */
1263 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1267 while (start
<= end
)
1269 print_line (p
, start
);
1274 /* Show the line number, or the source line, in a disassembly
1278 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1280 const char *filename
;
1281 const char *functionname
;
1282 unsigned int linenumber
;
1285 if (! with_line_numbers
&& ! with_source_code
)
1288 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1289 &functionname
, &linenumber
))
1292 if (filename
!= NULL
&& *filename
== '\0')
1294 if (functionname
!= NULL
&& *functionname
== '\0')
1295 functionname
= NULL
;
1298 && IS_ABSOLUTE_PATH (filename
)
1302 const char *fname
= filename
;
1303 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1306 memcpy (path
, prefix
, prefix_length
);
1307 path_up
= path
+ prefix_length
;
1309 /* Build relocated filename, stripping off leading directories
1310 from the initial filename if requested. */
1311 if (prefix_strip
> 0)
1316 /* Skip selected directory levels. */
1317 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1318 if (IS_DIR_SEPARATOR(*s
))
1325 /* Update complete filename. */
1326 strncpy (path_up
, fname
, PATH_MAX
);
1327 path_up
[PATH_MAX
] = '\0';
1335 if (with_line_numbers
)
1337 if (functionname
!= NULL
1338 && (prev_functionname
== NULL
1339 || strcmp (functionname
, prev_functionname
) != 0))
1340 printf ("%s():\n", functionname
);
1341 if (linenumber
> 0 && linenumber
!= prev_line
)
1342 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
1345 if (with_source_code
1349 struct print_file_list
**pp
, *p
;
1352 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1353 if (strcmp ((*pp
)->filename
, filename
) == 0)
1360 filename
= xstrdup (filename
);
1361 p
= update_source_path (filename
);
1364 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1366 if (file_start_context
&& p
->first
)
1370 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1371 if (l
>= linenumber
)
1373 if (p
->last_line
>= l
&& p
->last_line
<= linenumber
)
1374 l
= p
->last_line
+ 1;
1376 dump_lines (p
, l
, linenumber
);
1377 p
->last_line
= linenumber
;
1382 if (functionname
!= NULL
1383 && (prev_functionname
== NULL
1384 || strcmp (functionname
, prev_functionname
) != 0))
1386 if (prev_functionname
!= NULL
)
1387 free (prev_functionname
);
1388 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1389 strcpy (prev_functionname
, functionname
);
1392 if (linenumber
> 0 && linenumber
!= prev_line
)
1393 prev_line
= linenumber
;
1396 /* Pseudo FILE object for strings. */
1404 /* sprintf to a "stream". */
1406 static int ATTRIBUTE_PRINTF_2
1407 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1414 size_t space
= f
->alloc
- f
->pos
;
1416 va_start (args
, format
);
1417 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1423 f
->alloc
= (f
->alloc
+ n
) * 2;
1424 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1431 /* The number of zeroes we want to see before we start skipping them.
1432 The number is arbitrarily chosen. */
1434 #define DEFAULT_SKIP_ZEROES 8
1436 /* The number of zeroes to skip at the end of a section. If the
1437 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1438 SKIP_ZEROES, they will be disassembled. If there are fewer than
1439 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1440 attempt to avoid disassembling zeroes inserted by section
1443 #define DEFAULT_SKIP_ZEROES_AT_END 3
1445 /* Disassemble some data in memory between given values. */
1448 disassemble_bytes (struct disassemble_info
* inf
,
1449 disassembler_ftype disassemble_fn
,
1452 bfd_vma start_offset
,
1453 bfd_vma stop_offset
,
1456 arelent
** relppend
)
1458 struct objdump_disasm_info
*aux
;
1460 int octets_per_line
;
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;
1507 addr_offset
= start_offset
;
1508 while (addr_offset
< stop_offset
)
1511 bfd_boolean need_nl
= FALSE
;
1512 int previous_octets
;
1514 /* Remember the length of the previous instruction. */
1515 previous_octets
= octets
;
1518 /* Make sure we don't use relocs from previous instructions. */
1521 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1523 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1526 if (! disassemble_zeroes
1527 && (inf
->insn_info_valid
== 0
1528 || inf
->branch_delay_insns
== 0)
1529 && (z
- addr_offset
* opb
>= skip_zeroes
1530 || (z
== stop_offset
* opb
&&
1531 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1533 /* If there are more nonzero octets to follow, we only skip
1534 zeroes in multiples of 4, to try to avoid running over
1535 the start of an instruction which happens to start with
1537 if (z
!= stop_offset
* opb
)
1538 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1540 octets
= z
- addr_offset
* opb
;
1542 /* If we are going to display more data, and we are displaying
1543 file offsets, then tell the user how many zeroes we skip
1544 and the file offset from where we resume dumping. */
1545 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1546 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1548 (unsigned long) (section
->filepos
1549 + (addr_offset
+ (octets
/ opb
))));
1559 if (with_line_numbers
|| with_source_code
)
1560 show_line (aux
->abfd
, section
, addr_offset
);
1562 if (! prefix_addresses
)
1566 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1567 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1571 printf ("%s:\t", buf
+ skip_addr_chars
);
1575 aux
->require_sec
= TRUE
;
1576 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1577 aux
->require_sec
= FALSE
;
1584 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1585 inf
->stream
= &sfile
;
1586 inf
->bytes_per_line
= 0;
1587 inf
->bytes_per_chunk
= 0;
1588 inf
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1590 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1592 if (inf
->disassembler_needs_relocs
1593 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1594 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1595 && *relppp
< relppend
)
1597 bfd_signed_vma distance_to_rel
;
1599 distance_to_rel
= (**relppp
)->address
1600 - (rel_offset
+ addr_offset
);
1602 /* Check to see if the current reloc is associated with
1603 the instruction that we are about to disassemble. */
1604 if (distance_to_rel
== 0
1605 /* FIXME: This is wrong. We are trying to catch
1606 relocs that are addressed part way through the
1607 current instruction, as might happen with a packed
1608 VLIW instruction. Unfortunately we do not know the
1609 length of the current instruction since we have not
1610 disassembled it yet. Instead we take a guess based
1611 upon the length of the previous instruction. The
1612 proper solution is to have a new target-specific
1613 disassembler function which just returns the length
1614 of an instruction at a given address without trying
1615 to display its disassembly. */
1616 || (distance_to_rel
> 0
1617 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1619 inf
->flags
|= INSN_HAS_RELOC
;
1620 aux
->reloc
= **relppp
;
1624 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
1625 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
1626 inf
->stream
= stdout
;
1627 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
1628 octets_per_line
= inf
->bytes_per_line
;
1632 printf ("%s\n", sfile
.buffer
);
1640 octets
= octets_per_line
;
1641 if (addr_offset
+ octets
/ opb
> stop_offset
)
1642 octets
= (stop_offset
- addr_offset
) * opb
;
1644 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1646 if (ISPRINT (data
[j
]))
1647 buf
[j
- addr_offset
* opb
] = data
[j
];
1649 buf
[j
- addr_offset
* opb
] = '.';
1651 buf
[j
- addr_offset
* opb
] = '\0';
1654 if (prefix_addresses
1656 : show_raw_insn
>= 0)
1660 /* If ! prefix_addresses and ! wide_output, we print
1661 octets_per_line octets per line. */
1663 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1664 pb
= octets_per_line
;
1666 if (inf
->bytes_per_chunk
)
1667 bpc
= inf
->bytes_per_chunk
;
1671 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1675 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1677 for (k
= bpc
- 1; k
>= 0; k
--)
1678 printf ("%02x", (unsigned) data
[j
+ k
]);
1683 for (k
= 0; k
< bpc
; k
++)
1684 printf ("%02x", (unsigned) data
[j
+ k
]);
1689 for (; pb
< octets_per_line
; pb
+= bpc
)
1693 for (k
= 0; k
< bpc
; k
++)
1698 /* Separate raw data from instruction by extra space. */
1708 printf ("%s", sfile
.buffer
);
1710 if (prefix_addresses
1712 : show_raw_insn
>= 0)
1720 j
= addr_offset
* opb
+ pb
;
1722 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1723 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1727 printf ("%s:\t", buf
+ skip_addr_chars
);
1729 pb
+= octets_per_line
;
1732 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1736 if (bpc
> 1 && inf
->display_endian
== BFD_ENDIAN_LITTLE
)
1738 for (k
= bpc
- 1; k
>= 0; k
--)
1739 printf ("%02x", (unsigned) data
[j
+ k
]);
1744 for (k
= 0; k
< bpc
; k
++)
1745 printf ("%02x", (unsigned) data
[j
+ k
]);
1758 while ((*relppp
) < relppend
1759 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1761 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1772 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1775 if (q
->howto
== NULL
)
1776 printf (": *unknown*\t");
1777 else if (q
->howto
->name
)
1778 printf (": %s\t", q
->howto
->name
);
1780 printf (": %d\t", q
->howto
->type
);
1782 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1783 printf ("*unknown*");
1786 const char *sym_name
;
1788 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1789 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1790 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
1795 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1796 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1797 if (sym_name
== NULL
|| *sym_name
== '\0')
1798 sym_name
= "*unknown*";
1799 printf ("%s", sym_name
);
1806 objdump_print_value (q
->addend
, inf
, TRUE
);
1818 addr_offset
+= octets
/ opb
;
1821 free (sfile
.buffer
);
1825 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
1827 const struct elf_backend_data
* bed
;
1828 bfd_vma sign_adjust
= 0;
1829 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
1830 struct objdump_disasm_info
* paux
;
1831 unsigned int opb
= pinfo
->octets_per_byte
;
1832 bfd_byte
* data
= NULL
;
1833 bfd_size_type datasize
= 0;
1834 arelent
** rel_pp
= NULL
;
1835 arelent
** rel_ppstart
= NULL
;
1836 arelent
** rel_ppend
;
1837 unsigned long stop_offset
;
1838 asymbol
* sym
= NULL
;
1842 unsigned long addr_offset
;
1844 /* Sections that do not contain machine
1845 code are not normally disassembled. */
1846 if (! disassemble_all
1847 && only_list
== NULL
1848 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1849 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1852 if (! process_section_p (section
))
1855 datasize
= bfd_get_section_size (section
);
1859 /* Decide which set of relocs to use. Load them if necessary. */
1860 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1861 if (paux
->dynrelbuf
)
1863 rel_pp
= paux
->dynrelbuf
;
1864 rel_count
= paux
->dynrelcount
;
1865 /* Dynamic reloc addresses are absolute, non-dynamic are section
1866 relative. REL_OFFSET specifies the reloc address corresponding
1867 to the start of this section. */
1868 rel_offset
= section
->vma
;
1876 if ((section
->flags
& SEC_RELOC
) != 0
1877 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1881 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1883 bfd_fatal (bfd_get_filename (abfd
));
1887 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
1888 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1890 bfd_fatal (bfd_get_filename (abfd
));
1892 /* Sort the relocs by address. */
1893 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1897 rel_ppend
= rel_pp
+ rel_count
;
1899 data
= (bfd_byte
*) xmalloc (datasize
);
1901 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1903 paux
->sec
= section
;
1904 pinfo
->buffer
= data
;
1905 pinfo
->buffer_vma
= section
->vma
;
1906 pinfo
->buffer_length
= datasize
;
1907 pinfo
->section
= section
;
1909 if (start_address
== (bfd_vma
) -1
1910 || start_address
< pinfo
->buffer_vma
)
1913 addr_offset
= start_address
- pinfo
->buffer_vma
;
1915 if (stop_address
== (bfd_vma
) -1)
1916 stop_offset
= datasize
/ opb
;
1919 if (stop_address
< pinfo
->buffer_vma
)
1922 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1923 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1924 stop_offset
= pinfo
->buffer_length
/ opb
;
1927 /* Skip over the relocs belonging to addresses below the
1929 while (rel_pp
< rel_ppend
1930 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1933 if (addr_offset
< stop_offset
)
1934 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1936 /* Find the nearest symbol forwards from our current position. */
1937 paux
->require_sec
= TRUE
;
1938 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
1939 (struct disassemble_info
*) inf
,
1941 paux
->require_sec
= FALSE
;
1943 /* PR 9774: If the target used signed addresses then we must make
1944 sure that we sign extend the value that we calculate for 'addr'
1945 in the loop below. */
1946 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1947 && (bed
= get_elf_backend_data (abfd
)) != NULL
1948 && bed
->sign_extend_vma
)
1949 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
1951 /* Disassemble a block of instructions up to the address associated with
1952 the symbol we have just found. Then print the symbol and find the
1953 next symbol on. Repeat until we have disassembled the entire section
1954 or we have reached the end of the address range we are interested in. */
1955 while (addr_offset
< stop_offset
)
1959 unsigned long nextstop_offset
;
1962 addr
= section
->vma
+ addr_offset
;
1963 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
1965 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1970 (x
< sorted_symcount
1971 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1975 pinfo
->symbols
= sorted_syms
+ place
;
1976 pinfo
->num_symbols
= x
- place
;
1977 pinfo
->symtab_pos
= place
;
1981 pinfo
->symbols
= NULL
;
1982 pinfo
->num_symbols
= 0;
1983 pinfo
->symtab_pos
= -1;
1986 if (! prefix_addresses
)
1988 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1989 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1991 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1994 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1996 else if (sym
== NULL
)
2000 #define is_valid_next_sym(SYM) \
2001 ((SYM)->section == section \
2002 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2003 && pinfo->symbol_is_valid (SYM, pinfo))
2005 /* Search forward for the next appropriate symbol in
2006 SECTION. Note that all the symbols are sorted
2007 together into one big array, and that some sections
2008 may have overlapping addresses. */
2009 while (place
< sorted_symcount
2010 && ! is_valid_next_sym (sorted_syms
[place
]))
2013 if (place
>= sorted_symcount
)
2016 nextsym
= sorted_syms
[place
];
2019 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2020 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2021 else if (nextsym
== NULL
)
2022 nextstop_offset
= stop_offset
;
2024 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2026 if (nextstop_offset
> stop_offset
2027 || nextstop_offset
<= addr_offset
)
2028 nextstop_offset
= stop_offset
;
2030 /* If a symbol is explicitly marked as being an object
2031 rather than a function, just dump the bytes without
2032 disassembling them. */
2035 || sym
->section
!= section
2036 || bfd_asymbol_value (sym
) > addr
2037 || ((sym
->flags
& BSF_OBJECT
) == 0
2038 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2040 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2042 || (sym
->flags
& BSF_FUNCTION
) != 0)
2047 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2048 addr_offset
, nextstop_offset
,
2049 rel_offset
, &rel_pp
, rel_ppend
);
2051 addr_offset
= nextstop_offset
;
2057 if (rel_ppstart
!= NULL
)
2061 /* Disassemble the contents of an object file. */
2064 disassemble_data (bfd
*abfd
)
2066 struct disassemble_info disasm_info
;
2067 struct objdump_disasm_info aux
;
2071 prev_functionname
= NULL
;
2074 /* We make a copy of syms to sort. We don't want to sort syms
2075 because that will screw up the relocs. */
2076 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2077 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2078 * sizeof (asymbol
*));
2079 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2080 sorted_symcount
* sizeof (asymbol
*));
2082 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2084 for (i
= 0; i
< synthcount
; ++i
)
2086 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2090 /* Sort the symbols into section and symbol order. */
2091 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2093 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2095 disasm_info
.application_data
= (void *) &aux
;
2097 aux
.require_sec
= FALSE
;
2098 aux
.dynrelbuf
= NULL
;
2099 aux
.dynrelcount
= 0;
2102 disasm_info
.print_address_func
= objdump_print_address
;
2103 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2105 if (machine
!= NULL
)
2107 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2110 fatal (_("Can't use supplied machine %s"), machine
);
2112 abfd
->arch_info
= inf
;
2115 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2117 struct bfd_target
*xvec
;
2119 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2120 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2121 xvec
->byteorder
= endian
;
2125 /* Use libopcodes to locate a suitable disassembler. */
2126 aux
.disassemble_fn
= disassembler (abfd
);
2127 if (!aux
.disassemble_fn
)
2129 non_fatal (_("Can't disassemble for architecture %s\n"),
2130 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2135 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2136 disasm_info
.arch
= bfd_get_arch (abfd
);
2137 disasm_info
.mach
= bfd_get_mach (abfd
);
2138 disasm_info
.disassembler_options
= disassembler_options
;
2139 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2140 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2141 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2142 disasm_info
.disassembler_needs_relocs
= FALSE
;
2144 if (bfd_big_endian (abfd
))
2145 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2146 else if (bfd_little_endian (abfd
))
2147 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2149 /* ??? Aborting here seems too drastic. We could default to big or little
2151 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2153 /* Allow the target to customize the info structure. */
2154 disassemble_init_for_target (& disasm_info
);
2156 /* Pre-load the dynamic relocs if we are going
2157 to be dumping them along with the disassembly. */
2158 if (dump_dynamic_reloc_info
)
2160 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2163 bfd_fatal (bfd_get_filename (abfd
));
2167 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2168 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2171 if (aux
.dynrelcount
< 0)
2172 bfd_fatal (bfd_get_filename (abfd
));
2174 /* Sort the relocs by address. */
2175 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2179 disasm_info
.symtab
= sorted_syms
;
2180 disasm_info
.symtab_size
= sorted_symcount
;
2182 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2184 if (aux
.dynrelbuf
!= NULL
)
2185 free (aux
.dynrelbuf
);
2190 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2191 asection
*sec
, void *file
)
2193 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2194 bfd
*abfd
= (bfd
*) file
;
2196 int section_is_compressed
;
2198 /* If it is already loaded, do nothing. */
2199 if (section
->start
!= NULL
)
2202 section_is_compressed
= section
->name
== section
->compressed_name
;
2204 section
->address
= 0;
2205 section
->size
= bfd_get_section_size (sec
);
2206 section
->start
= (unsigned char *) xmalloc (section
->size
);
2208 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2213 free_debug_section (debug
);
2214 printf (_("\nCan't get contents for section '%s'.\n"),
2219 if (section_is_compressed
)
2221 bfd_size_type size
= section
->size
;
2222 if (! bfd_uncompress_section_contents (§ion
->start
, &size
))
2224 free_debug_section (debug
);
2225 printf (_("\nCan't uncompress section '%s'.\n"), section
->name
);
2228 section
->size
= size
;
2231 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2233 /* We want to relocate the data we've already read (and
2234 decompressed), so we store a pointer to the data in
2235 the bfd_section, and tell it that the contents are
2236 already in memory. */
2237 sec
->contents
= section
->start
;
2238 sec
->flags
|= SEC_IN_MEMORY
;
2239 sec
->size
= section
->size
;
2241 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2248 free_debug_section (debug
);
2249 printf (_("\nCan't get contents for section '%s'.\n"),
2259 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2261 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2262 bfd
*abfd
= (bfd
*) file
;
2265 /* If it is already loaded, do nothing. */
2266 if (section
->start
!= NULL
)
2269 /* Locate the debug section. */
2270 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2272 section
->name
= section
->uncompressed_name
;
2275 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2277 section
->name
= section
->compressed_name
;
2282 return load_specific_debug_section (debug
, sec
, file
);
2286 free_debug_section (enum dwarf_section_display_enum debug
)
2288 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2290 if (section
->start
== NULL
)
2293 free ((char *) section
->start
);
2294 section
->start
= NULL
;
2295 section
->address
= 0;
2300 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2301 void *arg ATTRIBUTE_UNUSED
)
2303 const char *name
= bfd_get_section_name (abfd
, section
);
2307 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2308 match
= ".debug_info";
2312 for (i
= 0; i
< max
; i
++)
2313 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2314 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2315 && debug_displays
[i
].enabled
!= NULL
2316 && *debug_displays
[i
].enabled
)
2318 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2320 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2321 sec
->name
= sec
->uncompressed_name
;
2323 sec
->name
= sec
->compressed_name
;
2324 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2327 debug_displays
[i
].display (sec
, abfd
);
2329 if (i
!= info
&& i
!= abbrev
)
2330 free_debug_section ((enum dwarf_section_display_enum
) i
);
2336 /* Dump the dwarf debugging information. */
2339 dump_dwarf (bfd
*abfd
)
2341 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2343 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2345 if (bfd_big_endian (abfd
))
2346 byte_get
= byte_get_big_endian
;
2347 else if (bfd_little_endian (abfd
))
2348 byte_get
= byte_get_little_endian
;
2352 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2354 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2355 init_dwarf_regnames (bed
->elf_machine_code
);
2358 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2360 free_debug_memory ();
2363 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2364 it. Return NULL on failure. */
2367 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2373 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2374 if (stabsect
== NULL
)
2376 printf (_("No %s section present\n\n"), sect_name
);
2380 size
= bfd_section_size (abfd
, stabsect
);
2381 contents
= (char *) xmalloc (size
);
2383 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2385 non_fatal (_("Reading %s section of %s failed: %s"),
2386 sect_name
, bfd_get_filename (abfd
),
2387 bfd_errmsg (bfd_get_error ()));
2398 /* Stabs entries use a 12 byte format:
2399 4 byte string table index
2401 1 byte stab other field
2402 2 byte stab desc field
2404 FIXME: This will have to change for a 64 bit object format. */
2406 #define STRDXOFF (0)
2408 #define OTHEROFF (5)
2411 #define STABSIZE (12)
2413 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2414 using string table section STRSECT_NAME (in `strtab'). */
2417 print_section_stabs (bfd
*abfd
,
2418 const char *stabsect_name
,
2419 unsigned *string_offset_ptr
)
2422 unsigned file_string_table_offset
= 0;
2423 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2424 bfd_byte
*stabp
, *stabs_end
;
2427 stabs_end
= stabp
+ stab_size
;
2429 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2430 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2432 /* Loop through all symbols and print them.
2434 We start the index at -1 because there is a dummy symbol on
2435 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2436 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2440 unsigned char type
, other
;
2441 unsigned short desc
;
2444 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2445 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2446 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2447 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2448 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2450 printf ("\n%-6d ", i
);
2451 /* Either print the stab name, or, if unnamed, print its number
2452 again (makes consistent formatting for tools like awk). */
2453 name
= bfd_get_stab_name (type
);
2455 printf ("%-6s", name
);
2456 else if (type
== N_UNDF
)
2459 printf ("%-6d", type
);
2460 printf (" %-6d %-6d ", other
, desc
);
2461 bfd_printf_vma (abfd
, value
);
2462 printf (" %-6lu", strx
);
2464 /* Symbols with type == 0 (N_UNDF) specify the length of the
2465 string table associated with this file. We use that info
2466 to know how to relocate the *next* file's string table indices. */
2469 file_string_table_offset
= next_file_string_table_offset
;
2470 next_file_string_table_offset
+= value
;
2474 /* Using the (possibly updated) string table offset, print the
2475 string (if any) associated with this symbol. */
2476 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2477 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2483 *string_offset_ptr
= next_file_string_table_offset
;
2488 const char * section_name
;
2489 const char * string_section_name
;
2490 unsigned string_offset
;
2495 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2498 stab_section_names
* sought
= (stab_section_names
*) names
;
2500 /* Check for section names for which stabsect_name is a prefix, to
2501 handle .stab.N, etc. */
2502 len
= strlen (sought
->section_name
);
2504 /* If the prefix matches, and the files section name ends with a
2505 nul or a digit, then we match. I.e., we want either an exact
2506 match or a section followed by a number. */
2507 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2508 && (section
->name
[len
] == 0
2509 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2512 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2517 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2520 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2526 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2528 stab_section_names s
;
2530 s
.section_name
= stabsect_name
;
2531 s
.string_section_name
= strsect_name
;
2532 s
.string_offset
= 0;
2534 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2540 /* Dump the any sections containing stabs debugging information. */
2543 dump_stabs (bfd
*abfd
)
2545 dump_stabs_section (abfd
, ".stab", ".stabstr");
2546 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2547 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2550 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2552 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2556 dump_bfd_header (bfd
*abfd
)
2560 printf (_("architecture: %s, "),
2561 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2562 bfd_get_mach (abfd
)));
2563 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2565 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2566 PF (HAS_RELOC
, "HAS_RELOC");
2567 PF (EXEC_P
, "EXEC_P");
2568 PF (HAS_LINENO
, "HAS_LINENO");
2569 PF (HAS_DEBUG
, "HAS_DEBUG");
2570 PF (HAS_SYMS
, "HAS_SYMS");
2571 PF (HAS_LOCALS
, "HAS_LOCALS");
2572 PF (DYNAMIC
, "DYNAMIC");
2573 PF (WP_TEXT
, "WP_TEXT");
2574 PF (D_PAGED
, "D_PAGED");
2575 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2576 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2577 printf (_("\nstart address 0x"));
2578 bfd_printf_vma (abfd
, abfd
->start_address
);
2584 dump_bfd_private_header (bfd
*abfd
)
2586 bfd_print_private_bfd_data (abfd
, stdout
);
2590 /* Display a section in hexadecimal format with associated characters.
2591 Each line prefixed by the zero padded address. */
2594 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2597 bfd_size_type datasize
;
2598 bfd_size_type addr_offset
;
2599 bfd_size_type start_offset
;
2600 bfd_size_type stop_offset
;
2601 unsigned int opb
= bfd_octets_per_byte (abfd
);
2602 /* Bytes per line. */
2603 const int onaline
= 16;
2608 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2611 if (! process_section_p (section
))
2614 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2617 /* Compute the address range to display. */
2618 if (start_address
== (bfd_vma
) -1
2619 || start_address
< section
->vma
)
2622 start_offset
= start_address
- section
->vma
;
2624 if (stop_address
== (bfd_vma
) -1)
2625 stop_offset
= datasize
/ opb
;
2628 if (stop_address
< section
->vma
)
2631 stop_offset
= stop_address
- section
->vma
;
2633 if (stop_offset
> datasize
/ opb
)
2634 stop_offset
= datasize
/ opb
;
2637 if (start_offset
>= stop_offset
)
2640 printf (_("Contents of section %s:"), section
->name
);
2641 if (display_file_offsets
)
2642 printf (_(" (Starting at file offset: 0x%lx)"),
2643 (unsigned long) (section
->filepos
+ start_offset
));
2646 data
= (bfd_byte
*) xmalloc (datasize
);
2648 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2652 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2653 if (strlen (buf
) >= sizeof (buf
))
2657 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2659 count
= strlen (buf
) - count
;
2663 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2664 if (strlen (buf
) >= sizeof (buf
))
2668 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2670 count
= strlen (buf
) - count
;
2674 for (addr_offset
= start_offset
;
2675 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2679 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2680 count
= strlen (buf
);
2681 if ((size_t) count
>= sizeof (buf
))
2685 while (count
< width
)
2690 fputs (buf
+ count
- width
, stdout
);
2693 for (j
= addr_offset
* opb
;
2694 j
< addr_offset
* opb
+ onaline
; j
++)
2696 if (j
< stop_offset
* opb
)
2697 printf ("%02x", (unsigned) (data
[j
]));
2705 for (j
= addr_offset
* opb
;
2706 j
< addr_offset
* opb
+ onaline
; j
++)
2708 if (j
>= stop_offset
* opb
)
2711 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2718 /* Actually display the various requested regions. */
2721 dump_data (bfd
*abfd
)
2723 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2726 /* Should perhaps share code and display with nm? */
2729 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2738 max_count
= dynsymcount
;
2739 printf ("DYNAMIC SYMBOL TABLE:\n");
2744 max_count
= symcount
;
2745 printf ("SYMBOL TABLE:\n");
2749 printf (_("no symbols\n"));
2751 for (count
= 0; count
< max_count
; count
++)
2755 if (*current
== NULL
)
2756 printf (_("no information for symbol number %ld\n"), count
);
2758 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2759 printf (_("could not determine the type of symbol number %ld\n"),
2762 else if (process_section_p ((* current
)->section
)
2763 && (dump_special_syms
2764 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2766 const char *name
= (*current
)->name
;
2768 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2772 /* If we want to demangle the name, we demangle it
2773 here, and temporarily clobber it while calling
2774 bfd_print_symbol. FIXME: This is a gross hack. */
2775 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2777 (*current
)->name
= alloc
;
2778 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2779 bfd_print_symbol_all
);
2782 (*current
)->name
= name
;
2787 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2788 bfd_print_symbol_all
);
2798 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2801 char *last_filename
, *last_functionname
;
2802 unsigned int last_line
;
2804 /* Get column headers lined up reasonably. */
2812 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2813 width
= strlen (buf
) - 7;
2815 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2818 last_filename
= NULL
;
2819 last_functionname
= NULL
;
2822 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2825 const char *filename
, *functionname
;
2826 unsigned int linenumber
;
2827 const char *sym_name
;
2828 const char *section_name
;
2830 if (start_address
!= (bfd_vma
) -1
2831 && q
->address
< start_address
)
2833 if (stop_address
!= (bfd_vma
) -1
2834 && q
->address
> stop_address
)
2837 if (with_line_numbers
2839 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2840 &filename
, &functionname
, &linenumber
))
2842 if (functionname
!= NULL
2843 && (last_functionname
== NULL
2844 || strcmp (functionname
, last_functionname
) != 0))
2846 printf ("%s():\n", functionname
);
2847 if (last_functionname
!= NULL
)
2848 free (last_functionname
);
2849 last_functionname
= xstrdup (functionname
);
2853 && (linenumber
!= last_line
2854 || (filename
!= NULL
2855 && last_filename
!= NULL
2856 && strcmp (filename
, last_filename
) != 0)))
2858 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, linenumber
);
2859 last_line
= linenumber
;
2860 if (last_filename
!= NULL
)
2861 free (last_filename
);
2862 if (filename
== NULL
)
2863 last_filename
= NULL
;
2865 last_filename
= xstrdup (filename
);
2869 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2871 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2872 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2877 section_name
= NULL
;
2880 bfd_printf_vma (abfd
, q
->address
);
2881 if (q
->howto
== NULL
)
2882 printf (" *unknown* ");
2883 else if (q
->howto
->name
)
2884 printf (" %-16s ", q
->howto
->name
);
2886 printf (" %-16d ", q
->howto
->type
);
2890 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2894 if (section_name
== NULL
)
2895 section_name
= "*unknown*";
2896 printf ("[%s]", section_name
);
2902 bfd_printf_vma (abfd
, q
->addend
);
2910 dump_relocs_in_section (bfd
*abfd
,
2912 void *dummy ATTRIBUTE_UNUSED
)
2918 if ( bfd_is_abs_section (section
)
2919 || bfd_is_und_section (section
)
2920 || bfd_is_com_section (section
)
2921 || (! process_section_p (section
))
2922 || ((section
->flags
& SEC_RELOC
) == 0))
2925 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2927 bfd_fatal (bfd_get_filename (abfd
));
2929 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2933 printf (" (none)\n\n");
2937 relpp
= (arelent
**) xmalloc (relsize
);
2938 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2941 bfd_fatal (bfd_get_filename (abfd
));
2942 else if (relcount
== 0)
2943 printf (" (none)\n\n");
2947 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2954 dump_relocs (bfd
*abfd
)
2956 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2960 dump_dynamic_relocs (bfd
*abfd
)
2966 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2968 bfd_fatal (bfd_get_filename (abfd
));
2970 printf ("DYNAMIC RELOCATION RECORDS");
2973 printf (" (none)\n\n");
2976 relpp
= (arelent
**) xmalloc (relsize
);
2977 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2980 bfd_fatal (bfd_get_filename (abfd
));
2981 else if (relcount
== 0)
2982 printf (" (none)\n\n");
2986 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2993 /* Creates a table of paths, to search for source files. */
2996 add_include_path (const char *path
)
3000 include_path_count
++;
3001 include_paths
= (const char **)
3002 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3003 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3004 if (path
[1] == ':' && path
[2] == 0)
3005 path
= concat (path
, ".", (const char *) 0);
3007 include_paths
[include_path_count
- 1] = path
;
3011 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3015 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3017 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3018 section
->vma
+= adjust_section_vma
;
3020 section
->lma
+= adjust_section_vma
;
3024 /* Dump selected contents of ABFD. */
3027 dump_bfd (bfd
*abfd
)
3029 /* If we are adjusting section VMA's, change them all now. Changing
3030 the BFD information is a hack. However, we must do it, or
3031 bfd_find_nearest_line will not do the right thing. */
3032 if (adjust_section_vma
!= 0)
3034 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3035 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3038 if (! dump_debugging_tags
)
3039 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
3042 print_arelt_descr (stdout
, abfd
, TRUE
);
3043 if (dump_file_header
)
3044 dump_bfd_header (abfd
);
3045 if (dump_private_headers
)
3046 dump_bfd_private_header (abfd
);
3047 if (! dump_debugging_tags
)
3049 if (dump_section_headers
)
3050 dump_headers (abfd
);
3056 || dump_dwarf_section_info
)
3057 syms
= slurp_symtab (abfd
);
3058 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
3059 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
3060 dynsyms
= slurp_dynamic_symtab (abfd
);
3063 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
3064 dynsymcount
, dynsyms
, &synthsyms
);
3070 dump_symbols (abfd
, FALSE
);
3071 if (dump_dynamic_symtab
)
3072 dump_symbols (abfd
, TRUE
);
3073 if (dump_dwarf_section_info
)
3075 if (dump_stab_section_info
)
3077 if (dump_reloc_info
&& ! disassemble
)
3079 if (dump_dynamic_reloc_info
&& ! disassemble
)
3080 dump_dynamic_relocs (abfd
);
3081 if (dump_section_contents
)
3084 disassemble_data (abfd
);
3090 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3091 if (dhandle
!= NULL
)
3093 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3095 dump_debugging_tags
? TRUE
: FALSE
))
3097 non_fatal (_("%s: printing debugging information failed"),
3098 bfd_get_filename (abfd
));
3102 /* PR 6483: If there was no STABS or IEEE debug
3103 info in the file, try DWARF instead. */
3104 else if (! dump_dwarf_section_info
)
3134 display_bfd (bfd
*abfd
)
3138 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3144 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3146 nonfatal (bfd_get_filename (abfd
));
3147 list_matching_formats (matching
);
3152 if (bfd_get_error () != bfd_error_file_not_recognized
)
3154 nonfatal (bfd_get_filename (abfd
));
3158 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3164 nonfatal (bfd_get_filename (abfd
));
3166 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3168 list_matching_formats (matching
);
3174 display_file (char *filename
, char *target
)
3179 if (get_file_size (filename
) < 1)
3185 file
= bfd_openr (filename
, target
);
3188 nonfatal (filename
);
3192 /* If the file is an archive, process all of its elements. */
3193 if (bfd_check_format (file
, bfd_archive
))
3195 bfd
*last_arfile
= NULL
;
3197 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3200 bfd_set_error (bfd_error_no_error
);
3202 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3205 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3206 nonfatal (bfd_get_filename (file
));
3210 display_bfd (arfile
);
3212 if (last_arfile
!= NULL
)
3213 bfd_close (last_arfile
);
3214 last_arfile
= arfile
;
3217 if (last_arfile
!= NULL
)
3218 bfd_close (last_arfile
);
3227 main (int argc
, char **argv
)
3230 char *target
= default_target
;
3231 bfd_boolean seenflag
= FALSE
;
3233 #if defined (HAVE_SETLOCALE)
3234 #if defined (HAVE_LC_MESSAGES)
3235 setlocale (LC_MESSAGES
, "");
3237 setlocale (LC_CTYPE
, "");
3240 bindtextdomain (PACKAGE
, LOCALEDIR
);
3241 textdomain (PACKAGE
);
3243 program_name
= *argv
;
3244 xmalloc_set_program_name (program_name
);
3246 START_PROGRESS (program_name
, 0);
3248 expandargv (&argc
, &argv
);
3251 set_default_bfd_target ();
3253 while ((c
= getopt_long (argc
, argv
,
3254 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3255 long_options
, (int *) 0))
3261 break; /* We've been given a long option. */
3266 if (disassembler_options
)
3267 /* Ignore potential memory leak for now. */
3268 disassembler_options
= concat (disassembler_options
, ",",
3269 optarg
, (const char *) NULL
);
3271 disassembler_options
= optarg
;
3277 display_file_offsets
= TRUE
;
3280 with_line_numbers
= TRUE
;
3289 enum demangling_styles style
;
3291 style
= cplus_demangle_name_to_style (optarg
);
3292 if (style
== unknown_demangling
)
3293 fatal (_("unknown demangling style `%s'"),
3296 cplus_demangle_set_style (style
);
3302 case OPTION_ADJUST_VMA
:
3303 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3305 case OPTION_START_ADDRESS
:
3306 start_address
= parse_vma (optarg
, "--start-address");
3307 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3308 fatal (_("error: the start address should be before the end address"));
3310 case OPTION_STOP_ADDRESS
:
3311 stop_address
= parse_vma (optarg
, "--stop-address");
3312 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3313 fatal (_("error: the stop address should be after the start address"));
3317 prefix_length
= strlen (prefix
);
3318 /* Remove an unnecessary trailing '/' */
3319 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3322 case OPTION_PREFIX_STRIP
:
3323 prefix_strip
= atoi (optarg
);
3324 if (prefix_strip
< 0)
3325 fatal (_("error: prefix strip must be non-negative"));
3327 case OPTION_INSN_WIDTH
:
3328 insn_width
= strtoul (optarg
, NULL
, 0);
3329 if (insn_width
<= 0)
3330 fatal (_("error: instruction width must be positive"));
3333 if (strcmp (optarg
, "B") == 0)
3334 endian
= BFD_ENDIAN_BIG
;
3335 else if (strcmp (optarg
, "L") == 0)
3336 endian
= BFD_ENDIAN_LITTLE
;
3339 non_fatal (_("unrecognized -E option"));
3344 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3345 endian
= BFD_ENDIAN_BIG
;
3346 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3347 endian
= BFD_ENDIAN_LITTLE
;
3350 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3356 dump_file_header
= TRUE
;
3360 formats_info
= TRUE
;
3364 add_include_path (optarg
);
3367 dump_private_headers
= TRUE
;
3371 dump_private_headers
= TRUE
;
3373 dump_reloc_info
= TRUE
;
3374 dump_file_header
= TRUE
;
3375 dump_ar_hdrs
= TRUE
;
3376 dump_section_headers
= TRUE
;
3384 dump_dynamic_symtab
= TRUE
;
3392 disassemble_zeroes
= TRUE
;
3396 disassemble_all
= TRUE
;
3401 with_source_code
= TRUE
;
3410 dump_debugging_tags
= 1;
3415 dump_dwarf_section_info
= TRUE
;
3418 dwarf_select_sections_by_letters (optarg
);
3420 dwarf_select_sections_all ();
3423 dump_dwarf_section_info
= TRUE
;
3426 dwarf_select_sections_by_names (optarg
);
3428 dwarf_select_sections_all ();
3431 dump_stab_section_info
= TRUE
;
3435 dump_section_contents
= TRUE
;
3439 dump_reloc_info
= TRUE
;
3443 dump_dynamic_reloc_info
= TRUE
;
3447 dump_ar_hdrs
= TRUE
;
3451 dump_section_headers
= TRUE
;
3459 show_version
= TRUE
;
3469 print_version ("objdump");
3475 exit_status
= display_info ();
3479 display_file ("a.out", target
);
3481 for (; optind
< argc
;)
3482 display_file (argv
[optind
++], target
);
3487 END_PROGRESS (program_name
);