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
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"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status
= 0;
80 static char *default_target
= NULL
; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version
= 0; /* Show the version number. */
85 static int dump_section_contents
; /* -s */
86 static int dump_section_headers
; /* -h */
87 static bfd_boolean dump_file_header
; /* -f */
88 static int dump_symtab
; /* -t */
89 static int dump_dynamic_symtab
; /* -T */
90 static int dump_reloc_info
; /* -r */
91 static int dump_dynamic_reloc_info
; /* -R */
92 static int dump_ar_hdrs
; /* -a */
93 static int dump_private_headers
; /* -p */
94 static int prefix_addresses
; /* --prefix-addresses */
95 static int with_line_numbers
; /* -l */
96 static bfd_boolean with_source_code
; /* -S */
97 static int show_raw_insn
; /* --show-raw-insn */
98 static int dump_dwarf_section_info
; /* --dwarf */
99 static int dump_stab_section_info
; /* --stabs */
100 static int do_demangle
; /* -C, --demangle */
101 static bfd_boolean disassemble
; /* -d */
102 static bfd_boolean disassemble_all
; /* -D */
103 static int disassemble_zeroes
; /* --disassemble-zeroes */
104 static bfd_boolean formats_info
; /* -i */
105 static int wide_output
; /* -w */
106 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
107 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
108 static int dump_debugging
; /* --debugging */
109 static int dump_debugging_tags
; /* --debugging-tags */
110 static int dump_special_syms
= 0; /* --special-syms */
111 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
112 static int file_start_context
= 0; /* --file-start-context */
113 static bfd_boolean display_file_offsets
;/* -F */
115 /* Pointer to an array of section names provided by
116 one or more "-j secname" command line options. */
118 /* The total number of slots in the only[] array. */
119 static size_t only_size
= 0;
120 /* The number of occupied slots in the only[] array. */
121 static size_t only_used
= 0;
123 /* Variables for handling include file path table. */
124 static const char **include_paths
;
125 static int include_path_count
;
127 /* Extra info to pass to the section disassembler and address printing
129 struct objdump_disasm_info
133 bfd_boolean require_sec
;
134 arelent
** dynrelbuf
;
136 disassembler_ftype disassemble_fn
;
140 /* Architecture to disassemble for, or default if NULL. */
141 static char *machine
= NULL
;
143 /* Target specific options to the disassembler. */
144 static char *disassembler_options
= NULL
;
146 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
147 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
149 /* The symbol table. */
150 static asymbol
**syms
;
152 /* Number of symbols in `syms'. */
153 static long symcount
= 0;
155 /* The sorted symbol table. */
156 static asymbol
**sorted_syms
;
158 /* Number of symbols in `sorted_syms'. */
159 static long sorted_symcount
= 0;
161 /* The dynamic symbol table. */
162 static asymbol
**dynsyms
;
164 /* The synthetic symbol table. */
165 static asymbol
*synthsyms
;
166 static long synthcount
= 0;
168 /* Number of symbols in `dynsyms'. */
169 static long dynsymcount
= 0;
171 static bfd_byte
*stabs
;
172 static bfd_size_type stab_size
;
175 static bfd_size_type stabstr_size
;
177 static bfd_boolean is_relocatable
= FALSE
;
180 usage (FILE *stream
, int status
)
182 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
183 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
184 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
185 fprintf (stream
, _("\
186 -a, --archive-headers Display archive header information\n\
187 -f, --file-headers Display the contents of the overall file header\n\
188 -p, --private-headers Display object format specific file header contents\n\
189 -h, --[section-]headers Display the contents of the section headers\n\
190 -x, --all-headers Display the contents of all headers\n\
191 -d, --disassemble Display assembler contents of executable sections\n\
192 -D, --disassemble-all Display assembler contents of all sections\n\
193 -S, --source Intermix source code with disassembly\n\
194 -s, --full-contents Display the full contents of all sections requested\n\
195 -g, --debugging Display debug information in object file\n\
196 -e, --debugging-tags Display debug information using ctags style\n\
197 -G, --stabs Display (in raw form) any STABS info in the file\n\
198 -W, --dwarf Display DWARF info in the file\n\
199 -t, --syms Display the contents of the symbol table(s)\n\
200 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
201 -r, --reloc Display the relocation entries in the file\n\
202 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
203 @<file> Read options from <file>\n\
204 -v, --version Display this program's version number\n\
205 -i, --info List object formats and architectures supported\n\
206 -H, --help Display this information\n\
210 fprintf (stream
, _("\n The following switches are optional:\n"));
211 fprintf (stream
, _("\
212 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
213 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
214 -j, --section=NAME Only display information for section NAME\n\
215 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
216 -EB --endian=big Assume big endian format when disassembling\n\
217 -EL --endian=little Assume little endian format when disassembling\n\
218 --file-start-context Include context from start of file (with -S)\n\
219 -I, --include=DIR Add DIR to search list for source files\n\
220 -l, --line-numbers Include line numbers and filenames in output\n\
221 -F, --file-offsets Include file offsets when displaying information\n\
222 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
223 The STYLE, if specified, can be `auto', `gnu',\n\
224 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
226 -w, --wide Format output for more than 80 columns\n\
227 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
228 --start-address=ADDR Only process data whose address is >= ADDR\n\
229 --stop-address=ADDR Only process data whose address is <= ADDR\n\
230 --prefix-addresses Print complete address alongside disassembly\n\
231 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
232 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
233 --special-syms Include special symbols in symbol dumps\n\
235 list_supported_targets (program_name
, stream
);
236 list_supported_architectures (program_name
, stream
);
238 disassembler_usage (stream
);
240 if (REPORT_BUGS_TO
[0] && status
== 0)
241 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
245 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
249 OPTION_START_ADDRESS
,
254 static struct option long_options
[]=
256 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
257 {"all-headers", no_argument
, NULL
, 'x'},
258 {"private-headers", no_argument
, NULL
, 'p'},
259 {"architecture", required_argument
, NULL
, 'm'},
260 {"archive-headers", no_argument
, NULL
, 'a'},
261 {"debugging", no_argument
, NULL
, 'g'},
262 {"debugging-tags", no_argument
, NULL
, 'e'},
263 {"demangle", optional_argument
, NULL
, 'C'},
264 {"disassemble", no_argument
, NULL
, 'd'},
265 {"disassemble-all", no_argument
, NULL
, 'D'},
266 {"disassembler-options", required_argument
, NULL
, 'M'},
267 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
268 {"dynamic-reloc", no_argument
, NULL
, 'R'},
269 {"dynamic-syms", no_argument
, NULL
, 'T'},
270 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
271 {"file-headers", no_argument
, NULL
, 'f'},
272 {"file-offsets", no_argument
, NULL
, 'F'},
273 {"file-start-context", no_argument
, &file_start_context
, 1},
274 {"full-contents", no_argument
, NULL
, 's'},
275 {"headers", no_argument
, NULL
, 'h'},
276 {"help", no_argument
, NULL
, 'H'},
277 {"info", no_argument
, NULL
, 'i'},
278 {"line-numbers", no_argument
, NULL
, 'l'},
279 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
280 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
281 {"reloc", no_argument
, NULL
, 'r'},
282 {"section", required_argument
, NULL
, 'j'},
283 {"section-headers", no_argument
, NULL
, 'h'},
284 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
285 {"source", no_argument
, NULL
, 'S'},
286 {"special-syms", no_argument
, &dump_special_syms
, 1},
287 {"include", required_argument
, NULL
, 'I'},
288 {"dwarf", no_argument
, NULL
, 'W'},
289 {"stabs", no_argument
, NULL
, 'G'},
290 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
291 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
292 {"syms", no_argument
, NULL
, 't'},
293 {"target", required_argument
, NULL
, 'b'},
294 {"version", no_argument
, NULL
, 'V'},
295 {"wide", no_argument
, NULL
, 'w'},
296 {0, no_argument
, 0, 0}
300 nonfatal (const char *msg
)
307 dump_section_header (bfd
*abfd
, asection
*section
,
308 void *ignored ATTRIBUTE_UNUSED
)
311 unsigned int opb
= bfd_octets_per_byte (abfd
);
313 /* Ignore linker created section. See elfNN_ia64_object_p in
315 if (section
->flags
& SEC_LINKER_CREATED
)
318 printf ("%3d %-13s %08lx ", section
->index
,
319 bfd_get_section_name (abfd
, section
),
320 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
321 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
323 bfd_printf_vma (abfd
, section
->lma
);
324 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
325 bfd_get_section_alignment (abfd
, section
));
331 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
333 PF (SEC_HAS_CONTENTS
, "CONTENTS");
334 PF (SEC_ALLOC
, "ALLOC");
335 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
336 PF (SEC_LOAD
, "LOAD");
337 PF (SEC_RELOC
, "RELOC");
338 PF (SEC_READONLY
, "READONLY");
339 PF (SEC_CODE
, "CODE");
340 PF (SEC_DATA
, "DATA");
342 PF (SEC_DEBUGGING
, "DEBUGGING");
343 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
344 PF (SEC_EXCLUDE
, "EXCLUDE");
345 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
346 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
348 PF (SEC_TIC54X_BLOCK
, "BLOCK");
349 PF (SEC_TIC54X_CLINK
, "CLINK");
351 PF (SEC_SMALL_DATA
, "SMALL_DATA");
352 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
353 PF (SEC_COFF_SHARED
, "SHARED");
354 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
355 PF (SEC_GROUP
, "GROUP");
357 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
360 struct coff_comdat_info
*comdat
;
362 switch (section
->flags
& SEC_LINK_DUPLICATES
)
366 case SEC_LINK_DUPLICATES_DISCARD
:
367 ls
= "LINK_ONCE_DISCARD";
369 case SEC_LINK_DUPLICATES_ONE_ONLY
:
370 ls
= "LINK_ONCE_ONE_ONLY";
372 case SEC_LINK_DUPLICATES_SAME_SIZE
:
373 ls
= "LINK_ONCE_SAME_SIZE";
375 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
376 ls
= "LINK_ONCE_SAME_CONTENTS";
379 printf ("%s%s", comma
, ls
);
381 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
383 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
393 dump_headers (bfd
*abfd
)
395 printf (_("Sections:\n"));
398 printf (_("Idx Name Size VMA LMA File off Algn"));
400 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
401 if (bfd_get_arch_size (abfd
) == 32)
402 printf (_("Idx Name Size VMA LMA File off Algn"));
404 printf (_("Idx Name Size VMA LMA File off Algn"));
408 printf (_(" Flags"));
409 if (abfd
->flags
& HAS_LOAD_PAGE
)
413 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
417 slurp_symtab (bfd
*abfd
)
422 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
428 storage
= bfd_get_symtab_upper_bound (abfd
);
430 bfd_fatal (bfd_get_filename (abfd
));
432 sy
= xmalloc (storage
);
434 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
436 bfd_fatal (bfd_get_filename (abfd
));
440 /* Read in the dynamic symbols. */
443 slurp_dynamic_symtab (bfd
*abfd
)
448 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
451 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
453 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
458 bfd_fatal (bfd_get_filename (abfd
));
461 sy
= xmalloc (storage
);
463 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
465 bfd_fatal (bfd_get_filename (abfd
));
469 /* Filter out (in place) symbols that are useless for disassembly.
470 COUNT is the number of elements in SYMBOLS.
471 Return the number of useful symbols. */
474 remove_useless_symbols (asymbol
**symbols
, long count
)
476 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
480 asymbol
*sym
= *in_ptr
++;
482 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
484 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
486 if (bfd_is_und_section (sym
->section
)
487 || bfd_is_com_section (sym
->section
))
492 return out_ptr
- symbols
;
495 /* Sort symbols into value order. */
498 compare_symbols (const void *ap
, const void *bp
)
500 const asymbol
*a
= * (const asymbol
**) ap
;
501 const asymbol
*b
= * (const asymbol
**) bp
;
511 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
513 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
516 if (a
->section
> b
->section
)
518 else if (a
->section
< b
->section
)
521 an
= bfd_asymbol_name (a
);
522 bn
= bfd_asymbol_name (b
);
526 /* The symbols gnu_compiled and gcc2_compiled convey no real
527 information, so put them after other symbols with the same value. */
528 af
= (strstr (an
, "gnu_compiled") != NULL
529 || strstr (an
, "gcc2_compiled") != NULL
);
530 bf
= (strstr (bn
, "gnu_compiled") != NULL
531 || strstr (bn
, "gcc2_compiled") != NULL
);
538 /* We use a heuristic for the file name, to try to sort it after
539 more useful symbols. It may not work on non Unix systems, but it
540 doesn't really matter; the only difference is precisely which
541 symbol names get printed. */
543 #define file_symbol(s, sn, snl) \
544 (((s)->flags & BSF_FILE) != 0 \
545 || ((sn)[(snl) - 2] == '.' \
546 && ((sn)[(snl) - 1] == 'o' \
547 || (sn)[(snl) - 1] == 'a')))
549 af
= file_symbol (a
, an
, anl
);
550 bf
= file_symbol (b
, bn
, bnl
);
557 /* Try to sort global symbols before local symbols before function
558 symbols before debugging symbols. */
563 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
565 if ((aflags
& BSF_DEBUGGING
) != 0)
570 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
572 if ((aflags
& BSF_FUNCTION
) != 0)
577 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
579 if ((aflags
& BSF_LOCAL
) != 0)
584 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
586 if ((aflags
& BSF_GLOBAL
) != 0)
592 /* Symbols that start with '.' might be section names, so sort them
593 after symbols that don't start with '.'. */
594 if (an
[0] == '.' && bn
[0] != '.')
596 if (an
[0] != '.' && bn
[0] == '.')
599 /* Finally, if we can't distinguish them in any other way, try to
600 get consistent results by sorting the symbols by name. */
601 return strcmp (an
, bn
);
604 /* Sort relocs into address order. */
607 compare_relocs (const void *ap
, const void *bp
)
609 const arelent
*a
= * (const arelent
**) ap
;
610 const arelent
*b
= * (const arelent
**) bp
;
612 if (a
->address
> b
->address
)
614 else if (a
->address
< b
->address
)
617 /* So that associated relocations tied to the same address show up
618 in the correct order, we don't do any further sorting. */
627 /* Print an address (VMA) to the output stream in INFO.
628 If SKIP_ZEROES is TRUE, omit leading zeroes. */
631 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
632 bfd_boolean skip_zeroes
)
636 struct objdump_disasm_info
*aux
;
638 aux
= (struct objdump_disasm_info
*) info
->application_data
;
639 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
644 for (p
= buf
; *p
== '0'; ++p
)
649 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
652 /* Print the name of a symbol. */
655 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
662 name
= bfd_asymbol_name (sym
);
663 if (do_demangle
&& name
[0] != '\0')
665 /* Demangle the name. */
666 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
672 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
680 /* Locate a symbol given a bfd and a section (from INFO->application_data),
681 and a VMA. If INFO->application_data->require_sec is TRUE, then always
682 require the symbol to be in the section. Returns NULL if there is no
683 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
684 of the symbol in sorted_syms. */
687 find_symbol_for_address (bfd_vma vma
,
688 struct disassemble_info
*info
,
691 /* @@ Would it speed things up to cache the last two symbols returned,
692 and maybe their address ranges? For many processors, only one memory
693 operand can be present at a time, so the 2-entry cache wouldn't be
694 constantly churned by code doing heavy memory accesses. */
696 /* Indices in `sorted_syms'. */
698 long max
= sorted_symcount
;
700 struct objdump_disasm_info
*aux
;
704 bfd_boolean want_section
;
706 if (sorted_symcount
< 1)
709 aux
= (struct objdump_disasm_info
*) info
->application_data
;
712 opb
= bfd_octets_per_byte (abfd
);
714 /* Perform a binary search looking for the closest symbol to the
715 required value. We are searching the range (min, max]. */
716 while (min
+ 1 < max
)
720 thisplace
= (max
+ min
) / 2;
721 sym
= sorted_syms
[thisplace
];
723 if (bfd_asymbol_value (sym
) > vma
)
725 else if (bfd_asymbol_value (sym
) < vma
)
734 /* The symbol we want is now in min, the low end of the range we
735 were searching. If there are several symbols with the same
736 value, we want the first one. */
739 && (bfd_asymbol_value (sorted_syms
[thisplace
])
740 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
743 /* If the file is relocatable, and the symbol could be from this
744 section, prefer a symbol from this section over symbols from
745 others, even if the other symbol's value might be closer.
747 Note that this may be wrong for some symbol references if the
748 sections have overlapping memory ranges, but in that case there's
749 no way to tell what's desired without looking at the relocation
752 Also give the target a chance to reject symbols. */
753 want_section
= (aux
->require_sec
754 || ((abfd
->flags
& HAS_RELOC
) != 0
755 && vma
>= bfd_get_section_vma (abfd
, sec
)
756 && vma
< (bfd_get_section_vma (abfd
, sec
)
757 + bfd_section_size (abfd
, sec
) / opb
)));
758 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
759 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
764 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
766 if (bfd_asymbol_value (sorted_syms
[i
])
767 != bfd_asymbol_value (sorted_syms
[thisplace
]))
772 newplace
= sorted_symcount
;
776 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
777 && info
->symbol_is_valid (sorted_syms
[i
], info
))
779 if (newplace
== sorted_symcount
)
782 if (bfd_asymbol_value (sorted_syms
[i
])
783 != bfd_asymbol_value (sorted_syms
[newplace
]))
786 /* Remember this symbol and keep searching until we reach
787 an earlier address. */
792 if (newplace
!= sorted_symcount
)
793 thisplace
= newplace
;
796 /* We didn't find a good symbol with a smaller value.
797 Look for one with a larger value. */
798 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
800 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
801 && info
->symbol_is_valid (sorted_syms
[i
], info
))
809 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
810 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
811 /* There is no suitable symbol. */
818 return sorted_syms
[thisplace
];
821 /* Print an address and the offset to the nearest symbol. */
824 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
825 bfd_vma vma
, struct disassemble_info
*info
,
826 bfd_boolean skip_zeroes
)
828 objdump_print_value (vma
, info
, skip_zeroes
);
834 (*info
->fprintf_func
) (info
->stream
, " <%s",
835 bfd_get_section_name (abfd
, sec
));
836 secaddr
= bfd_get_section_vma (abfd
, sec
);
839 (*info
->fprintf_func
) (info
->stream
, "-0x");
840 objdump_print_value (secaddr
- vma
, info
, TRUE
);
842 else if (vma
> secaddr
)
844 (*info
->fprintf_func
) (info
->stream
, "+0x");
845 objdump_print_value (vma
- secaddr
, info
, TRUE
);
847 (*info
->fprintf_func
) (info
->stream
, ">");
851 (*info
->fprintf_func
) (info
->stream
, " <");
852 objdump_print_symname (abfd
, info
, sym
);
853 if (bfd_asymbol_value (sym
) > vma
)
855 (*info
->fprintf_func
) (info
->stream
, "-0x");
856 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
858 else if (vma
> bfd_asymbol_value (sym
))
860 (*info
->fprintf_func
) (info
->stream
, "+0x");
861 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
863 (*info
->fprintf_func
) (info
->stream
, ">");
866 if (display_file_offsets
)
867 info
->fprintf_func (info
->stream
, " (File Offset: 0x%lx)",
868 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
871 /* Print an address (VMA), symbolically if possible.
872 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
875 objdump_print_addr (bfd_vma vma
,
876 struct disassemble_info
*info
,
877 bfd_boolean skip_zeroes
)
879 struct objdump_disasm_info
*aux
;
880 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
881 bfd_boolean skip_find
= FALSE
;
883 if (sorted_symcount
< 1)
885 (*info
->fprintf_func
) (info
->stream
, "0x");
886 objdump_print_value (vma
, info
, skip_zeroes
);
890 aux
= (struct objdump_disasm_info
*) info
->application_data
;
892 if (aux
->reloc
!= NULL
893 && aux
->reloc
->sym_ptr_ptr
!= NULL
894 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
896 sym
= * aux
->reloc
->sym_ptr_ptr
;
898 /* Adjust the vma to the reloc. */
899 vma
+= bfd_asymbol_value (sym
);
901 if (bfd_is_und_section (bfd_get_section (sym
)))
906 sym
= find_symbol_for_address (vma
, info
, NULL
);
908 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
912 /* Print VMA to INFO. This function is passed to the disassembler
916 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
918 objdump_print_addr (vma
, info
, ! prefix_addresses
);
921 /* Determine if the given address has a symbol associated with it. */
924 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
928 sym
= find_symbol_for_address (vma
, info
, NULL
);
930 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
933 /* Hold the last function name and the last line number we displayed
936 static char *prev_functionname
;
937 static unsigned int prev_line
;
939 /* We keep a list of all files that we have seen when doing a
940 disassembly with source, so that we know how much of the file to
941 display. This can be important for inlined functions. */
943 struct print_file_list
945 struct print_file_list
*next
;
946 const char *filename
;
950 const char **linemap
;
956 static struct print_file_list
*print_files
;
958 /* The number of preceding context lines to show when we start
959 displaying a file for the first time. */
961 #define SHOW_PRECEDING_CONTEXT_LINES (5)
963 /* Read a complete file into memory. */
966 slurp_file (const char *fn
, size_t *size
)
969 int ps
= getpagesize ();
974 int fd
= open (fn
, O_RDONLY
);
978 if (fstat (fd
, &st
) < 0)
982 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
983 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
984 if (map
!= (char *)-1L)
990 map
= malloc (*size
);
991 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1000 #define line_map_decrease 5
1002 /* Precompute array of lines for a mapped file. */
1004 static const char **
1005 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1007 const char *p
, *lstart
, *end
;
1008 int chars_per_line
= 45; /* First iteration will use 40. */
1009 unsigned int lineno
;
1010 const char **linemap
= NULL
;
1011 unsigned long line_map_size
= 0;
1017 for (p
= map
; p
< end
; p
++)
1021 if (p
+ 1 < end
&& p
[1] == '\r')
1024 else if (*p
== '\r')
1026 if (p
+ 1 < end
&& p
[1] == '\n')
1032 /* End of line found. */
1034 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1036 unsigned long newsize
;
1038 chars_per_line
-= line_map_decrease
;
1039 if (chars_per_line
<= 1)
1041 line_map_size
= size
/ chars_per_line
+ 1;
1042 if (line_map_size
< lineno
+ 1)
1043 line_map_size
= lineno
+ 1;
1044 newsize
= line_map_size
* sizeof (char *);
1045 linemap
= xrealloc (linemap
, newsize
);
1048 linemap
[lineno
++] = lstart
;
1056 /* Tries to open MODNAME, and if successful adds a node to print_files
1057 linked list and returns that node. Returns NULL on failure. */
1059 static struct print_file_list
*
1060 try_print_file_open (const char *origname
, const char *modname
)
1062 struct print_file_list
*p
;
1064 p
= xmalloc (sizeof (struct print_file_list
));
1066 p
->map
= slurp_file (modname
, &p
->mapsize
);
1073 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1075 p
->filename
= origname
;
1076 p
->modname
= modname
;
1077 p
->next
= print_files
;
1083 /* If the the source file, as described in the symtab, is not found
1084 try to locate it in one of the paths specified with -I
1085 If found, add location to print_files linked list. */
1087 static struct print_file_list
*
1088 update_source_path (const char *filename
)
1090 struct print_file_list
*p
;
1094 if (filename
== NULL
)
1097 p
= try_print_file_open (filename
, filename
);
1101 if (include_path_count
== 0)
1104 /* Get the name of the file. */
1105 fname
= strrchr (filename
, '/');
1106 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1108 /* We could have a mixed forward/back slash case. */
1109 char *backslash
= strrchr (filename
, '\\');
1110 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1112 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1113 fname
= filename
+ 1;
1121 /* If file exists under a new path, we need to add it to the list
1122 so that show_line knows about it. */
1123 for (i
= 0; i
< include_path_count
; i
++)
1125 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1127 p
= try_print_file_open (filename
, modname
);
1137 /* Print a source file line. */
1140 print_line (struct print_file_list
*p
, unsigned int line
)
1146 if (line
>= p
->maxline
)
1148 l
= p
->linemap
[line
];
1149 /* Test fwrite return value to quiet glibc warning. */
1150 len
= strcspn (l
, "\n\r");
1151 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1155 /* Print a range of source code lines. */
1158 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1162 while (start
<= end
)
1164 print_line (p
, start
);
1169 /* Show the line number, or the source line, in a disassembly
1173 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1175 const char *filename
;
1176 const char *functionname
;
1179 if (! with_line_numbers
&& ! with_source_code
)
1182 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1183 &functionname
, &line
))
1186 if (filename
!= NULL
&& *filename
== '\0')
1188 if (functionname
!= NULL
&& *functionname
== '\0')
1189 functionname
= NULL
;
1191 if (with_line_numbers
)
1193 if (functionname
!= NULL
1194 && (prev_functionname
== NULL
1195 || strcmp (functionname
, prev_functionname
) != 0))
1196 printf ("%s():\n", functionname
);
1197 if (line
> 0 && line
!= prev_line
)
1198 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1201 if (with_source_code
1205 struct print_file_list
**pp
, *p
;
1208 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1209 if (strcmp ((*pp
)->filename
, filename
) == 0)
1214 p
= update_source_path (filename
);
1216 if (p
!= NULL
&& line
!= p
->last_line
)
1218 if (file_start_context
&& p
->first
)
1222 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1225 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1226 l
= p
->last_line
+ 1;
1228 dump_lines (p
, l
, line
);
1229 p
->last_line
= line
;
1234 if (functionname
!= NULL
1235 && (prev_functionname
== NULL
1236 || strcmp (functionname
, prev_functionname
) != 0))
1238 if (prev_functionname
!= NULL
)
1239 free (prev_functionname
);
1240 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1241 strcpy (prev_functionname
, functionname
);
1244 if (line
> 0 && line
!= prev_line
)
1248 /* Pseudo FILE object for strings. */
1256 /* sprintf to a "stream". */
1258 static int ATTRIBUTE_PRINTF_2
1259 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1266 size_t space
= f
->alloc
- f
->pos
;
1268 va_start (args
, format
);
1269 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1275 f
->alloc
= (f
->alloc
+ n
) * 2;
1276 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1283 /* Returns TRUE if the specified section should be dumped. */
1286 process_section_p (asection
* section
)
1293 for (i
= 0; i
< only_used
; i
++)
1294 if (strcmp (only
[i
], section
->name
) == 0)
1301 /* The number of zeroes we want to see before we start skipping them.
1302 The number is arbitrarily chosen. */
1304 #define DEFAULT_SKIP_ZEROES 8
1306 /* The number of zeroes to skip at the end of a section. If the
1307 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1308 SKIP_ZEROES, they will be disassembled. If there are fewer than
1309 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1310 attempt to avoid disassembling zeroes inserted by section
1313 #define DEFAULT_SKIP_ZEROES_AT_END 3
1315 /* Disassemble some data in memory between given values. */
1318 disassemble_bytes (struct disassemble_info
* info
,
1319 disassembler_ftype disassemble_fn
,
1322 bfd_vma start_offset
,
1323 bfd_vma stop_offset
,
1326 arelent
** relppend
)
1328 struct objdump_disasm_info
*aux
;
1330 int octets_per_line
;
1331 bfd_boolean done_dot
;
1332 int skip_addr_chars
;
1333 bfd_vma addr_offset
;
1334 unsigned int opb
= info
->octets_per_byte
;
1335 unsigned int skip_zeroes
= info
->skip_zeroes
;
1336 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1340 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1344 sfile
.buffer
= xmalloc (sfile
.alloc
);
1348 octets_per_line
= 4;
1350 octets_per_line
= 16;
1352 /* Figure out how many characters to skip at the start of an
1353 address, to make the disassembly look nicer. We discard leading
1354 zeroes in chunks of 4, ensuring that there is always a leading
1356 skip_addr_chars
= 0;
1357 if (! prefix_addresses
)
1365 + bfd_section_size (section
->owner
, section
) / opb
));
1367 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1370 skip_addr_chars
+= 4;
1375 info
->insn_info_valid
= 0;
1378 addr_offset
= start_offset
;
1379 while (addr_offset
< stop_offset
)
1382 bfd_boolean need_nl
= FALSE
;
1383 int previous_octets
;
1385 /* Remember the length of the previous instruction. */
1386 previous_octets
= octets
;
1389 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1391 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1394 if (! disassemble_zeroes
1395 && (info
->insn_info_valid
== 0
1396 || info
->branch_delay_insns
== 0)
1397 && (z
- addr_offset
* opb
>= skip_zeroes
1398 || (z
== stop_offset
* opb
&&
1399 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1401 /* If there are more nonzero octets to follow, we only skip
1402 zeroes in multiples of 4, to try to avoid running over
1403 the start of an instruction which happens to start with
1405 if (z
!= stop_offset
* opb
)
1406 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1408 octets
= z
- addr_offset
* opb
;
1410 /* If we are going to display more data, and we are displaying
1411 file offsets, then tell the user how many zeroes we skip
1412 and the file offset from where we resume dumping. */
1413 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1414 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1416 (long int)(section
->filepos
+ (addr_offset
+ (octets
/ opb
))));
1428 if (with_line_numbers
|| with_source_code
)
1429 show_line (aux
->abfd
, section
, addr_offset
);
1431 if (! prefix_addresses
)
1435 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1436 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1440 printf ("%s:\t", buf
+ skip_addr_chars
);
1444 aux
->require_sec
= TRUE
;
1445 objdump_print_address (section
->vma
+ addr_offset
, info
);
1446 aux
->require_sec
= FALSE
;
1453 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1454 info
->stream
= &sfile
;
1455 info
->bytes_per_line
= 0;
1456 info
->bytes_per_chunk
= 0;
1459 if (info
->disassembler_needs_relocs
1460 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1461 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1462 && *relppp
< relppend
)
1464 bfd_signed_vma distance_to_rel
;
1466 distance_to_rel
= (**relppp
)->address
1467 - (rel_offset
+ addr_offset
);
1469 /* Check to see if the current reloc is associated with
1470 the instruction that we are about to disassemble. */
1471 if (distance_to_rel
== 0
1472 /* FIXME: This is wrong. We are trying to catch
1473 relocs that are addressed part way through the
1474 current instruction, as might happen with a packed
1475 VLIW instruction. Unfortunately we do not know the
1476 length of the current instruction since we have not
1477 disassembled it yet. Instead we take a guess based
1478 upon the length of the previous instruction. The
1479 proper solution is to have a new target-specific
1480 disassembler function which just returns the length
1481 of an instruction at a given address without trying
1482 to display its disassembly. */
1483 || (distance_to_rel
> 0
1484 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1486 info
->flags
= INSN_HAS_RELOC
;
1487 aux
->reloc
= **relppp
;
1493 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1494 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1495 info
->stream
= stdout
;
1496 if (info
->bytes_per_line
!= 0)
1497 octets_per_line
= info
->bytes_per_line
;
1501 printf ("%s\n", sfile
.buffer
);
1509 octets
= octets_per_line
;
1510 if (addr_offset
+ octets
/ opb
> stop_offset
)
1511 octets
= (stop_offset
- addr_offset
) * opb
;
1513 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1515 if (ISPRINT (data
[j
]))
1516 buf
[j
- addr_offset
* opb
] = data
[j
];
1518 buf
[j
- addr_offset
* opb
] = '.';
1520 buf
[j
- addr_offset
* opb
] = '\0';
1523 if (prefix_addresses
1525 : show_raw_insn
>= 0)
1529 /* If ! prefix_addresses and ! wide_output, we print
1530 octets_per_line octets per line. */
1532 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1533 pb
= octets_per_line
;
1535 if (info
->bytes_per_chunk
)
1536 bpc
= info
->bytes_per_chunk
;
1540 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1544 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1546 for (k
= bpc
- 1; k
>= 0; k
--)
1547 printf ("%02x", (unsigned) data
[j
+ k
]);
1552 for (k
= 0; k
< bpc
; k
++)
1553 printf ("%02x", (unsigned) data
[j
+ k
]);
1558 for (; pb
< octets_per_line
; pb
+= bpc
)
1562 for (k
= 0; k
< bpc
; k
++)
1567 /* Separate raw data from instruction by extra space. */
1577 printf ("%s", sfile
.buffer
);
1579 if (prefix_addresses
1581 : show_raw_insn
>= 0)
1589 j
= addr_offset
* opb
+ pb
;
1591 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1592 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1596 printf ("%s:\t", buf
+ skip_addr_chars
);
1598 pb
+= octets_per_line
;
1601 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1605 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1607 for (k
= bpc
- 1; k
>= 0; k
--)
1608 printf ("%02x", (unsigned) data
[j
+ k
]);
1613 for (k
= 0; k
< bpc
; k
++)
1614 printf ("%02x", (unsigned) data
[j
+ k
]);
1627 while ((*relppp
) < relppend
1628 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1630 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1641 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1644 if (q
->howto
== NULL
)
1645 printf (": *unknown*\t");
1646 else if (q
->howto
->name
)
1647 printf (": %s\t", q
->howto
->name
);
1649 printf (": %d\t", q
->howto
->type
);
1651 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1652 printf ("*unknown*");
1655 const char *sym_name
;
1657 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1658 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1659 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1664 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1665 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1666 if (sym_name
== NULL
|| *sym_name
== '\0')
1667 sym_name
= "*unknown*";
1668 printf ("%s", sym_name
);
1675 objdump_print_value (q
->addend
, info
, TRUE
);
1687 addr_offset
+= octets
/ opb
;
1690 free (sfile
.buffer
);
1694 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1696 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1697 struct objdump_disasm_info
* paux
;
1698 unsigned int opb
= pinfo
->octets_per_byte
;
1699 bfd_byte
* data
= NULL
;
1700 bfd_size_type datasize
= 0;
1701 arelent
** rel_pp
= NULL
;
1702 arelent
** rel_ppstart
= NULL
;
1703 arelent
** rel_ppend
;
1704 unsigned long stop_offset
;
1705 asymbol
* sym
= NULL
;
1709 unsigned long addr_offset
;
1711 /* Sections that do not contain machine
1712 code are not normally disassembled. */
1713 if (! disassemble_all
1715 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1716 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1719 if (! process_section_p (section
))
1722 datasize
= bfd_get_section_size (section
);
1726 /* Decide which set of relocs to use. Load them if necessary. */
1727 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1728 if (paux
->dynrelbuf
)
1730 rel_pp
= paux
->dynrelbuf
;
1731 rel_count
= paux
->dynrelcount
;
1732 /* Dynamic reloc addresses are absolute, non-dynamic are section
1733 relative. REL_OFFSET specifies the reloc address corresponding
1734 to the start of this section. */
1735 rel_offset
= section
->vma
;
1743 if ((section
->flags
& SEC_RELOC
) != 0
1744 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1748 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1750 bfd_fatal (bfd_get_filename (abfd
));
1754 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1755 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1757 bfd_fatal (bfd_get_filename (abfd
));
1759 /* Sort the relocs by address. */
1760 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1765 rel_ppend
= rel_pp
+ rel_count
;
1767 data
= xmalloc (datasize
);
1769 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1771 paux
->sec
= section
;
1772 pinfo
->buffer
= data
;
1773 pinfo
->buffer_vma
= section
->vma
;
1774 pinfo
->buffer_length
= datasize
;
1775 pinfo
->section
= section
;
1777 if (start_address
== (bfd_vma
) -1
1778 || start_address
< pinfo
->buffer_vma
)
1781 addr_offset
= start_address
- pinfo
->buffer_vma
;
1783 if (stop_address
== (bfd_vma
) -1)
1784 stop_offset
= datasize
/ opb
;
1787 if (stop_address
< pinfo
->buffer_vma
)
1790 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1791 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1792 stop_offset
= pinfo
->buffer_length
/ opb
;
1795 /* Skip over the relocs belonging to addresses below the
1797 while (rel_pp
< rel_ppend
1798 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1801 if (addr_offset
< stop_offset
)
1802 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1804 /* Find the nearest symbol forwards from our current position. */
1805 paux
->require_sec
= TRUE
;
1806 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1807 paux
->require_sec
= FALSE
;
1809 /* Disassemble a block of instructions up to the address associated with
1810 the symbol we have just found. Then print the symbol and find the
1811 next symbol on. Repeat until we have disassembled the entire section
1812 or we have reached the end of the address range we are interested in. */
1813 while (addr_offset
< stop_offset
)
1817 unsigned long nextstop_offset
;
1820 addr
= section
->vma
+ addr_offset
;
1822 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1827 (x
< sorted_symcount
1828 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1832 pinfo
->symbols
= sorted_syms
+ place
;
1833 pinfo
->num_symbols
= x
- place
;
1834 pinfo
->symtab_pos
= place
;
1838 pinfo
->symbols
= NULL
;
1839 pinfo
->num_symbols
= 0;
1840 pinfo
->symtab_pos
= -1;
1843 if (! prefix_addresses
)
1845 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1846 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1848 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1851 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1853 else if (sym
== NULL
)
1857 #define is_valid_next_sym(SYM) \
1858 ((SYM)->section == section \
1859 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1860 && pinfo->symbol_is_valid (SYM, pinfo))
1862 /* Search forward for the next appropriate symbol in
1863 SECTION. Note that all the symbols are sorted
1864 together into one big array, and that some sections
1865 may have overlapping addresses. */
1866 while (place
< sorted_symcount
1867 && ! is_valid_next_sym (sorted_syms
[place
]))
1870 if (place
>= sorted_symcount
)
1873 nextsym
= sorted_syms
[place
];
1876 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1877 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1878 else if (nextsym
== NULL
)
1879 nextstop_offset
= stop_offset
;
1881 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1883 if (nextstop_offset
> stop_offset
)
1884 nextstop_offset
= stop_offset
;
1886 /* If a symbol is explicitly marked as being an object
1887 rather than a function, just dump the bytes without
1888 disassembling them. */
1891 || bfd_asymbol_value (sym
) > addr
1892 || ((sym
->flags
& BSF_OBJECT
) == 0
1893 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1895 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1897 || (sym
->flags
& BSF_FUNCTION
) != 0)
1902 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1903 addr_offset
, nextstop_offset
,
1904 rel_offset
, &rel_pp
, rel_ppend
);
1906 addr_offset
= nextstop_offset
;
1912 if (rel_ppstart
!= NULL
)
1916 /* Disassemble the contents of an object file. */
1919 disassemble_data (bfd
*abfd
)
1921 struct disassemble_info disasm_info
;
1922 struct objdump_disasm_info aux
;
1926 prev_functionname
= NULL
;
1929 /* We make a copy of syms to sort. We don't want to sort syms
1930 because that will screw up the relocs. */
1931 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1932 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1933 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1934 sorted_symcount
* sizeof (asymbol
*));
1936 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1938 for (i
= 0; i
< synthcount
; ++i
)
1940 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1944 /* Sort the symbols into section and symbol order. */
1945 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1947 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1949 disasm_info
.application_data
= (void *) &aux
;
1951 aux
.require_sec
= FALSE
;
1952 aux
.dynrelbuf
= NULL
;
1953 aux
.dynrelcount
= 0;
1956 disasm_info
.print_address_func
= objdump_print_address
;
1957 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1959 if (machine
!= NULL
)
1961 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1964 fatal (_("Can't use supplied machine %s"), machine
);
1966 abfd
->arch_info
= info
;
1969 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1971 struct bfd_target
*xvec
;
1973 xvec
= xmalloc (sizeof (struct bfd_target
));
1974 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1975 xvec
->byteorder
= endian
;
1979 /* Use libopcodes to locate a suitable disassembler. */
1980 aux
.disassemble_fn
= disassembler (abfd
);
1981 if (!aux
.disassemble_fn
)
1983 non_fatal (_("Can't disassemble for architecture %s\n"),
1984 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1989 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1990 disasm_info
.arch
= bfd_get_arch (abfd
);
1991 disasm_info
.mach
= bfd_get_mach (abfd
);
1992 disasm_info
.disassembler_options
= disassembler_options
;
1993 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1994 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1995 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1996 disasm_info
.disassembler_needs_relocs
= FALSE
;
1998 if (bfd_big_endian (abfd
))
1999 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2000 else if (bfd_little_endian (abfd
))
2001 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2003 /* ??? Aborting here seems too drastic. We could default to big or little
2005 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2007 /* Allow the target to customize the info structure. */
2008 disassemble_init_for_target (& disasm_info
);
2010 /* Pre-load the dynamic relocs if we are going
2011 to be dumping them along with the disassembly. */
2012 if (dump_dynamic_reloc_info
)
2014 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2017 bfd_fatal (bfd_get_filename (abfd
));
2021 aux
.dynrelbuf
= xmalloc (relsize
);
2022 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2025 if (aux
.dynrelcount
< 0)
2026 bfd_fatal (bfd_get_filename (abfd
));
2028 /* Sort the relocs by address. */
2029 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2033 disasm_info
.symtab
= sorted_syms
;
2034 disasm_info
.symtab_size
= sorted_symcount
;
2036 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2038 if (aux
.dynrelbuf
!= NULL
)
2039 free (aux
.dynrelbuf
);
2044 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2046 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2051 /* If it is already loaded, do nothing. */
2052 if (section
->start
!= NULL
)
2055 /* Locate the debug section. */
2056 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2060 /* Compute a bias to be added to offsets found within the DWARF debug
2061 information. These offsets are meant to be relative to the start of
2062 the dwarf section, and hence the bias should be 0. For MACH-O however
2063 a dwarf section is really just a region of a much larger section and so
2064 the bias is the address of the start of that area within the larger
2065 section. This test is important for PE and COFF based targets which
2066 use DWARF debug information, since unlike ELF, they do not allow the
2067 dwarf sections to be placed at address 0. */
2068 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2069 section
->address
= bfd_get_section_vma (abfd
, sec
);
2071 section
->address
= 0;
2073 section
->size
= bfd_get_section_size (sec
);
2074 section
->start
= xmalloc (section
->size
);
2076 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2077 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2082 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2087 free_debug_section (debug
);
2088 printf (_("\nCan't get contents for section '%s'.\n"),
2096 free_debug_section (enum dwarf_section_display_enum debug
)
2098 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2100 if (section
->start
== NULL
)
2103 free ((char *) section
->start
);
2104 section
->start
= NULL
;
2105 section
->address
= 0;
2110 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2111 void *arg ATTRIBUTE_UNUSED
)
2113 const char *name
= bfd_get_section_name (abfd
, section
);
2115 enum dwarf_section_display_enum i
;
2117 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2118 match
= ".debug_info";
2122 for (i
= 0; i
< max
; i
++)
2123 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2125 if (!debug_displays
[i
].eh_frame
)
2127 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2129 if (load_debug_section (i
, abfd
))
2131 debug_displays
[i
].display (sec
, abfd
);
2133 if (i
!= info
&& i
!= abbrev
)
2134 free_debug_section (i
);
2141 static const char *mach_o_dwarf_sections
[] = {
2142 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2143 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2144 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2145 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2146 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2147 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2148 ".eh_frame", /* .eh_frame */
2149 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2150 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2151 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2152 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2153 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2154 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2155 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2156 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2157 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2160 static const char *generic_dwarf_sections
[max
];
2163 check_mach_o_dwarf (bfd
*abfd
)
2165 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2166 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2167 enum dwarf_section_display_enum i
;
2169 if (generic_dwarf_sections
[0] == NULL
)
2170 for (i
= 0; i
< max
; i
++)
2171 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2173 if (old_flavour
!= current_flavour
)
2175 if (current_flavour
== bfd_target_mach_o_flavour
)
2176 for (i
= 0; i
< max
; i
++)
2177 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2178 else if (old_flavour
== bfd_target_mach_o_flavour
)
2179 for (i
= 0; i
< max
; i
++)
2180 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2182 old_flavour
= current_flavour
;
2186 /* Dump the dwarf debugging information. */
2189 dump_dwarf (bfd
*abfd
)
2191 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2193 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2194 targets will return 64. */
2195 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2197 if (bfd_big_endian (abfd
))
2198 byte_get
= byte_get_big_endian
;
2199 else if (bfd_little_endian (abfd
))
2200 byte_get
= byte_get_little_endian
;
2204 check_mach_o_dwarf (abfd
);
2206 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2208 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2209 init_dwarf_regnames (bed
->elf_machine_code
);
2212 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2214 free_debug_memory ();
2217 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2218 it. Return NULL on failure. */
2221 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2227 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2228 if (stabsect
== NULL
)
2230 printf (_("No %s section present\n\n"), sect_name
);
2234 size
= bfd_section_size (abfd
, stabsect
);
2235 contents
= xmalloc (size
);
2237 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2239 non_fatal (_("Reading %s section of %s failed: %s"),
2240 sect_name
, bfd_get_filename (abfd
),
2241 bfd_errmsg (bfd_get_error ()));
2252 /* Stabs entries use a 12 byte format:
2253 4 byte string table index
2255 1 byte stab other field
2256 2 byte stab desc field
2258 FIXME: This will have to change for a 64 bit object format. */
2260 #define STRDXOFF (0)
2262 #define OTHEROFF (5)
2265 #define STABSIZE (12)
2267 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2268 using string table section STRSECT_NAME (in `strtab'). */
2271 print_section_stabs (bfd
*abfd
,
2272 const char *stabsect_name
,
2273 unsigned *string_offset_ptr
)
2276 unsigned file_string_table_offset
= 0;
2277 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2278 bfd_byte
*stabp
, *stabs_end
;
2281 stabs_end
= stabp
+ stab_size
;
2283 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2284 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2286 /* Loop through all symbols and print them.
2288 We start the index at -1 because there is a dummy symbol on
2289 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2290 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2294 unsigned char type
, other
;
2295 unsigned short desc
;
2298 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2299 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2300 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2301 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2302 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2304 printf ("\n%-6d ", i
);
2305 /* Either print the stab name, or, if unnamed, print its number
2306 again (makes consistent formatting for tools like awk). */
2307 name
= bfd_get_stab_name (type
);
2309 printf ("%-6s", name
);
2310 else if (type
== N_UNDF
)
2313 printf ("%-6d", type
);
2314 printf (" %-6d %-6d ", other
, desc
);
2315 bfd_printf_vma (abfd
, value
);
2316 printf (" %-6lu", strx
);
2318 /* Symbols with type == 0 (N_UNDF) specify the length of the
2319 string table associated with this file. We use that info
2320 to know how to relocate the *next* file's string table indices. */
2323 file_string_table_offset
= next_file_string_table_offset
;
2324 next_file_string_table_offset
+= value
;
2328 /* Using the (possibly updated) string table offset, print the
2329 string (if any) associated with this symbol. */
2330 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2331 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2337 *string_offset_ptr
= next_file_string_table_offset
;
2342 const char * section_name
;
2343 const char * string_section_name
;
2344 unsigned string_offset
;
2349 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2352 stab_section_names
* sought
= (stab_section_names
*) names
;
2354 /* Check for section names for which stabsect_name is a prefix, to
2355 handle .stab.N, etc. */
2356 len
= strlen (sought
->section_name
);
2358 /* If the prefix matches, and the files section name ends with a
2359 nul or a digit, then we match. I.e., we want either an exact
2360 match or a section followed by a number. */
2361 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2362 && (section
->name
[len
] == 0
2363 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2366 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2371 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2374 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2380 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2382 stab_section_names s
;
2384 s
.section_name
= stabsect_name
;
2385 s
.string_section_name
= strsect_name
;
2386 s
.string_offset
= 0;
2388 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2394 /* Dump the any sections containing stabs debugging information. */
2397 dump_stabs (bfd
*abfd
)
2399 dump_stabs_section (abfd
, ".stab", ".stabstr");
2400 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2401 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2402 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2406 dump_bfd_header (bfd
*abfd
)
2410 printf (_("architecture: %s, "),
2411 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2412 bfd_get_mach (abfd
)));
2413 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2415 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2416 PF (HAS_RELOC
, "HAS_RELOC");
2417 PF (EXEC_P
, "EXEC_P");
2418 PF (HAS_LINENO
, "HAS_LINENO");
2419 PF (HAS_DEBUG
, "HAS_DEBUG");
2420 PF (HAS_SYMS
, "HAS_SYMS");
2421 PF (HAS_LOCALS
, "HAS_LOCALS");
2422 PF (DYNAMIC
, "DYNAMIC");
2423 PF (WP_TEXT
, "WP_TEXT");
2424 PF (D_PAGED
, "D_PAGED");
2425 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2426 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2427 printf (_("\nstart address 0x"));
2428 bfd_printf_vma (abfd
, abfd
->start_address
);
2434 dump_bfd_private_header (bfd
*abfd
)
2436 bfd_print_private_bfd_data (abfd
, stdout
);
2440 /* Display a section in hexadecimal format with associated characters.
2441 Each line prefixed by the zero padded address. */
2444 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2447 bfd_size_type datasize
;
2448 bfd_size_type addr_offset
;
2449 bfd_size_type start_offset
;
2450 bfd_size_type stop_offset
;
2451 unsigned int opb
= bfd_octets_per_byte (abfd
);
2452 /* Bytes per line. */
2453 const int onaline
= 16;
2458 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2461 if (! process_section_p (section
))
2464 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2467 printf (_("Contents of section %s:\n"), section
->name
);
2469 data
= xmalloc (datasize
);
2471 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2473 /* Compute the address range to display. */
2474 if (start_address
== (bfd_vma
) -1
2475 || start_address
< section
->vma
)
2478 start_offset
= start_address
- section
->vma
;
2480 if (stop_address
== (bfd_vma
) -1)
2481 stop_offset
= datasize
/ opb
;
2484 if (stop_address
< section
->vma
)
2487 stop_offset
= stop_address
- section
->vma
;
2489 if (stop_offset
> datasize
/ opb
)
2490 stop_offset
= datasize
/ opb
;
2495 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2496 if (strlen (buf
) >= sizeof (buf
))
2500 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2502 count
= strlen (buf
) - count
;
2506 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2507 if (strlen (buf
) >= sizeof (buf
))
2511 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2513 count
= strlen (buf
) - count
;
2517 for (addr_offset
= start_offset
;
2518 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2522 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2523 count
= strlen (buf
);
2524 if ((size_t) count
>= sizeof (buf
))
2528 while (count
< width
)
2533 fputs (buf
+ count
- width
, stdout
);
2536 for (j
= addr_offset
* opb
;
2537 j
< addr_offset
* opb
+ onaline
; j
++)
2539 if (j
< stop_offset
* opb
)
2540 printf ("%02x", (unsigned) (data
[j
]));
2548 for (j
= addr_offset
* opb
;
2549 j
< addr_offset
* opb
+ onaline
; j
++)
2551 if (j
>= stop_offset
* opb
)
2554 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2561 /* Actually display the various requested regions. */
2564 dump_data (bfd
*abfd
)
2566 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2569 /* Should perhaps share code and display with nm? */
2572 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2582 printf ("DYNAMIC SYMBOL TABLE:\n");
2588 printf ("SYMBOL TABLE:\n");
2592 printf (_("no symbols\n"));
2594 for (count
= 0; count
< max
; count
++)
2598 if (*current
== NULL
)
2599 printf (_("no information for symbol number %ld\n"), count
);
2601 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2602 printf (_("could not determine the type of symbol number %ld\n"),
2605 else if (process_section_p ((* current
)->section
)
2606 && (dump_special_syms
2607 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2609 const char *name
= (*current
)->name
;
2611 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2615 /* If we want to demangle the name, we demangle it
2616 here, and temporarily clobber it while calling
2617 bfd_print_symbol. FIXME: This is a gross hack. */
2618 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2620 (*current
)->name
= alloc
;
2621 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2622 bfd_print_symbol_all
);
2625 (*current
)->name
= name
;
2630 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2631 bfd_print_symbol_all
);
2641 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2644 char *last_filename
, *last_functionname
;
2645 unsigned int last_line
;
2647 /* Get column headers lined up reasonably. */
2655 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2656 width
= strlen (buf
) - 7;
2658 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2661 last_filename
= NULL
;
2662 last_functionname
= NULL
;
2665 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2668 const char *filename
, *functionname
;
2670 const char *sym_name
;
2671 const char *section_name
;
2673 if (start_address
!= (bfd_vma
) -1
2674 && q
->address
< start_address
)
2676 if (stop_address
!= (bfd_vma
) -1
2677 && q
->address
> stop_address
)
2680 if (with_line_numbers
2682 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2683 &filename
, &functionname
, &line
))
2685 if (functionname
!= NULL
2686 && (last_functionname
== NULL
2687 || strcmp (functionname
, last_functionname
) != 0))
2689 printf ("%s():\n", functionname
);
2690 if (last_functionname
!= NULL
)
2691 free (last_functionname
);
2692 last_functionname
= xstrdup (functionname
);
2696 && (line
!= last_line
2697 || (filename
!= NULL
2698 && last_filename
!= NULL
2699 && strcmp (filename
, last_filename
) != 0)))
2701 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2703 if (last_filename
!= NULL
)
2704 free (last_filename
);
2705 if (filename
== NULL
)
2706 last_filename
= NULL
;
2708 last_filename
= xstrdup (filename
);
2712 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2714 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2715 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2720 section_name
= NULL
;
2723 bfd_printf_vma (abfd
, q
->address
);
2724 if (q
->howto
== NULL
)
2725 printf (" *unknown* ");
2726 else if (q
->howto
->name
)
2727 printf (" %-16s ", q
->howto
->name
);
2729 printf (" %-16d ", q
->howto
->type
);
2731 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2734 if (section_name
== NULL
)
2735 section_name
= "*unknown*";
2736 printf ("[%s]", section_name
);
2742 bfd_printf_vma (abfd
, q
->addend
);
2750 dump_relocs_in_section (bfd
*abfd
,
2752 void *dummy ATTRIBUTE_UNUSED
)
2758 if ( bfd_is_abs_section (section
)
2759 || bfd_is_und_section (section
)
2760 || bfd_is_com_section (section
)
2761 || (! process_section_p (section
))
2762 || ((section
->flags
& SEC_RELOC
) == 0))
2765 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2767 bfd_fatal (bfd_get_filename (abfd
));
2769 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2773 printf (" (none)\n\n");
2777 relpp
= xmalloc (relsize
);
2778 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2781 bfd_fatal (bfd_get_filename (abfd
));
2782 else if (relcount
== 0)
2783 printf (" (none)\n\n");
2787 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2794 dump_relocs (bfd
*abfd
)
2796 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2800 dump_dynamic_relocs (bfd
*abfd
)
2806 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2808 bfd_fatal (bfd_get_filename (abfd
));
2810 printf ("DYNAMIC RELOCATION RECORDS");
2813 printf (" (none)\n\n");
2816 relpp
= xmalloc (relsize
);
2817 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2820 bfd_fatal (bfd_get_filename (abfd
));
2821 else if (relcount
== 0)
2822 printf (" (none)\n\n");
2826 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2833 /* Creates a table of paths, to search for source files. */
2836 add_include_path (const char *path
)
2840 include_path_count
++;
2841 include_paths
= xrealloc (include_paths
,
2842 include_path_count
* sizeof (*include_paths
));
2843 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2844 if (path
[1] == ':' && path
[2] == 0)
2845 path
= concat (path
, ".", (const char *) 0);
2847 include_paths
[include_path_count
- 1] = path
;
2851 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2855 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2857 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2858 section
->vma
+= adjust_section_vma
;
2860 section
->lma
+= adjust_section_vma
;
2864 /* Dump selected contents of ABFD. */
2867 dump_bfd (bfd
*abfd
)
2869 /* If we are adjusting section VMA's, change them all now. Changing
2870 the BFD information is a hack. However, we must do it, or
2871 bfd_find_nearest_line will not do the right thing. */
2872 if (adjust_section_vma
!= 0)
2874 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2875 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2878 if (! dump_debugging_tags
)
2879 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2882 print_arelt_descr (stdout
, abfd
, TRUE
);
2883 if (dump_file_header
)
2884 dump_bfd_header (abfd
);
2885 if (dump_private_headers
)
2886 dump_bfd_private_header (abfd
);
2887 if (! dump_debugging_tags
)
2889 if (dump_section_headers
)
2890 dump_headers (abfd
);
2896 || dump_dwarf_section_info
)
2897 syms
= slurp_symtab (abfd
);
2898 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2899 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2900 dynsyms
= slurp_dynamic_symtab (abfd
);
2903 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2904 dynsymcount
, dynsyms
, &synthsyms
);
2910 dump_symbols (abfd
, FALSE
);
2911 if (dump_dynamic_symtab
)
2912 dump_symbols (abfd
, TRUE
);
2913 if (dump_dwarf_section_info
)
2915 if (dump_stab_section_info
)
2917 if (dump_reloc_info
&& ! disassemble
)
2919 if (dump_dynamic_reloc_info
&& ! disassemble
)
2920 dump_dynamic_relocs (abfd
);
2921 if (dump_section_contents
)
2924 disassemble_data (abfd
);
2930 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2931 if (dhandle
!= NULL
)
2933 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2935 dump_debugging_tags
? TRUE
: FALSE
))
2937 non_fatal (_("%s: printing debugging information failed"),
2938 bfd_get_filename (abfd
));
2968 display_bfd (bfd
*abfd
)
2972 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2978 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2980 nonfatal (bfd_get_filename (abfd
));
2981 list_matching_formats (matching
);
2986 if (bfd_get_error () != bfd_error_file_not_recognized
)
2988 nonfatal (bfd_get_filename (abfd
));
2992 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2998 nonfatal (bfd_get_filename (abfd
));
3000 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3002 list_matching_formats (matching
);
3008 display_file (char *filename
, char *target
)
3013 if (get_file_size (filename
) < 1)
3019 file
= bfd_openr (filename
, target
);
3022 nonfatal (filename
);
3026 /* If the file is an archive, process all of its elements. */
3027 if (bfd_check_format (file
, bfd_archive
))
3029 bfd
*last_arfile
= NULL
;
3031 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3034 bfd_set_error (bfd_error_no_error
);
3036 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3039 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3040 nonfatal (bfd_get_filename (file
));
3044 display_bfd (arfile
);
3046 if (last_arfile
!= NULL
)
3047 bfd_close (last_arfile
);
3048 last_arfile
= arfile
;
3051 if (last_arfile
!= NULL
)
3052 bfd_close (last_arfile
);
3061 main (int argc
, char **argv
)
3064 char *target
= default_target
;
3065 bfd_boolean seenflag
= FALSE
;
3067 #if defined (HAVE_SETLOCALE)
3068 #if defined (HAVE_LC_MESSAGES)
3069 setlocale (LC_MESSAGES
, "");
3071 setlocale (LC_CTYPE
, "");
3074 bindtextdomain (PACKAGE
, LOCALEDIR
);
3075 textdomain (PACKAGE
);
3077 program_name
= *argv
;
3078 xmalloc_set_program_name (program_name
);
3080 START_PROGRESS (program_name
, 0);
3082 expandargv (&argc
, &argv
);
3085 set_default_bfd_target ();
3087 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW",
3088 long_options
, (int *) 0))
3094 break; /* We've been given a long option. */
3099 if (disassembler_options
)
3100 /* Ignore potential memory leak for now. */
3101 disassembler_options
= concat (disassembler_options
, ",",
3102 optarg
, (const char *) NULL
);
3104 disassembler_options
= optarg
;
3107 if (only_used
== only_size
)
3110 only
= xrealloc (only
, only_size
* sizeof (char *));
3112 only
[only_used
++] = optarg
;
3115 display_file_offsets
= TRUE
;
3118 with_line_numbers
= TRUE
;
3127 enum demangling_styles style
;
3129 style
= cplus_demangle_name_to_style (optarg
);
3130 if (style
== unknown_demangling
)
3131 fatal (_("unknown demangling style `%s'"),
3134 cplus_demangle_set_style (style
);
3140 case OPTION_ADJUST_VMA
:
3141 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3143 case OPTION_START_ADDRESS
:
3144 start_address
= parse_vma (optarg
, "--start-address");
3145 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3146 fatal (_("error: the start address should be before the end address"));
3148 case OPTION_STOP_ADDRESS
:
3149 stop_address
= parse_vma (optarg
, "--stop-address");
3150 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3151 fatal (_("error: the stop address should be after the start address"));
3154 if (strcmp (optarg
, "B") == 0)
3155 endian
= BFD_ENDIAN_BIG
;
3156 else if (strcmp (optarg
, "L") == 0)
3157 endian
= BFD_ENDIAN_LITTLE
;
3160 non_fatal (_("unrecognized -E option"));
3165 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3166 endian
= BFD_ENDIAN_BIG
;
3167 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3168 endian
= BFD_ENDIAN_LITTLE
;
3171 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3177 dump_file_header
= TRUE
;
3181 formats_info
= TRUE
;
3185 add_include_path (optarg
);
3188 dump_private_headers
= TRUE
;
3192 dump_private_headers
= TRUE
;
3194 dump_reloc_info
= TRUE
;
3195 dump_file_header
= TRUE
;
3196 dump_ar_hdrs
= TRUE
;
3197 dump_section_headers
= TRUE
;
3205 dump_dynamic_symtab
= TRUE
;
3213 disassemble_zeroes
= TRUE
;
3217 disassemble_all
= TRUE
;
3222 with_source_code
= TRUE
;
3231 dump_debugging_tags
= 1;
3236 dump_dwarf_section_info
= TRUE
;
3239 do_debug_abbrevs
= 1;
3241 do_debug_pubnames
= 1;
3242 do_debug_aranges
= 1;
3243 do_debug_ranges
= 1;
3244 do_debug_frames
= 1;
3245 do_debug_macinfo
= 1;
3250 dump_stab_section_info
= TRUE
;
3254 dump_section_contents
= TRUE
;
3258 dump_reloc_info
= TRUE
;
3262 dump_dynamic_reloc_info
= TRUE
;
3266 dump_ar_hdrs
= TRUE
;
3270 dump_section_headers
= TRUE
;
3278 show_version
= TRUE
;
3288 print_version ("objdump");
3294 exit_status
= display_info ();
3298 display_file ("a.out", target
);
3300 for (; optind
< argc
;)
3301 display_file (argv
[optind
++], target
);
3304 END_PROGRESS (program_name
);