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
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 /* Pointer to an array of section names provided by
121 one or more "-j secname" command line options. */
123 /* The total number of slots in the only[] array. */
124 static size_t only_size
= 0;
125 /* The number of occupied slots in the only[] array. */
126 static size_t only_used
= 0;
128 /* Variables for handling include file path table. */
129 static const char **include_paths
;
130 static int include_path_count
;
132 /* Extra info to pass to the section disassembler and address printing
134 struct objdump_disasm_info
138 bfd_boolean require_sec
;
139 arelent
** dynrelbuf
;
141 disassembler_ftype disassemble_fn
;
145 /* Architecture to disassemble for, or default if NULL. */
146 static char *machine
= NULL
;
148 /* Target specific options to the disassembler. */
149 static char *disassembler_options
= NULL
;
151 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
152 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
154 /* The symbol table. */
155 static asymbol
**syms
;
157 /* Number of symbols in `syms'. */
158 static long symcount
= 0;
160 /* The sorted symbol table. */
161 static asymbol
**sorted_syms
;
163 /* Number of symbols in `sorted_syms'. */
164 static long sorted_symcount
= 0;
166 /* The dynamic symbol table. */
167 static asymbol
**dynsyms
;
169 /* The synthetic symbol table. */
170 static asymbol
*synthsyms
;
171 static long synthcount
= 0;
173 /* Number of symbols in `dynsyms'. */
174 static long dynsymcount
= 0;
176 static bfd_byte
*stabs
;
177 static bfd_size_type stab_size
;
180 static bfd_size_type stabstr_size
;
182 static bfd_boolean is_relocatable
= FALSE
;
185 usage (FILE *stream
, int status
)
187 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
188 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
189 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
190 fprintf (stream
, _("\
191 -a, --archive-headers Display archive header information\n\
192 -f, --file-headers Display the contents of the overall file header\n\
193 -p, --private-headers Display object format specific file header contents\n\
194 -h, --[section-]headers Display the contents of the section headers\n\
195 -x, --all-headers Display the contents of all headers\n\
196 -d, --disassemble Display assembler contents of executable sections\n\
197 -D, --disassemble-all Display assembler contents of all sections\n\
198 -S, --source Intermix source code with disassembly\n\
199 -s, --full-contents Display the full contents of all sections requested\n\
200 -g, --debugging Display debug information in object file\n\
201 -e, --debugging-tags Display debug information using ctags style\n\
202 -G, --stabs Display (in raw form) any STABS info in the file\n\
203 -W[lLiaprmfFsoR] or\n\
204 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
205 Display DWARF info in the file\n\
206 -t, --syms Display the contents of the symbol table(s)\n\
207 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
208 -r, --reloc Display the relocation entries in the file\n\
209 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
210 @<file> Read options from <file>\n\
211 -v, --version Display this program's version number\n\
212 -i, --info List object formats and architectures supported\n\
213 -H, --help Display this information\n\
217 fprintf (stream
, _("\n The following switches are optional:\n"));
218 fprintf (stream
, _("\
219 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
220 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
221 -j, --section=NAME Only display information for section NAME\n\
222 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
223 -EB --endian=big Assume big endian format when disassembling\n\
224 -EL --endian=little Assume little endian format when disassembling\n\
225 --file-start-context Include context from start of file (with -S)\n\
226 -I, --include=DIR Add DIR to search list for source files\n\
227 -l, --line-numbers Include line numbers and filenames in output\n\
228 -F, --file-offsets Include file offsets when displaying information\n\
229 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
230 The STYLE, if specified, can be `auto', `gnu',\n\
231 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
233 -w, --wide Format output for more than 80 columns\n\
234 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
235 --start-address=ADDR Only process data whose address is >= ADDR\n\
236 --stop-address=ADDR Only process data whose address is <= ADDR\n\
237 --prefix-addresses Print complete address alongside disassembly\n\
238 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
239 --insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
240 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
241 --special-syms Include special symbols in symbol dumps\n\
242 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
243 --prefix-strip=LEVEL Strip initial directory names for -S\n\
245 list_supported_targets (program_name
, stream
);
246 list_supported_architectures (program_name
, stream
);
248 disassembler_usage (stream
);
250 if (REPORT_BUGS_TO
[0] && status
== 0)
251 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
255 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
259 OPTION_START_ADDRESS
,
268 static struct option long_options
[]=
270 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
271 {"all-headers", no_argument
, NULL
, 'x'},
272 {"private-headers", no_argument
, NULL
, 'p'},
273 {"architecture", required_argument
, NULL
, 'm'},
274 {"archive-headers", no_argument
, NULL
, 'a'},
275 {"debugging", no_argument
, NULL
, 'g'},
276 {"debugging-tags", no_argument
, NULL
, 'e'},
277 {"demangle", optional_argument
, NULL
, 'C'},
278 {"disassemble", no_argument
, NULL
, 'd'},
279 {"disassemble-all", no_argument
, NULL
, 'D'},
280 {"disassembler-options", required_argument
, NULL
, 'M'},
281 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
282 {"dynamic-reloc", no_argument
, NULL
, 'R'},
283 {"dynamic-syms", no_argument
, NULL
, 'T'},
284 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
285 {"file-headers", no_argument
, NULL
, 'f'},
286 {"file-offsets", no_argument
, NULL
, 'F'},
287 {"file-start-context", no_argument
, &file_start_context
, 1},
288 {"full-contents", no_argument
, NULL
, 's'},
289 {"headers", no_argument
, NULL
, 'h'},
290 {"help", no_argument
, NULL
, 'H'},
291 {"info", no_argument
, NULL
, 'i'},
292 {"line-numbers", no_argument
, NULL
, 'l'},
293 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
294 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
295 {"reloc", no_argument
, NULL
, 'r'},
296 {"section", required_argument
, NULL
, 'j'},
297 {"section-headers", no_argument
, NULL
, 'h'},
298 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
299 {"source", no_argument
, NULL
, 'S'},
300 {"special-syms", no_argument
, &dump_special_syms
, 1},
301 {"include", required_argument
, NULL
, 'I'},
302 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
303 {"stabs", no_argument
, NULL
, 'G'},
304 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
305 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
306 {"syms", no_argument
, NULL
, 't'},
307 {"target", required_argument
, NULL
, 'b'},
308 {"version", no_argument
, NULL
, 'V'},
309 {"wide", no_argument
, NULL
, 'w'},
310 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
311 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
312 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
313 {0, no_argument
, 0, 0}
317 nonfatal (const char *msg
)
324 dump_section_header (bfd
*abfd
, asection
*section
,
325 void *ignored ATTRIBUTE_UNUSED
)
328 unsigned int opb
= bfd_octets_per_byte (abfd
);
330 /* Ignore linker created section. See elfNN_ia64_object_p in
332 if (section
->flags
& SEC_LINKER_CREATED
)
335 printf ("%3d %-13s %08lx ", section
->index
,
336 bfd_get_section_name (abfd
, section
),
337 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
338 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
340 bfd_printf_vma (abfd
, section
->lma
);
341 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
342 bfd_get_section_alignment (abfd
, section
));
348 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
350 PF (SEC_HAS_CONTENTS
, "CONTENTS");
351 PF (SEC_ALLOC
, "ALLOC");
352 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
353 PF (SEC_LOAD
, "LOAD");
354 PF (SEC_RELOC
, "RELOC");
355 PF (SEC_READONLY
, "READONLY");
356 PF (SEC_CODE
, "CODE");
357 PF (SEC_DATA
, "DATA");
359 PF (SEC_DEBUGGING
, "DEBUGGING");
360 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
361 PF (SEC_EXCLUDE
, "EXCLUDE");
362 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
363 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
365 PF (SEC_TIC54X_BLOCK
, "BLOCK");
366 PF (SEC_TIC54X_CLINK
, "CLINK");
368 PF (SEC_SMALL_DATA
, "SMALL_DATA");
369 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
370 PF (SEC_COFF_SHARED
, "SHARED");
371 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
372 PF (SEC_GROUP
, "GROUP");
374 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
377 struct coff_comdat_info
*comdat
;
379 switch (section
->flags
& SEC_LINK_DUPLICATES
)
383 case SEC_LINK_DUPLICATES_DISCARD
:
384 ls
= "LINK_ONCE_DISCARD";
386 case SEC_LINK_DUPLICATES_ONE_ONLY
:
387 ls
= "LINK_ONCE_ONE_ONLY";
389 case SEC_LINK_DUPLICATES_SAME_SIZE
:
390 ls
= "LINK_ONCE_SAME_SIZE";
392 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
393 ls
= "LINK_ONCE_SAME_CONTENTS";
396 printf ("%s%s", comma
, ls
);
398 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
400 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
410 dump_headers (bfd
*abfd
)
412 printf (_("Sections:\n"));
415 printf (_("Idx Name Size VMA LMA File off Algn"));
417 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
418 if (bfd_get_arch_size (abfd
) == 32)
419 printf (_("Idx Name Size VMA LMA File off Algn"));
421 printf (_("Idx Name Size VMA LMA File off Algn"));
425 printf (_(" Flags"));
426 if (abfd
->flags
& HAS_LOAD_PAGE
)
430 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
434 slurp_symtab (bfd
*abfd
)
439 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
445 storage
= bfd_get_symtab_upper_bound (abfd
);
447 bfd_fatal (bfd_get_filename (abfd
));
449 sy
= xmalloc (storage
);
451 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
453 bfd_fatal (bfd_get_filename (abfd
));
457 /* Read in the dynamic symbols. */
460 slurp_dynamic_symtab (bfd
*abfd
)
465 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
468 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
470 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
475 bfd_fatal (bfd_get_filename (abfd
));
478 sy
= xmalloc (storage
);
480 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
482 bfd_fatal (bfd_get_filename (abfd
));
486 /* Filter out (in place) symbols that are useless for disassembly.
487 COUNT is the number of elements in SYMBOLS.
488 Return the number of useful symbols. */
491 remove_useless_symbols (asymbol
**symbols
, long count
)
493 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
497 asymbol
*sym
= *in_ptr
++;
499 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
501 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
503 if (bfd_is_und_section (sym
->section
)
504 || bfd_is_com_section (sym
->section
))
509 return out_ptr
- symbols
;
512 /* Sort symbols into value order. */
515 compare_symbols (const void *ap
, const void *bp
)
517 const asymbol
*a
= * (const asymbol
**) ap
;
518 const asymbol
*b
= * (const asymbol
**) bp
;
528 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
530 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
533 if (a
->section
> b
->section
)
535 else if (a
->section
< b
->section
)
538 an
= bfd_asymbol_name (a
);
539 bn
= bfd_asymbol_name (b
);
543 /* The symbols gnu_compiled and gcc2_compiled convey no real
544 information, so put them after other symbols with the same value. */
545 af
= (strstr (an
, "gnu_compiled") != NULL
546 || strstr (an
, "gcc2_compiled") != NULL
);
547 bf
= (strstr (bn
, "gnu_compiled") != NULL
548 || strstr (bn
, "gcc2_compiled") != NULL
);
555 /* We use a heuristic for the file name, to try to sort it after
556 more useful symbols. It may not work on non Unix systems, but it
557 doesn't really matter; the only difference is precisely which
558 symbol names get printed. */
560 #define file_symbol(s, sn, snl) \
561 (((s)->flags & BSF_FILE) != 0 \
562 || ((sn)[(snl) - 2] == '.' \
563 && ((sn)[(snl) - 1] == 'o' \
564 || (sn)[(snl) - 1] == 'a')))
566 af
= file_symbol (a
, an
, anl
);
567 bf
= file_symbol (b
, bn
, bnl
);
574 /* Try to sort global symbols before local symbols before function
575 symbols before debugging symbols. */
580 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
582 if ((aflags
& BSF_DEBUGGING
) != 0)
587 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
589 if ((aflags
& BSF_FUNCTION
) != 0)
594 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
596 if ((aflags
& BSF_LOCAL
) != 0)
601 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
603 if ((aflags
& BSF_GLOBAL
) != 0)
609 /* Symbols that start with '.' might be section names, so sort them
610 after symbols that don't start with '.'. */
611 if (an
[0] == '.' && bn
[0] != '.')
613 if (an
[0] != '.' && bn
[0] == '.')
616 /* Finally, if we can't distinguish them in any other way, try to
617 get consistent results by sorting the symbols by name. */
618 return strcmp (an
, bn
);
621 /* Sort relocs into address order. */
624 compare_relocs (const void *ap
, const void *bp
)
626 const arelent
*a
= * (const arelent
**) ap
;
627 const arelent
*b
= * (const arelent
**) bp
;
629 if (a
->address
> b
->address
)
631 else if (a
->address
< b
->address
)
634 /* So that associated relocations tied to the same address show up
635 in the correct order, we don't do any further sorting. */
644 /* Print an address (VMA) to the output stream in INFO.
645 If SKIP_ZEROES is TRUE, omit leading zeroes. */
648 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
649 bfd_boolean skip_zeroes
)
653 struct objdump_disasm_info
*aux
;
655 aux
= (struct objdump_disasm_info
*) info
->application_data
;
656 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
661 for (p
= buf
; *p
== '0'; ++p
)
666 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
669 /* Print the name of a symbol. */
672 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
679 name
= bfd_asymbol_name (sym
);
680 if (do_demangle
&& name
[0] != '\0')
682 /* Demangle the name. */
683 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
689 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
697 /* Locate a symbol given a bfd and a section (from INFO->application_data),
698 and a VMA. If INFO->application_data->require_sec is TRUE, then always
699 require the symbol to be in the section. Returns NULL if there is no
700 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
701 of the symbol in sorted_syms. */
704 find_symbol_for_address (bfd_vma vma
,
705 struct disassemble_info
*info
,
708 /* @@ Would it speed things up to cache the last two symbols returned,
709 and maybe their address ranges? For many processors, only one memory
710 operand can be present at a time, so the 2-entry cache wouldn't be
711 constantly churned by code doing heavy memory accesses. */
713 /* Indices in `sorted_syms'. */
715 long max
= sorted_symcount
;
717 struct objdump_disasm_info
*aux
;
721 bfd_boolean want_section
;
723 if (sorted_symcount
< 1)
726 aux
= (struct objdump_disasm_info
*) info
->application_data
;
729 opb
= bfd_octets_per_byte (abfd
);
731 /* Perform a binary search looking for the closest symbol to the
732 required value. We are searching the range (min, max]. */
733 while (min
+ 1 < max
)
737 thisplace
= (max
+ min
) / 2;
738 sym
= sorted_syms
[thisplace
];
740 if (bfd_asymbol_value (sym
) > vma
)
742 else if (bfd_asymbol_value (sym
) < vma
)
751 /* The symbol we want is now in min, the low end of the range we
752 were searching. If there are several symbols with the same
753 value, we want the first one. */
756 && (bfd_asymbol_value (sorted_syms
[thisplace
])
757 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
760 /* Prefer a symbol in the current section if we have multple symbols
761 with the same value, as can occur with overlays or zero size
765 && (bfd_asymbol_value (sorted_syms
[min
])
766 == bfd_asymbol_value (sorted_syms
[thisplace
])))
768 if (sorted_syms
[min
]->section
== sec
769 && info
->symbol_is_valid (sorted_syms
[min
], info
))
776 return sorted_syms
[thisplace
];
781 /* If the file is relocatable, and the symbol could be from this
782 section, prefer a symbol from this section over symbols from
783 others, even if the other symbol's value might be closer.
785 Note that this may be wrong for some symbol references if the
786 sections have overlapping memory ranges, but in that case there's
787 no way to tell what's desired without looking at the relocation
790 Also give the target a chance to reject symbols. */
791 want_section
= (aux
->require_sec
792 || ((abfd
->flags
& HAS_RELOC
) != 0
793 && vma
>= bfd_get_section_vma (abfd
, sec
)
794 && vma
< (bfd_get_section_vma (abfd
, sec
)
795 + bfd_section_size (abfd
, sec
) / opb
)));
796 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
797 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
800 long newplace
= sorted_symcount
;
802 for (i
= min
- 1; i
>= 0; i
--)
804 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
805 && info
->symbol_is_valid (sorted_syms
[i
], info
))
807 if (newplace
== sorted_symcount
)
810 if (bfd_asymbol_value (sorted_syms
[i
])
811 != bfd_asymbol_value (sorted_syms
[newplace
]))
814 /* Remember this symbol and keep searching until we reach
815 an earlier address. */
820 if (newplace
!= sorted_symcount
)
821 thisplace
= newplace
;
824 /* We didn't find a good symbol with a smaller value.
825 Look for one with a larger value. */
826 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
828 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
829 && info
->symbol_is_valid (sorted_syms
[i
], info
))
837 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
838 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
839 /* There is no suitable symbol. */
846 return sorted_syms
[thisplace
];
849 /* Print an address and the offset to the nearest symbol. */
852 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
853 bfd_vma vma
, struct disassemble_info
*info
,
854 bfd_boolean skip_zeroes
)
856 objdump_print_value (vma
, info
, skip_zeroes
);
862 (*info
->fprintf_func
) (info
->stream
, " <%s",
863 bfd_get_section_name (abfd
, sec
));
864 secaddr
= bfd_get_section_vma (abfd
, sec
);
867 (*info
->fprintf_func
) (info
->stream
, "-0x");
868 objdump_print_value (secaddr
- vma
, info
, TRUE
);
870 else if (vma
> secaddr
)
872 (*info
->fprintf_func
) (info
->stream
, "+0x");
873 objdump_print_value (vma
- secaddr
, info
, TRUE
);
875 (*info
->fprintf_func
) (info
->stream
, ">");
879 (*info
->fprintf_func
) (info
->stream
, " <");
880 objdump_print_symname (abfd
, info
, sym
);
881 if (bfd_asymbol_value (sym
) > vma
)
883 (*info
->fprintf_func
) (info
->stream
, "-0x");
884 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
886 else if (vma
> bfd_asymbol_value (sym
))
888 (*info
->fprintf_func
) (info
->stream
, "+0x");
889 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
891 (*info
->fprintf_func
) (info
->stream
, ">");
894 if (display_file_offsets
)
895 info
->fprintf_func (info
->stream
, _(" (File Offset: 0x%lx)"),
896 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
899 /* Print an address (VMA), symbolically if possible.
900 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
903 objdump_print_addr (bfd_vma vma
,
904 struct disassemble_info
*info
,
905 bfd_boolean skip_zeroes
)
907 struct objdump_disasm_info
*aux
;
909 bfd_boolean skip_find
= FALSE
;
911 aux
= (struct objdump_disasm_info
*) info
->application_data
;
913 if (sorted_symcount
< 1)
915 (*info
->fprintf_func
) (info
->stream
, "0x");
916 objdump_print_value (vma
, info
, skip_zeroes
);
918 if (display_file_offsets
)
919 info
->fprintf_func (info
->stream
, _(" (File Offset: 0x%lx)"),
920 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
924 if (aux
->reloc
!= NULL
925 && aux
->reloc
->sym_ptr_ptr
!= NULL
926 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
928 sym
= * aux
->reloc
->sym_ptr_ptr
;
930 /* Adjust the vma to the reloc. */
931 vma
+= bfd_asymbol_value (sym
);
933 if (bfd_is_und_section (bfd_get_section (sym
)))
938 sym
= find_symbol_for_address (vma
, info
, NULL
);
940 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
944 /* Print VMA to INFO. This function is passed to the disassembler
948 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
950 objdump_print_addr (vma
, info
, ! prefix_addresses
);
953 /* Determine if the given address has a symbol associated with it. */
956 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
960 sym
= find_symbol_for_address (vma
, info
, NULL
);
962 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
965 /* Hold the last function name and the last line number we displayed
968 static char *prev_functionname
;
969 static unsigned int prev_line
;
971 /* We keep a list of all files that we have seen when doing a
972 disassembly with source, so that we know how much of the file to
973 display. This can be important for inlined functions. */
975 struct print_file_list
977 struct print_file_list
*next
;
978 const char *filename
;
982 const char **linemap
;
988 static struct print_file_list
*print_files
;
990 /* The number of preceding context lines to show when we start
991 displaying a file for the first time. */
993 #define SHOW_PRECEDING_CONTEXT_LINES (5)
995 /* Read a complete file into memory. */
998 slurp_file (const char *fn
, size_t *size
)
1001 int ps
= getpagesize ();
1006 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1010 if (fstat (fd
, &st
) < 0)
1014 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1015 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1016 if (map
!= (char *)-1L)
1022 map
= malloc (*size
);
1023 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1032 #define line_map_decrease 5
1034 /* Precompute array of lines for a mapped file. */
1036 static const char **
1037 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1039 const char *p
, *lstart
, *end
;
1040 int chars_per_line
= 45; /* First iteration will use 40. */
1041 unsigned int lineno
;
1042 const char **linemap
= NULL
;
1043 unsigned long line_map_size
= 0;
1049 for (p
= map
; p
< end
; p
++)
1053 if (p
+ 1 < end
&& p
[1] == '\r')
1056 else if (*p
== '\r')
1058 if (p
+ 1 < end
&& p
[1] == '\n')
1064 /* End of line found. */
1066 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1068 unsigned long newsize
;
1070 chars_per_line
-= line_map_decrease
;
1071 if (chars_per_line
<= 1)
1073 line_map_size
= size
/ chars_per_line
+ 1;
1074 if (line_map_size
< lineno
+ 1)
1075 line_map_size
= lineno
+ 1;
1076 newsize
= line_map_size
* sizeof (char *);
1077 linemap
= xrealloc (linemap
, newsize
);
1080 linemap
[lineno
++] = lstart
;
1088 /* Tries to open MODNAME, and if successful adds a node to print_files
1089 linked list and returns that node. Returns NULL on failure. */
1091 static struct print_file_list
*
1092 try_print_file_open (const char *origname
, const char *modname
)
1094 struct print_file_list
*p
;
1096 p
= xmalloc (sizeof (struct print_file_list
));
1098 p
->map
= slurp_file (modname
, &p
->mapsize
);
1105 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1107 p
->filename
= origname
;
1108 p
->modname
= modname
;
1109 p
->next
= print_files
;
1115 /* If the the source file, as described in the symtab, is not found
1116 try to locate it in one of the paths specified with -I
1117 If found, add location to print_files linked list. */
1119 static struct print_file_list
*
1120 update_source_path (const char *filename
)
1122 struct print_file_list
*p
;
1126 if (filename
== NULL
)
1129 p
= try_print_file_open (filename
, filename
);
1133 if (include_path_count
== 0)
1136 /* Get the name of the file. */
1137 fname
= strrchr (filename
, '/');
1138 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1140 /* We could have a mixed forward/back slash case. */
1141 char *backslash
= strrchr (filename
, '\\');
1142 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1144 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1145 fname
= filename
+ 1;
1153 /* If file exists under a new path, we need to add it to the list
1154 so that show_line knows about it. */
1155 for (i
= 0; i
< include_path_count
; i
++)
1157 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1159 p
= try_print_file_open (filename
, modname
);
1169 /* Print a source file line. */
1172 print_line (struct print_file_list
*p
, unsigned int line
)
1178 if (line
>= p
->maxline
)
1180 l
= p
->linemap
[line
];
1181 /* Test fwrite return value to quiet glibc warning. */
1182 len
= strcspn (l
, "\n\r");
1183 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1187 /* Print a range of source code lines. */
1190 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1194 while (start
<= end
)
1196 print_line (p
, start
);
1201 /* Show the line number, or the source line, in a disassembly
1205 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1207 const char *filename
;
1208 const char *functionname
;
1212 if (! with_line_numbers
&& ! with_source_code
)
1215 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1216 &functionname
, &line
))
1219 if (filename
!= NULL
&& *filename
== '\0')
1221 if (functionname
!= NULL
&& *functionname
== '\0')
1222 functionname
= NULL
;
1225 && IS_ABSOLUTE_PATH (filename
)
1229 const char *fname
= filename
;
1230 char *path
= (char *) alloca (prefix_length
+ PATH_MAX
+ 1);
1233 memcpy (path
, prefix
, prefix_length
);
1234 path_up
= path
+ prefix_length
;
1236 /* Build relocated filename, stripping off leading directories
1237 from the initial filename if requested. */
1238 if (prefix_strip
> 0)
1243 /* Skip selected directory levels. */
1244 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1245 if (IS_DIR_SEPARATOR(*s
))
1252 /* Update complete filename. */
1253 strncpy (path_up
, fname
, PATH_MAX
);
1254 path_up
[PATH_MAX
] = '\0';
1262 if (with_line_numbers
)
1264 if (functionname
!= NULL
1265 && (prev_functionname
== NULL
1266 || strcmp (functionname
, prev_functionname
) != 0))
1267 printf ("%s():\n", functionname
);
1268 if (line
> 0 && line
!= prev_line
)
1269 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1272 if (with_source_code
1276 struct print_file_list
**pp
, *p
;
1279 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1280 if (strcmp ((*pp
)->filename
, filename
) == 0)
1287 filename
= xstrdup (filename
);
1288 p
= update_source_path (filename
);
1291 if (p
!= NULL
&& line
!= p
->last_line
)
1293 if (file_start_context
&& p
->first
)
1297 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1300 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1301 l
= p
->last_line
+ 1;
1303 dump_lines (p
, l
, line
);
1304 p
->last_line
= line
;
1309 if (functionname
!= NULL
1310 && (prev_functionname
== NULL
1311 || strcmp (functionname
, prev_functionname
) != 0))
1313 if (prev_functionname
!= NULL
)
1314 free (prev_functionname
);
1315 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1316 strcpy (prev_functionname
, functionname
);
1319 if (line
> 0 && line
!= prev_line
)
1323 /* Pseudo FILE object for strings. */
1331 /* sprintf to a "stream". */
1333 static int ATTRIBUTE_PRINTF_2
1334 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1341 size_t space
= f
->alloc
- f
->pos
;
1343 va_start (args
, format
);
1344 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1350 f
->alloc
= (f
->alloc
+ n
) * 2;
1351 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1358 /* Returns TRUE if the specified section should be dumped. */
1361 process_section_p (asection
* section
)
1368 for (i
= 0; i
< only_used
; i
++)
1369 if (strcmp (only
[i
], section
->name
) == 0)
1376 /* The number of zeroes we want to see before we start skipping them.
1377 The number is arbitrarily chosen. */
1379 #define DEFAULT_SKIP_ZEROES 8
1381 /* The number of zeroes to skip at the end of a section. If the
1382 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1383 SKIP_ZEROES, they will be disassembled. If there are fewer than
1384 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1385 attempt to avoid disassembling zeroes inserted by section
1388 #define DEFAULT_SKIP_ZEROES_AT_END 3
1390 /* Disassemble some data in memory between given values. */
1393 disassemble_bytes (struct disassemble_info
* info
,
1394 disassembler_ftype disassemble_fn
,
1397 bfd_vma start_offset
,
1398 bfd_vma stop_offset
,
1401 arelent
** relppend
)
1403 struct objdump_disasm_info
*aux
;
1405 int octets_per_line
;
1406 bfd_boolean done_dot
;
1407 int skip_addr_chars
;
1408 bfd_vma addr_offset
;
1409 unsigned int opb
= info
->octets_per_byte
;
1410 unsigned int skip_zeroes
= info
->skip_zeroes
;
1411 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1415 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1419 sfile
.buffer
= xmalloc (sfile
.alloc
);
1423 octets_per_line
= insn_width
;
1425 octets_per_line
= 4;
1427 octets_per_line
= 16;
1429 /* Figure out how many characters to skip at the start of an
1430 address, to make the disassembly look nicer. We discard leading
1431 zeroes in chunks of 4, ensuring that there is always a leading
1433 skip_addr_chars
= 0;
1434 if (! prefix_addresses
)
1438 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1440 while (buf
[skip_addr_chars
] == '0')
1443 /* Don't discard zeros on overflow. */
1444 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1445 skip_addr_chars
= 0;
1447 if (skip_addr_chars
!= 0)
1448 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1451 info
->insn_info_valid
= 0;
1454 addr_offset
= start_offset
;
1455 while (addr_offset
< stop_offset
)
1458 bfd_boolean need_nl
= FALSE
;
1459 int previous_octets
;
1461 /* Remember the length of the previous instruction. */
1462 previous_octets
= octets
;
1465 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1467 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1470 if (! disassemble_zeroes
1471 && (info
->insn_info_valid
== 0
1472 || info
->branch_delay_insns
== 0)
1473 && (z
- addr_offset
* opb
>= skip_zeroes
1474 || (z
== stop_offset
* opb
&&
1475 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1477 /* If there are more nonzero octets to follow, we only skip
1478 zeroes in multiples of 4, to try to avoid running over
1479 the start of an instruction which happens to start with
1481 if (z
!= stop_offset
* opb
)
1482 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1484 octets
= z
- addr_offset
* opb
;
1486 /* If we are going to display more data, and we are displaying
1487 file offsets, then tell the user how many zeroes we skip
1488 and the file offset from where we resume dumping. */
1489 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1490 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1492 (unsigned long) (section
->filepos
1493 + (addr_offset
+ (octets
/ opb
))));
1505 if (with_line_numbers
|| with_source_code
)
1506 show_line (aux
->abfd
, section
, addr_offset
);
1508 if (! prefix_addresses
)
1512 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1513 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1517 printf ("%s:\t", buf
+ skip_addr_chars
);
1521 aux
->require_sec
= TRUE
;
1522 objdump_print_address (section
->vma
+ addr_offset
, info
);
1523 aux
->require_sec
= FALSE
;
1530 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1531 info
->stream
= &sfile
;
1532 info
->bytes_per_line
= 0;
1533 info
->bytes_per_chunk
= 0;
1534 info
->flags
= disassemble_all
? DISASSEMBLE_DATA
: 0;
1536 info
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1538 if (info
->disassembler_needs_relocs
1539 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1540 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1541 && *relppp
< relppend
)
1543 bfd_signed_vma distance_to_rel
;
1545 distance_to_rel
= (**relppp
)->address
1546 - (rel_offset
+ addr_offset
);
1548 /* Check to see if the current reloc is associated with
1549 the instruction that we are about to disassemble. */
1550 if (distance_to_rel
== 0
1551 /* FIXME: This is wrong. We are trying to catch
1552 relocs that are addressed part way through the
1553 current instruction, as might happen with a packed
1554 VLIW instruction. Unfortunately we do not know the
1555 length of the current instruction since we have not
1556 disassembled it yet. Instead we take a guess based
1557 upon the length of the previous instruction. The
1558 proper solution is to have a new target-specific
1559 disassembler function which just returns the length
1560 of an instruction at a given address without trying
1561 to display its disassembly. */
1562 || (distance_to_rel
> 0
1563 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1565 info
->flags
|= INSN_HAS_RELOC
;
1566 aux
->reloc
= **relppp
;
1572 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1573 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1574 info
->stream
= stdout
;
1575 if (insn_width
== 0 && info
->bytes_per_line
!= 0)
1576 octets_per_line
= info
->bytes_per_line
;
1580 printf ("%s\n", sfile
.buffer
);
1588 octets
= octets_per_line
;
1589 if (addr_offset
+ octets
/ opb
> stop_offset
)
1590 octets
= (stop_offset
- addr_offset
) * opb
;
1592 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1594 if (ISPRINT (data
[j
]))
1595 buf
[j
- addr_offset
* opb
] = data
[j
];
1597 buf
[j
- addr_offset
* opb
] = '.';
1599 buf
[j
- addr_offset
* opb
] = '\0';
1602 if (prefix_addresses
1604 : show_raw_insn
>= 0)
1608 /* If ! prefix_addresses and ! wide_output, we print
1609 octets_per_line octets per line. */
1611 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1612 pb
= octets_per_line
;
1614 if (info
->bytes_per_chunk
)
1615 bpc
= info
->bytes_per_chunk
;
1619 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1623 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1625 for (k
= bpc
- 1; k
>= 0; k
--)
1626 printf ("%02x", (unsigned) data
[j
+ k
]);
1631 for (k
= 0; k
< bpc
; k
++)
1632 printf ("%02x", (unsigned) data
[j
+ k
]);
1637 for (; pb
< octets_per_line
; pb
+= bpc
)
1641 for (k
= 0; k
< bpc
; k
++)
1646 /* Separate raw data from instruction by extra space. */
1656 printf ("%s", sfile
.buffer
);
1658 if (prefix_addresses
1660 : show_raw_insn
>= 0)
1668 j
= addr_offset
* opb
+ pb
;
1670 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1671 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1675 printf ("%s:\t", buf
+ skip_addr_chars
);
1677 pb
+= octets_per_line
;
1680 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1684 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1686 for (k
= bpc
- 1; k
>= 0; k
--)
1687 printf ("%02x", (unsigned) data
[j
+ k
]);
1692 for (k
= 0; k
< bpc
; k
++)
1693 printf ("%02x", (unsigned) data
[j
+ k
]);
1706 while ((*relppp
) < relppend
1707 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1709 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1720 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1723 if (q
->howto
== NULL
)
1724 printf (": *unknown*\t");
1725 else if (q
->howto
->name
)
1726 printf (": %s\t", q
->howto
->name
);
1728 printf (": %d\t", q
->howto
->type
);
1730 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1731 printf ("*unknown*");
1734 const char *sym_name
;
1736 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1737 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1738 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1743 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1744 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1745 if (sym_name
== NULL
|| *sym_name
== '\0')
1746 sym_name
= "*unknown*";
1747 printf ("%s", sym_name
);
1754 objdump_print_value (q
->addend
, info
, TRUE
);
1766 addr_offset
+= octets
/ opb
;
1769 free (sfile
.buffer
);
1773 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1775 const struct elf_backend_data
* bed
;
1776 bfd_vma sign_adjust
= 0;
1777 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1778 struct objdump_disasm_info
* paux
;
1779 unsigned int opb
= pinfo
->octets_per_byte
;
1780 bfd_byte
* data
= NULL
;
1781 bfd_size_type datasize
= 0;
1782 arelent
** rel_pp
= NULL
;
1783 arelent
** rel_ppstart
= NULL
;
1784 arelent
** rel_ppend
;
1785 unsigned long stop_offset
;
1786 asymbol
* sym
= NULL
;
1790 unsigned long addr_offset
;
1792 /* Sections that do not contain machine
1793 code are not normally disassembled. */
1794 if (! disassemble_all
1796 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1797 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1800 if (! process_section_p (section
))
1803 datasize
= bfd_get_section_size (section
);
1807 /* Decide which set of relocs to use. Load them if necessary. */
1808 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1809 if (paux
->dynrelbuf
)
1811 rel_pp
= paux
->dynrelbuf
;
1812 rel_count
= paux
->dynrelcount
;
1813 /* Dynamic reloc addresses are absolute, non-dynamic are section
1814 relative. REL_OFFSET specifies the reloc address corresponding
1815 to the start of this section. */
1816 rel_offset
= section
->vma
;
1824 if ((section
->flags
& SEC_RELOC
) != 0
1825 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1829 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1831 bfd_fatal (bfd_get_filename (abfd
));
1835 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1836 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1838 bfd_fatal (bfd_get_filename (abfd
));
1840 /* Sort the relocs by address. */
1841 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1845 rel_ppend
= rel_pp
+ rel_count
;
1847 data
= xmalloc (datasize
);
1849 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1851 paux
->sec
= section
;
1852 pinfo
->buffer
= data
;
1853 pinfo
->buffer_vma
= section
->vma
;
1854 pinfo
->buffer_length
= datasize
;
1855 pinfo
->section
= section
;
1857 if (start_address
== (bfd_vma
) -1
1858 || start_address
< pinfo
->buffer_vma
)
1861 addr_offset
= start_address
- pinfo
->buffer_vma
;
1863 if (stop_address
== (bfd_vma
) -1)
1864 stop_offset
= datasize
/ opb
;
1867 if (stop_address
< pinfo
->buffer_vma
)
1870 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1871 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1872 stop_offset
= pinfo
->buffer_length
/ opb
;
1875 /* Skip over the relocs belonging to addresses below the
1877 while (rel_pp
< rel_ppend
1878 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1881 if (addr_offset
< stop_offset
)
1882 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1884 /* Find the nearest symbol forwards from our current position. */
1885 paux
->require_sec
= TRUE
;
1886 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1887 paux
->require_sec
= FALSE
;
1889 /* PR 9774: If the target used signed 32-bit addresses then we must make
1890 sure that we sign extend the value that we calculate for 'addr' in the
1892 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1893 && (bed
= get_elf_backend_data (abfd
)) != NULL
1894 && bed
->sign_extend_vma
)
1895 sign_adjust
= 0x80000000;
1897 /* Disassemble a block of instructions up to the address associated with
1898 the symbol we have just found. Then print the symbol and find the
1899 next symbol on. Repeat until we have disassembled the entire section
1900 or we have reached the end of the address range we are interested in. */
1901 while (addr_offset
< stop_offset
)
1905 unsigned long nextstop_offset
;
1908 addr
= section
->vma
+ addr_offset
;
1909 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
1911 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1916 (x
< sorted_symcount
1917 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1921 pinfo
->symbols
= sorted_syms
+ place
;
1922 pinfo
->num_symbols
= x
- place
;
1923 pinfo
->symtab_pos
= place
;
1927 pinfo
->symbols
= NULL
;
1928 pinfo
->num_symbols
= 0;
1929 pinfo
->symtab_pos
= -1;
1932 if (! prefix_addresses
)
1934 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1935 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1937 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1940 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1942 else if (sym
== NULL
)
1946 #define is_valid_next_sym(SYM) \
1947 ((SYM)->section == section \
1948 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1949 && pinfo->symbol_is_valid (SYM, pinfo))
1951 /* Search forward for the next appropriate symbol in
1952 SECTION. Note that all the symbols are sorted
1953 together into one big array, and that some sections
1954 may have overlapping addresses. */
1955 while (place
< sorted_symcount
1956 && ! is_valid_next_sym (sorted_syms
[place
]))
1959 if (place
>= sorted_symcount
)
1962 nextsym
= sorted_syms
[place
];
1965 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1966 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1967 else if (nextsym
== NULL
)
1968 nextstop_offset
= stop_offset
;
1970 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1972 if (nextstop_offset
> stop_offset
1973 || nextstop_offset
<= addr_offset
)
1974 nextstop_offset
= stop_offset
;
1976 /* If a symbol is explicitly marked as being an object
1977 rather than a function, just dump the bytes without
1978 disassembling them. */
1981 || sym
->section
!= section
1982 || bfd_asymbol_value (sym
) > addr
1983 || ((sym
->flags
& BSF_OBJECT
) == 0
1984 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1986 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1988 || (sym
->flags
& BSF_FUNCTION
) != 0)
1993 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1994 addr_offset
, nextstop_offset
,
1995 rel_offset
, &rel_pp
, rel_ppend
);
1997 addr_offset
= nextstop_offset
;
2003 if (rel_ppstart
!= NULL
)
2007 /* Disassemble the contents of an object file. */
2010 disassemble_data (bfd
*abfd
)
2012 struct disassemble_info disasm_info
;
2013 struct objdump_disasm_info aux
;
2017 prev_functionname
= NULL
;
2020 /* We make a copy of syms to sort. We don't want to sort syms
2021 because that will screw up the relocs. */
2022 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2023 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
2024 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2025 sorted_symcount
* sizeof (asymbol
*));
2027 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2029 for (i
= 0; i
< synthcount
; ++i
)
2031 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2035 /* Sort the symbols into section and symbol order. */
2036 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2038 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2040 disasm_info
.application_data
= (void *) &aux
;
2042 aux
.require_sec
= FALSE
;
2043 aux
.dynrelbuf
= NULL
;
2044 aux
.dynrelcount
= 0;
2047 disasm_info
.print_address_func
= objdump_print_address
;
2048 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2050 if (machine
!= NULL
)
2052 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
2055 fatal (_("Can't use supplied machine %s"), machine
);
2057 abfd
->arch_info
= info
;
2060 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2062 struct bfd_target
*xvec
;
2064 xvec
= xmalloc (sizeof (struct bfd_target
));
2065 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2066 xvec
->byteorder
= endian
;
2070 /* Use libopcodes to locate a suitable disassembler. */
2071 aux
.disassemble_fn
= disassembler (abfd
);
2072 if (!aux
.disassemble_fn
)
2074 non_fatal (_("Can't disassemble for architecture %s\n"),
2075 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2080 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2081 disasm_info
.arch
= bfd_get_arch (abfd
);
2082 disasm_info
.mach
= bfd_get_mach (abfd
);
2083 disasm_info
.disassembler_options
= disassembler_options
;
2084 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2085 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2086 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2087 disasm_info
.disassembler_needs_relocs
= FALSE
;
2089 if (bfd_big_endian (abfd
))
2090 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2091 else if (bfd_little_endian (abfd
))
2092 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2094 /* ??? Aborting here seems too drastic. We could default to big or little
2096 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2098 /* Allow the target to customize the info structure. */
2099 disassemble_init_for_target (& disasm_info
);
2101 /* Pre-load the dynamic relocs if we are going
2102 to be dumping them along with the disassembly. */
2103 if (dump_dynamic_reloc_info
)
2105 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2108 bfd_fatal (bfd_get_filename (abfd
));
2112 aux
.dynrelbuf
= xmalloc (relsize
);
2113 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2116 if (aux
.dynrelcount
< 0)
2117 bfd_fatal (bfd_get_filename (abfd
));
2119 /* Sort the relocs by address. */
2120 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2124 disasm_info
.symtab
= sorted_syms
;
2125 disasm_info
.symtab_size
= sorted_symcount
;
2127 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2129 if (aux
.dynrelbuf
!= NULL
)
2130 free (aux
.dynrelbuf
);
2135 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2136 asection
*sec
, void *file
)
2138 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2141 int section_is_compressed
;
2143 /* If it is already loaded, do nothing. */
2144 if (section
->start
!= NULL
)
2147 section_is_compressed
= section
->name
== section
->compressed_name
;
2149 section
->address
= 0;
2150 section
->size
= bfd_get_section_size (sec
);
2151 section
->start
= xmalloc (section
->size
);
2153 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2154 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2159 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2164 free_debug_section (debug
);
2165 printf (_("\nCan't get contents for section '%s'.\n"),
2170 if (section_is_compressed
)
2172 bfd_size_type size
= section
->size
;
2173 if (! bfd_uncompress_section_contents (§ion
->start
, &size
))
2175 free_debug_section (debug
);
2176 printf (_("\nCan't uncompress section '%s'.\n"), section
->name
);
2179 section
->size
= size
;
2186 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2188 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2192 /* If it is already loaded, do nothing. */
2193 if (section
->start
!= NULL
)
2196 /* Locate the debug section. */
2197 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2199 section
->name
= section
->uncompressed_name
;
2202 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2204 section
->name
= section
->compressed_name
;
2209 return load_specific_debug_section (debug
, sec
, file
);
2213 free_debug_section (enum dwarf_section_display_enum debug
)
2215 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2217 if (section
->start
== NULL
)
2220 free ((char *) section
->start
);
2221 section
->start
= NULL
;
2222 section
->address
= 0;
2227 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2228 void *arg ATTRIBUTE_UNUSED
)
2230 const char *name
= bfd_get_section_name (abfd
, section
);
2232 enum dwarf_section_display_enum i
;
2234 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2235 match
= ".debug_info";
2239 for (i
= 0; i
< max
; i
++)
2240 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2241 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2242 && debug_displays
[i
].enabled
!= NULL
2243 && *debug_displays
[i
].enabled
)
2245 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2247 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2248 sec
->name
= sec
->uncompressed_name
;
2250 sec
->name
= sec
->compressed_name
;
2251 if (load_specific_debug_section (i
, section
, abfd
))
2253 debug_displays
[i
].display (sec
, abfd
);
2255 if (i
!= info
&& i
!= abbrev
)
2256 free_debug_section (i
);
2262 /* Dump the dwarf debugging information. */
2265 dump_dwarf (bfd
*abfd
)
2267 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2269 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2270 targets will return 64. */
2271 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2273 if (bfd_big_endian (abfd
))
2274 byte_get
= byte_get_big_endian
;
2275 else if (bfd_little_endian (abfd
))
2276 byte_get
= byte_get_little_endian
;
2280 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2282 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2283 init_dwarf_regnames (bed
->elf_machine_code
);
2286 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2288 free_debug_memory ();
2291 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2292 it. Return NULL on failure. */
2295 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2301 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2302 if (stabsect
== NULL
)
2304 printf (_("No %s section present\n\n"), sect_name
);
2308 size
= bfd_section_size (abfd
, stabsect
);
2309 contents
= xmalloc (size
);
2311 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2313 non_fatal (_("Reading %s section of %s failed: %s"),
2314 sect_name
, bfd_get_filename (abfd
),
2315 bfd_errmsg (bfd_get_error ()));
2326 /* Stabs entries use a 12 byte format:
2327 4 byte string table index
2329 1 byte stab other field
2330 2 byte stab desc field
2332 FIXME: This will have to change for a 64 bit object format. */
2334 #define STRDXOFF (0)
2336 #define OTHEROFF (5)
2339 #define STABSIZE (12)
2341 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2342 using string table section STRSECT_NAME (in `strtab'). */
2345 print_section_stabs (bfd
*abfd
,
2346 const char *stabsect_name
,
2347 unsigned *string_offset_ptr
)
2350 unsigned file_string_table_offset
= 0;
2351 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2352 bfd_byte
*stabp
, *stabs_end
;
2355 stabs_end
= stabp
+ stab_size
;
2357 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2358 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2360 /* Loop through all symbols and print them.
2362 We start the index at -1 because there is a dummy symbol on
2363 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2364 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2368 unsigned char type
, other
;
2369 unsigned short desc
;
2372 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2373 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2374 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2375 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2376 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2378 printf ("\n%-6d ", i
);
2379 /* Either print the stab name, or, if unnamed, print its number
2380 again (makes consistent formatting for tools like awk). */
2381 name
= bfd_get_stab_name (type
);
2383 printf ("%-6s", name
);
2384 else if (type
== N_UNDF
)
2387 printf ("%-6d", type
);
2388 printf (" %-6d %-6d ", other
, desc
);
2389 bfd_printf_vma (abfd
, value
);
2390 printf (" %-6lu", strx
);
2392 /* Symbols with type == 0 (N_UNDF) specify the length of the
2393 string table associated with this file. We use that info
2394 to know how to relocate the *next* file's string table indices. */
2397 file_string_table_offset
= next_file_string_table_offset
;
2398 next_file_string_table_offset
+= value
;
2402 /* Using the (possibly updated) string table offset, print the
2403 string (if any) associated with this symbol. */
2404 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2405 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2411 *string_offset_ptr
= next_file_string_table_offset
;
2416 const char * section_name
;
2417 const char * string_section_name
;
2418 unsigned string_offset
;
2423 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2426 stab_section_names
* sought
= (stab_section_names
*) names
;
2428 /* Check for section names for which stabsect_name is a prefix, to
2429 handle .stab.N, etc. */
2430 len
= strlen (sought
->section_name
);
2432 /* If the prefix matches, and the files section name ends with a
2433 nul or a digit, then we match. I.e., we want either an exact
2434 match or a section followed by a number. */
2435 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2436 && (section
->name
[len
] == 0
2437 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2440 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2445 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2448 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2454 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2456 stab_section_names s
;
2458 s
.section_name
= stabsect_name
;
2459 s
.string_section_name
= strsect_name
;
2460 s
.string_offset
= 0;
2462 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2468 /* Dump the any sections containing stabs debugging information. */
2471 dump_stabs (bfd
*abfd
)
2473 dump_stabs_section (abfd
, ".stab", ".stabstr");
2474 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2475 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2478 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2480 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2484 dump_bfd_header (bfd
*abfd
)
2488 printf (_("architecture: %s, "),
2489 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2490 bfd_get_mach (abfd
)));
2491 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2493 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2494 PF (HAS_RELOC
, "HAS_RELOC");
2495 PF (EXEC_P
, "EXEC_P");
2496 PF (HAS_LINENO
, "HAS_LINENO");
2497 PF (HAS_DEBUG
, "HAS_DEBUG");
2498 PF (HAS_SYMS
, "HAS_SYMS");
2499 PF (HAS_LOCALS
, "HAS_LOCALS");
2500 PF (DYNAMIC
, "DYNAMIC");
2501 PF (WP_TEXT
, "WP_TEXT");
2502 PF (D_PAGED
, "D_PAGED");
2503 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2504 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2505 printf (_("\nstart address 0x"));
2506 bfd_printf_vma (abfd
, abfd
->start_address
);
2512 dump_bfd_private_header (bfd
*abfd
)
2514 bfd_print_private_bfd_data (abfd
, stdout
);
2518 /* Display a section in hexadecimal format with associated characters.
2519 Each line prefixed by the zero padded address. */
2522 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2525 bfd_size_type datasize
;
2526 bfd_size_type addr_offset
;
2527 bfd_size_type start_offset
;
2528 bfd_size_type stop_offset
;
2529 unsigned int opb
= bfd_octets_per_byte (abfd
);
2530 /* Bytes per line. */
2531 const int onaline
= 16;
2536 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2539 if (! process_section_p (section
))
2542 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2545 /* Compute the address range to display. */
2546 if (start_address
== (bfd_vma
) -1
2547 || start_address
< section
->vma
)
2550 start_offset
= start_address
- section
->vma
;
2552 if (stop_address
== (bfd_vma
) -1)
2553 stop_offset
= datasize
/ opb
;
2556 if (stop_address
< section
->vma
)
2559 stop_offset
= stop_address
- section
->vma
;
2561 if (stop_offset
> datasize
/ opb
)
2562 stop_offset
= datasize
/ opb
;
2565 if (start_offset
>= stop_offset
)
2568 printf (_("Contents of section %s:"), section
->name
);
2569 if (display_file_offsets
)
2570 printf (_(" (Starting at file offset: 0x%lx)"),
2571 (unsigned long) (section
->filepos
+ start_offset
));
2574 data
= xmalloc (datasize
);
2576 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2580 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2581 if (strlen (buf
) >= sizeof (buf
))
2585 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2587 count
= strlen (buf
) - count
;
2591 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2592 if (strlen (buf
) >= sizeof (buf
))
2596 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2598 count
= strlen (buf
) - count
;
2602 for (addr_offset
= start_offset
;
2603 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2607 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2608 count
= strlen (buf
);
2609 if ((size_t) count
>= sizeof (buf
))
2613 while (count
< width
)
2618 fputs (buf
+ count
- width
, stdout
);
2621 for (j
= addr_offset
* opb
;
2622 j
< addr_offset
* opb
+ onaline
; j
++)
2624 if (j
< stop_offset
* opb
)
2625 printf ("%02x", (unsigned) (data
[j
]));
2633 for (j
= addr_offset
* opb
;
2634 j
< addr_offset
* opb
+ onaline
; j
++)
2636 if (j
>= stop_offset
* opb
)
2639 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2646 /* Actually display the various requested regions. */
2649 dump_data (bfd
*abfd
)
2651 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2654 /* Should perhaps share code and display with nm? */
2657 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2667 printf ("DYNAMIC SYMBOL TABLE:\n");
2673 printf ("SYMBOL TABLE:\n");
2677 printf (_("no symbols\n"));
2679 for (count
= 0; count
< max
; count
++)
2683 if (*current
== NULL
)
2684 printf (_("no information for symbol number %ld\n"), count
);
2686 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2687 printf (_("could not determine the type of symbol number %ld\n"),
2690 else if (process_section_p ((* current
)->section
)
2691 && (dump_special_syms
2692 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2694 const char *name
= (*current
)->name
;
2696 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2700 /* If we want to demangle the name, we demangle it
2701 here, and temporarily clobber it while calling
2702 bfd_print_symbol. FIXME: This is a gross hack. */
2703 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2705 (*current
)->name
= alloc
;
2706 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2707 bfd_print_symbol_all
);
2710 (*current
)->name
= name
;
2715 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2716 bfd_print_symbol_all
);
2726 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2729 char *last_filename
, *last_functionname
;
2730 unsigned int last_line
;
2732 /* Get column headers lined up reasonably. */
2740 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2741 width
= strlen (buf
) - 7;
2743 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2746 last_filename
= NULL
;
2747 last_functionname
= NULL
;
2750 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2753 const char *filename
, *functionname
;
2755 const char *sym_name
;
2756 const char *section_name
;
2758 if (start_address
!= (bfd_vma
) -1
2759 && q
->address
< start_address
)
2761 if (stop_address
!= (bfd_vma
) -1
2762 && q
->address
> stop_address
)
2765 if (with_line_numbers
2767 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2768 &filename
, &functionname
, &line
))
2770 if (functionname
!= NULL
2771 && (last_functionname
== NULL
2772 || strcmp (functionname
, last_functionname
) != 0))
2774 printf ("%s():\n", functionname
);
2775 if (last_functionname
!= NULL
)
2776 free (last_functionname
);
2777 last_functionname
= xstrdup (functionname
);
2781 && (line
!= last_line
2782 || (filename
!= NULL
2783 && last_filename
!= NULL
2784 && strcmp (filename
, last_filename
) != 0)))
2786 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2788 if (last_filename
!= NULL
)
2789 free (last_filename
);
2790 if (filename
== NULL
)
2791 last_filename
= NULL
;
2793 last_filename
= xstrdup (filename
);
2797 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2799 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2800 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2805 section_name
= NULL
;
2808 bfd_printf_vma (abfd
, q
->address
);
2809 if (q
->howto
== NULL
)
2810 printf (" *unknown* ");
2811 else if (q
->howto
->name
)
2812 printf (" %-16s ", q
->howto
->name
);
2814 printf (" %-16d ", q
->howto
->type
);
2818 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2822 if (section_name
== NULL
)
2823 section_name
= "*unknown*";
2824 printf ("[%s]", section_name
);
2830 bfd_printf_vma (abfd
, q
->addend
);
2838 dump_relocs_in_section (bfd
*abfd
,
2840 void *dummy ATTRIBUTE_UNUSED
)
2846 if ( bfd_is_abs_section (section
)
2847 || bfd_is_und_section (section
)
2848 || bfd_is_com_section (section
)
2849 || (! process_section_p (section
))
2850 || ((section
->flags
& SEC_RELOC
) == 0))
2853 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2855 bfd_fatal (bfd_get_filename (abfd
));
2857 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2861 printf (" (none)\n\n");
2865 relpp
= xmalloc (relsize
);
2866 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2869 bfd_fatal (bfd_get_filename (abfd
));
2870 else if (relcount
== 0)
2871 printf (" (none)\n\n");
2875 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2882 dump_relocs (bfd
*abfd
)
2884 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2888 dump_dynamic_relocs (bfd
*abfd
)
2894 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2896 bfd_fatal (bfd_get_filename (abfd
));
2898 printf ("DYNAMIC RELOCATION RECORDS");
2901 printf (" (none)\n\n");
2904 relpp
= xmalloc (relsize
);
2905 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2908 bfd_fatal (bfd_get_filename (abfd
));
2909 else if (relcount
== 0)
2910 printf (" (none)\n\n");
2914 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2921 /* Creates a table of paths, to search for source files. */
2924 add_include_path (const char *path
)
2928 include_path_count
++;
2929 include_paths
= xrealloc (include_paths
,
2930 include_path_count
* sizeof (*include_paths
));
2931 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2932 if (path
[1] == ':' && path
[2] == 0)
2933 path
= concat (path
, ".", (const char *) 0);
2935 include_paths
[include_path_count
- 1] = path
;
2939 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2943 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2945 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2946 section
->vma
+= adjust_section_vma
;
2948 section
->lma
+= adjust_section_vma
;
2952 /* Dump selected contents of ABFD. */
2955 dump_bfd (bfd
*abfd
)
2957 /* If we are adjusting section VMA's, change them all now. Changing
2958 the BFD information is a hack. However, we must do it, or
2959 bfd_find_nearest_line will not do the right thing. */
2960 if (adjust_section_vma
!= 0)
2962 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2963 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2966 if (! dump_debugging_tags
)
2967 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2970 print_arelt_descr (stdout
, abfd
, TRUE
);
2971 if (dump_file_header
)
2972 dump_bfd_header (abfd
);
2973 if (dump_private_headers
)
2974 dump_bfd_private_header (abfd
);
2975 if (! dump_debugging_tags
)
2977 if (dump_section_headers
)
2978 dump_headers (abfd
);
2984 || dump_dwarf_section_info
)
2985 syms
= slurp_symtab (abfd
);
2986 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2987 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2988 dynsyms
= slurp_dynamic_symtab (abfd
);
2991 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2992 dynsymcount
, dynsyms
, &synthsyms
);
2998 dump_symbols (abfd
, FALSE
);
2999 if (dump_dynamic_symtab
)
3000 dump_symbols (abfd
, TRUE
);
3001 if (dump_dwarf_section_info
)
3003 if (dump_stab_section_info
)
3005 if (dump_reloc_info
&& ! disassemble
)
3007 if (dump_dynamic_reloc_info
&& ! disassemble
)
3008 dump_dynamic_relocs (abfd
);
3009 if (dump_section_contents
)
3012 disassemble_data (abfd
);
3018 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3019 if (dhandle
!= NULL
)
3021 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3023 dump_debugging_tags
? TRUE
: FALSE
))
3025 non_fatal (_("%s: printing debugging information failed"),
3026 bfd_get_filename (abfd
));
3030 /* PR 6483: If there was no STABS or IEEE debug
3031 info in the file, try DWARF instead. */
3032 else if (! dump_dwarf_section_info
)
3062 display_bfd (bfd
*abfd
)
3066 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3072 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3074 nonfatal (bfd_get_filename (abfd
));
3075 list_matching_formats (matching
);
3080 if (bfd_get_error () != bfd_error_file_not_recognized
)
3082 nonfatal (bfd_get_filename (abfd
));
3086 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3092 nonfatal (bfd_get_filename (abfd
));
3094 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3096 list_matching_formats (matching
);
3102 display_file (char *filename
, char *target
)
3107 if (get_file_size (filename
) < 1)
3113 file
= bfd_openr (filename
, target
);
3116 nonfatal (filename
);
3120 /* If the file is an archive, process all of its elements. */
3121 if (bfd_check_format (file
, bfd_archive
))
3123 bfd
*last_arfile
= NULL
;
3125 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3128 bfd_set_error (bfd_error_no_error
);
3130 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3133 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3134 nonfatal (bfd_get_filename (file
));
3138 display_bfd (arfile
);
3140 if (last_arfile
!= NULL
)
3141 bfd_close (last_arfile
);
3142 last_arfile
= arfile
;
3145 if (last_arfile
!= NULL
)
3146 bfd_close (last_arfile
);
3155 main (int argc
, char **argv
)
3158 char *target
= default_target
;
3159 bfd_boolean seenflag
= FALSE
;
3161 #if defined (HAVE_SETLOCALE)
3162 #if defined (HAVE_LC_MESSAGES)
3163 setlocale (LC_MESSAGES
, "");
3165 setlocale (LC_CTYPE
, "");
3168 bindtextdomain (PACKAGE
, LOCALEDIR
);
3169 textdomain (PACKAGE
);
3171 program_name
= *argv
;
3172 xmalloc_set_program_name (program_name
);
3174 START_PROGRESS (program_name
, 0);
3176 expandargv (&argc
, &argv
);
3179 set_default_bfd_target ();
3181 while ((c
= getopt_long (argc
, argv
,
3182 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3183 long_options
, (int *) 0))
3189 break; /* We've been given a long option. */
3194 if (disassembler_options
)
3195 /* Ignore potential memory leak for now. */
3196 disassembler_options
= concat (disassembler_options
, ",",
3197 optarg
, (const char *) NULL
);
3199 disassembler_options
= optarg
;
3202 if (only_used
== only_size
)
3205 only
= xrealloc (only
, only_size
* sizeof (char *));
3207 only
[only_used
++] = optarg
;
3210 display_file_offsets
= TRUE
;
3213 with_line_numbers
= TRUE
;
3222 enum demangling_styles style
;
3224 style
= cplus_demangle_name_to_style (optarg
);
3225 if (style
== unknown_demangling
)
3226 fatal (_("unknown demangling style `%s'"),
3229 cplus_demangle_set_style (style
);
3235 case OPTION_ADJUST_VMA
:
3236 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3238 case OPTION_START_ADDRESS
:
3239 start_address
= parse_vma (optarg
, "--start-address");
3240 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3241 fatal (_("error: the start address should be before the end address"));
3243 case OPTION_STOP_ADDRESS
:
3244 stop_address
= parse_vma (optarg
, "--stop-address");
3245 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3246 fatal (_("error: the stop address should be after the start address"));
3250 prefix_length
= strlen (prefix
);
3251 /* Remove an unnecessary trailing '/' */
3252 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
3255 case OPTION_PREFIX_STRIP
:
3256 prefix_strip
= atoi (optarg
);
3257 if (prefix_strip
< 0)
3258 fatal (_("error: prefix strip must be non-negative"));
3260 case OPTION_INSN_WIDTH
:
3261 insn_width
= strtoul (optarg
, NULL
, 0);
3262 if (insn_width
<= 0)
3263 fatal (_("error: instruction width must be positive"));
3266 if (strcmp (optarg
, "B") == 0)
3267 endian
= BFD_ENDIAN_BIG
;
3268 else if (strcmp (optarg
, "L") == 0)
3269 endian
= BFD_ENDIAN_LITTLE
;
3272 non_fatal (_("unrecognized -E option"));
3277 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3278 endian
= BFD_ENDIAN_BIG
;
3279 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3280 endian
= BFD_ENDIAN_LITTLE
;
3283 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3289 dump_file_header
= TRUE
;
3293 formats_info
= TRUE
;
3297 add_include_path (optarg
);
3300 dump_private_headers
= TRUE
;
3304 dump_private_headers
= TRUE
;
3306 dump_reloc_info
= TRUE
;
3307 dump_file_header
= TRUE
;
3308 dump_ar_hdrs
= TRUE
;
3309 dump_section_headers
= TRUE
;
3317 dump_dynamic_symtab
= TRUE
;
3325 disassemble_zeroes
= TRUE
;
3329 disassemble_all
= TRUE
;
3334 with_source_code
= TRUE
;
3343 dump_debugging_tags
= 1;
3348 dump_dwarf_section_info
= TRUE
;
3351 dwarf_select_sections_by_letters (optarg
);
3353 dwarf_select_sections_all ();
3356 dump_dwarf_section_info
= TRUE
;
3359 dwarf_select_sections_by_names (optarg
);
3361 dwarf_select_sections_all ();
3364 dump_stab_section_info
= TRUE
;
3368 dump_section_contents
= TRUE
;
3372 dump_reloc_info
= TRUE
;
3376 dump_dynamic_reloc_info
= TRUE
;
3380 dump_ar_hdrs
= TRUE
;
3384 dump_section_headers
= TRUE
;
3392 show_version
= TRUE
;
3402 print_version ("objdump");
3408 exit_status
= display_info ();
3412 display_file ("a.out", target
);
3414 for (; optind
< argc
;)
3415 display_file (argv
[optind
++], target
);
3418 END_PROGRESS (program_name
);