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 /* Prefer a symbol in the current section if we have multple symbols
744 with the same value, as can occur with overlays or zero size
748 && (bfd_asymbol_value (sorted_syms
[min
])
749 == bfd_asymbol_value (sorted_syms
[thisplace
])))
751 if (sorted_syms
[min
]->section
== sec
752 && info
->symbol_is_valid (sorted_syms
[min
], info
))
759 return sorted_syms
[thisplace
];
764 /* If the file is relocatable, and the symbol could be from this
765 section, prefer a symbol from this section over symbols from
766 others, even if the other symbol's value might be closer.
768 Note that this may be wrong for some symbol references if the
769 sections have overlapping memory ranges, but in that case there's
770 no way to tell what's desired without looking at the relocation
773 Also give the target a chance to reject symbols. */
774 want_section
= (aux
->require_sec
775 || ((abfd
->flags
& HAS_RELOC
) != 0
776 && vma
>= bfd_get_section_vma (abfd
, sec
)
777 && vma
< (bfd_get_section_vma (abfd
, sec
)
778 + bfd_section_size (abfd
, sec
) / opb
)));
779 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
780 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
783 long newplace
= sorted_symcount
;
785 for (i
= min
- 1; i
>= 0; i
--)
787 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
788 && info
->symbol_is_valid (sorted_syms
[i
], info
))
790 if (newplace
== sorted_symcount
)
793 if (bfd_asymbol_value (sorted_syms
[i
])
794 != bfd_asymbol_value (sorted_syms
[newplace
]))
797 /* Remember this symbol and keep searching until we reach
798 an earlier address. */
803 if (newplace
!= sorted_symcount
)
804 thisplace
= newplace
;
807 /* We didn't find a good symbol with a smaller value.
808 Look for one with a larger value. */
809 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
811 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
812 && info
->symbol_is_valid (sorted_syms
[i
], info
))
820 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
821 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
822 /* There is no suitable symbol. */
829 return sorted_syms
[thisplace
];
832 /* Print an address and the offset to the nearest symbol. */
835 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
836 bfd_vma vma
, struct disassemble_info
*info
,
837 bfd_boolean skip_zeroes
)
839 objdump_print_value (vma
, info
, skip_zeroes
);
845 (*info
->fprintf_func
) (info
->stream
, " <%s",
846 bfd_get_section_name (abfd
, sec
));
847 secaddr
= bfd_get_section_vma (abfd
, sec
);
850 (*info
->fprintf_func
) (info
->stream
, "-0x");
851 objdump_print_value (secaddr
- vma
, info
, TRUE
);
853 else if (vma
> secaddr
)
855 (*info
->fprintf_func
) (info
->stream
, "+0x");
856 objdump_print_value (vma
- secaddr
, info
, TRUE
);
858 (*info
->fprintf_func
) (info
->stream
, ">");
862 (*info
->fprintf_func
) (info
->stream
, " <");
863 objdump_print_symname (abfd
, info
, sym
);
864 if (bfd_asymbol_value (sym
) > vma
)
866 (*info
->fprintf_func
) (info
->stream
, "-0x");
867 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
869 else if (vma
> bfd_asymbol_value (sym
))
871 (*info
->fprintf_func
) (info
->stream
, "+0x");
872 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
874 (*info
->fprintf_func
) (info
->stream
, ">");
877 if (display_file_offsets
)
878 info
->fprintf_func (info
->stream
, _(" (File Offset: 0x%lx)"),
879 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
882 /* Print an address (VMA), symbolically if possible.
883 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
886 objdump_print_addr (bfd_vma vma
,
887 struct disassemble_info
*info
,
888 bfd_boolean skip_zeroes
)
890 struct objdump_disasm_info
*aux
;
892 bfd_boolean skip_find
= FALSE
;
894 aux
= (struct objdump_disasm_info
*) info
->application_data
;
896 if (sorted_symcount
< 1)
898 (*info
->fprintf_func
) (info
->stream
, "0x");
899 objdump_print_value (vma
, info
, skip_zeroes
);
901 if (display_file_offsets
)
902 info
->fprintf_func (info
->stream
, _(" (File Offset: 0x%lx)"),
903 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
907 if (aux
->reloc
!= NULL
908 && aux
->reloc
->sym_ptr_ptr
!= NULL
909 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
911 sym
= * aux
->reloc
->sym_ptr_ptr
;
913 /* Adjust the vma to the reloc. */
914 vma
+= bfd_asymbol_value (sym
);
916 if (bfd_is_und_section (bfd_get_section (sym
)))
921 sym
= find_symbol_for_address (vma
, info
, NULL
);
923 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
927 /* Print VMA to INFO. This function is passed to the disassembler
931 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
933 objdump_print_addr (vma
, info
, ! prefix_addresses
);
936 /* Determine if the given address has a symbol associated with it. */
939 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
943 sym
= find_symbol_for_address (vma
, info
, NULL
);
945 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
948 /* Hold the last function name and the last line number we displayed
951 static char *prev_functionname
;
952 static unsigned int prev_line
;
954 /* We keep a list of all files that we have seen when doing a
955 disassembly with source, so that we know how much of the file to
956 display. This can be important for inlined functions. */
958 struct print_file_list
960 struct print_file_list
*next
;
961 const char *filename
;
965 const char **linemap
;
971 static struct print_file_list
*print_files
;
973 /* The number of preceding context lines to show when we start
974 displaying a file for the first time. */
976 #define SHOW_PRECEDING_CONTEXT_LINES (5)
978 /* Read a complete file into memory. */
981 slurp_file (const char *fn
, size_t *size
)
984 int ps
= getpagesize ();
989 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
993 if (fstat (fd
, &st
) < 0)
997 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
998 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
999 if (map
!= (char *)-1L)
1005 map
= malloc (*size
);
1006 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
1015 #define line_map_decrease 5
1017 /* Precompute array of lines for a mapped file. */
1019 static const char **
1020 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1022 const char *p
, *lstart
, *end
;
1023 int chars_per_line
= 45; /* First iteration will use 40. */
1024 unsigned int lineno
;
1025 const char **linemap
= NULL
;
1026 unsigned long line_map_size
= 0;
1032 for (p
= map
; p
< end
; p
++)
1036 if (p
+ 1 < end
&& p
[1] == '\r')
1039 else if (*p
== '\r')
1041 if (p
+ 1 < end
&& p
[1] == '\n')
1047 /* End of line found. */
1049 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1051 unsigned long newsize
;
1053 chars_per_line
-= line_map_decrease
;
1054 if (chars_per_line
<= 1)
1056 line_map_size
= size
/ chars_per_line
+ 1;
1057 if (line_map_size
< lineno
+ 1)
1058 line_map_size
= lineno
+ 1;
1059 newsize
= line_map_size
* sizeof (char *);
1060 linemap
= xrealloc (linemap
, newsize
);
1063 linemap
[lineno
++] = lstart
;
1071 /* Tries to open MODNAME, and if successful adds a node to print_files
1072 linked list and returns that node. Returns NULL on failure. */
1074 static struct print_file_list
*
1075 try_print_file_open (const char *origname
, const char *modname
)
1077 struct print_file_list
*p
;
1079 p
= xmalloc (sizeof (struct print_file_list
));
1081 p
->map
= slurp_file (modname
, &p
->mapsize
);
1088 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1090 p
->filename
= origname
;
1091 p
->modname
= modname
;
1092 p
->next
= print_files
;
1098 /* If the the source file, as described in the symtab, is not found
1099 try to locate it in one of the paths specified with -I
1100 If found, add location to print_files linked list. */
1102 static struct print_file_list
*
1103 update_source_path (const char *filename
)
1105 struct print_file_list
*p
;
1109 if (filename
== NULL
)
1112 p
= try_print_file_open (filename
, filename
);
1116 if (include_path_count
== 0)
1119 /* Get the name of the file. */
1120 fname
= strrchr (filename
, '/');
1121 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1123 /* We could have a mixed forward/back slash case. */
1124 char *backslash
= strrchr (filename
, '\\');
1125 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1127 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1128 fname
= filename
+ 1;
1136 /* If file exists under a new path, we need to add it to the list
1137 so that show_line knows about it. */
1138 for (i
= 0; i
< include_path_count
; i
++)
1140 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1142 p
= try_print_file_open (filename
, modname
);
1152 /* Print a source file line. */
1155 print_line (struct print_file_list
*p
, unsigned int line
)
1161 if (line
>= p
->maxline
)
1163 l
= p
->linemap
[line
];
1164 /* Test fwrite return value to quiet glibc warning. */
1165 len
= strcspn (l
, "\n\r");
1166 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1170 /* Print a range of source code lines. */
1173 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1177 while (start
<= end
)
1179 print_line (p
, start
);
1184 /* Show the line number, or the source line, in a disassembly
1188 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1190 const char *filename
;
1191 const char *functionname
;
1194 if (! with_line_numbers
&& ! with_source_code
)
1197 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1198 &functionname
, &line
))
1201 if (filename
!= NULL
&& *filename
== '\0')
1203 if (functionname
!= NULL
&& *functionname
== '\0')
1204 functionname
= NULL
;
1206 if (with_line_numbers
)
1208 if (functionname
!= NULL
1209 && (prev_functionname
== NULL
1210 || strcmp (functionname
, prev_functionname
) != 0))
1211 printf ("%s():\n", functionname
);
1212 if (line
> 0 && line
!= prev_line
)
1213 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1216 if (with_source_code
1220 struct print_file_list
**pp
, *p
;
1223 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1224 if (strcmp ((*pp
)->filename
, filename
) == 0)
1229 p
= update_source_path (filename
);
1231 if (p
!= NULL
&& line
!= p
->last_line
)
1233 if (file_start_context
&& p
->first
)
1237 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1240 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1241 l
= p
->last_line
+ 1;
1243 dump_lines (p
, l
, line
);
1244 p
->last_line
= line
;
1249 if (functionname
!= NULL
1250 && (prev_functionname
== NULL
1251 || strcmp (functionname
, prev_functionname
) != 0))
1253 if (prev_functionname
!= NULL
)
1254 free (prev_functionname
);
1255 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1256 strcpy (prev_functionname
, functionname
);
1259 if (line
> 0 && line
!= prev_line
)
1263 /* Pseudo FILE object for strings. */
1271 /* sprintf to a "stream". */
1273 static int ATTRIBUTE_PRINTF_2
1274 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1281 size_t space
= f
->alloc
- f
->pos
;
1283 va_start (args
, format
);
1284 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1290 f
->alloc
= (f
->alloc
+ n
) * 2;
1291 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1298 /* Returns TRUE if the specified section should be dumped. */
1301 process_section_p (asection
* section
)
1308 for (i
= 0; i
< only_used
; i
++)
1309 if (strcmp (only
[i
], section
->name
) == 0)
1316 /* The number of zeroes we want to see before we start skipping them.
1317 The number is arbitrarily chosen. */
1319 #define DEFAULT_SKIP_ZEROES 8
1321 /* The number of zeroes to skip at the end of a section. If the
1322 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1323 SKIP_ZEROES, they will be disassembled. If there are fewer than
1324 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1325 attempt to avoid disassembling zeroes inserted by section
1328 #define DEFAULT_SKIP_ZEROES_AT_END 3
1330 /* Disassemble some data in memory between given values. */
1333 disassemble_bytes (struct disassemble_info
* info
,
1334 disassembler_ftype disassemble_fn
,
1337 bfd_vma start_offset
,
1338 bfd_vma stop_offset
,
1341 arelent
** relppend
)
1343 struct objdump_disasm_info
*aux
;
1345 int octets_per_line
;
1346 bfd_boolean done_dot
;
1347 int skip_addr_chars
;
1348 bfd_vma addr_offset
;
1349 unsigned int opb
= info
->octets_per_byte
;
1350 unsigned int skip_zeroes
= info
->skip_zeroes
;
1351 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1355 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1359 sfile
.buffer
= xmalloc (sfile
.alloc
);
1363 octets_per_line
= 4;
1365 octets_per_line
= 16;
1367 /* Figure out how many characters to skip at the start of an
1368 address, to make the disassembly look nicer. We discard leading
1369 zeroes in chunks of 4, ensuring that there is always a leading
1371 skip_addr_chars
= 0;
1372 if (! prefix_addresses
)
1380 + bfd_section_size (section
->owner
, section
) / opb
));
1382 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1385 skip_addr_chars
+= 4;
1390 info
->insn_info_valid
= 0;
1393 addr_offset
= start_offset
;
1394 while (addr_offset
< stop_offset
)
1397 bfd_boolean need_nl
= FALSE
;
1398 int previous_octets
;
1400 /* Remember the length of the previous instruction. */
1401 previous_octets
= octets
;
1404 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1406 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1409 if (! disassemble_zeroes
1410 && (info
->insn_info_valid
== 0
1411 || info
->branch_delay_insns
== 0)
1412 && (z
- addr_offset
* opb
>= skip_zeroes
1413 || (z
== stop_offset
* opb
&&
1414 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1416 /* If there are more nonzero octets to follow, we only skip
1417 zeroes in multiples of 4, to try to avoid running over
1418 the start of an instruction which happens to start with
1420 if (z
!= stop_offset
* opb
)
1421 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1423 octets
= z
- addr_offset
* opb
;
1425 /* If we are going to display more data, and we are displaying
1426 file offsets, then tell the user how many zeroes we skip
1427 and the file offset from where we resume dumping. */
1428 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1429 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1431 (long int)(section
->filepos
+ (addr_offset
+ (octets
/ opb
))));
1443 if (with_line_numbers
|| with_source_code
)
1444 show_line (aux
->abfd
, section
, addr_offset
);
1446 if (! prefix_addresses
)
1450 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1451 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1455 printf ("%s:\t", buf
+ skip_addr_chars
);
1459 aux
->require_sec
= TRUE
;
1460 objdump_print_address (section
->vma
+ addr_offset
, info
);
1461 aux
->require_sec
= FALSE
;
1468 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1469 info
->stream
= &sfile
;
1470 info
->bytes_per_line
= 0;
1471 info
->bytes_per_chunk
= 0;
1474 if (info
->disassembler_needs_relocs
1475 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1476 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1477 && *relppp
< relppend
)
1479 bfd_signed_vma distance_to_rel
;
1481 distance_to_rel
= (**relppp
)->address
1482 - (rel_offset
+ addr_offset
);
1484 /* Check to see if the current reloc is associated with
1485 the instruction that we are about to disassemble. */
1486 if (distance_to_rel
== 0
1487 /* FIXME: This is wrong. We are trying to catch
1488 relocs that are addressed part way through the
1489 current instruction, as might happen with a packed
1490 VLIW instruction. Unfortunately we do not know the
1491 length of the current instruction since we have not
1492 disassembled it yet. Instead we take a guess based
1493 upon the length of the previous instruction. The
1494 proper solution is to have a new target-specific
1495 disassembler function which just returns the length
1496 of an instruction at a given address without trying
1497 to display its disassembly. */
1498 || (distance_to_rel
> 0
1499 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1501 info
->flags
= INSN_HAS_RELOC
;
1502 aux
->reloc
= **relppp
;
1508 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1509 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1510 info
->stream
= stdout
;
1511 if (info
->bytes_per_line
!= 0)
1512 octets_per_line
= info
->bytes_per_line
;
1516 printf ("%s\n", sfile
.buffer
);
1524 octets
= octets_per_line
;
1525 if (addr_offset
+ octets
/ opb
> stop_offset
)
1526 octets
= (stop_offset
- addr_offset
) * opb
;
1528 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1530 if (ISPRINT (data
[j
]))
1531 buf
[j
- addr_offset
* opb
] = data
[j
];
1533 buf
[j
- addr_offset
* opb
] = '.';
1535 buf
[j
- addr_offset
* opb
] = '\0';
1538 if (prefix_addresses
1540 : show_raw_insn
>= 0)
1544 /* If ! prefix_addresses and ! wide_output, we print
1545 octets_per_line octets per line. */
1547 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1548 pb
= octets_per_line
;
1550 if (info
->bytes_per_chunk
)
1551 bpc
= info
->bytes_per_chunk
;
1555 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1559 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1561 for (k
= bpc
- 1; k
>= 0; k
--)
1562 printf ("%02x", (unsigned) data
[j
+ k
]);
1567 for (k
= 0; k
< bpc
; k
++)
1568 printf ("%02x", (unsigned) data
[j
+ k
]);
1573 for (; pb
< octets_per_line
; pb
+= bpc
)
1577 for (k
= 0; k
< bpc
; k
++)
1582 /* Separate raw data from instruction by extra space. */
1592 printf ("%s", sfile
.buffer
);
1594 if (prefix_addresses
1596 : show_raw_insn
>= 0)
1604 j
= addr_offset
* opb
+ pb
;
1606 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1607 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1611 printf ("%s:\t", buf
+ skip_addr_chars
);
1613 pb
+= octets_per_line
;
1616 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1620 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1622 for (k
= bpc
- 1; k
>= 0; k
--)
1623 printf ("%02x", (unsigned) data
[j
+ k
]);
1628 for (k
= 0; k
< bpc
; k
++)
1629 printf ("%02x", (unsigned) data
[j
+ k
]);
1642 while ((*relppp
) < relppend
1643 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1645 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1656 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1659 if (q
->howto
== NULL
)
1660 printf (": *unknown*\t");
1661 else if (q
->howto
->name
)
1662 printf (": %s\t", q
->howto
->name
);
1664 printf (": %d\t", q
->howto
->type
);
1666 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1667 printf ("*unknown*");
1670 const char *sym_name
;
1672 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1673 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1674 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1679 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1680 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1681 if (sym_name
== NULL
|| *sym_name
== '\0')
1682 sym_name
= "*unknown*";
1683 printf ("%s", sym_name
);
1690 objdump_print_value (q
->addend
, info
, TRUE
);
1702 addr_offset
+= octets
/ opb
;
1705 free (sfile
.buffer
);
1709 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1711 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1712 struct objdump_disasm_info
* paux
;
1713 unsigned int opb
= pinfo
->octets_per_byte
;
1714 bfd_byte
* data
= NULL
;
1715 bfd_size_type datasize
= 0;
1716 arelent
** rel_pp
= NULL
;
1717 arelent
** rel_ppstart
= NULL
;
1718 arelent
** rel_ppend
;
1719 unsigned long stop_offset
;
1720 asymbol
* sym
= NULL
;
1724 unsigned long addr_offset
;
1726 /* Sections that do not contain machine
1727 code are not normally disassembled. */
1728 if (! disassemble_all
1730 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1731 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1734 if (! process_section_p (section
))
1737 datasize
= bfd_get_section_size (section
);
1741 /* Decide which set of relocs to use. Load them if necessary. */
1742 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1743 if (paux
->dynrelbuf
)
1745 rel_pp
= paux
->dynrelbuf
;
1746 rel_count
= paux
->dynrelcount
;
1747 /* Dynamic reloc addresses are absolute, non-dynamic are section
1748 relative. REL_OFFSET specifies the reloc address corresponding
1749 to the start of this section. */
1750 rel_offset
= section
->vma
;
1758 if ((section
->flags
& SEC_RELOC
) != 0
1759 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1763 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1765 bfd_fatal (bfd_get_filename (abfd
));
1769 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1770 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1772 bfd_fatal (bfd_get_filename (abfd
));
1774 /* Sort the relocs by address. */
1775 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1780 rel_ppend
= rel_pp
+ rel_count
;
1782 data
= xmalloc (datasize
);
1784 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1786 paux
->sec
= section
;
1787 pinfo
->buffer
= data
;
1788 pinfo
->buffer_vma
= section
->vma
;
1789 pinfo
->buffer_length
= datasize
;
1790 pinfo
->section
= section
;
1792 if (start_address
== (bfd_vma
) -1
1793 || start_address
< pinfo
->buffer_vma
)
1796 addr_offset
= start_address
- pinfo
->buffer_vma
;
1798 if (stop_address
== (bfd_vma
) -1)
1799 stop_offset
= datasize
/ opb
;
1802 if (stop_address
< pinfo
->buffer_vma
)
1805 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1806 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1807 stop_offset
= pinfo
->buffer_length
/ opb
;
1810 /* Skip over the relocs belonging to addresses below the
1812 while (rel_pp
< rel_ppend
1813 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1816 if (addr_offset
< stop_offset
)
1817 printf (_("\nDisassembly of section %s:\n"), section
->name
);
1819 /* Find the nearest symbol forwards from our current position. */
1820 paux
->require_sec
= TRUE
;
1821 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1822 paux
->require_sec
= FALSE
;
1824 /* Disassemble a block of instructions up to the address associated with
1825 the symbol we have just found. Then print the symbol and find the
1826 next symbol on. Repeat until we have disassembled the entire section
1827 or we have reached the end of the address range we are interested in. */
1828 while (addr_offset
< stop_offset
)
1832 unsigned long nextstop_offset
;
1835 addr
= section
->vma
+ addr_offset
;
1837 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1842 (x
< sorted_symcount
1843 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1847 pinfo
->symbols
= sorted_syms
+ place
;
1848 pinfo
->num_symbols
= x
- place
;
1849 pinfo
->symtab_pos
= place
;
1853 pinfo
->symbols
= NULL
;
1854 pinfo
->num_symbols
= 0;
1855 pinfo
->symtab_pos
= -1;
1858 if (! prefix_addresses
)
1860 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1861 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1863 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1866 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1868 else if (sym
== NULL
)
1872 #define is_valid_next_sym(SYM) \
1873 ((SYM)->section == section \
1874 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1875 && pinfo->symbol_is_valid (SYM, pinfo))
1877 /* Search forward for the next appropriate symbol in
1878 SECTION. Note that all the symbols are sorted
1879 together into one big array, and that some sections
1880 may have overlapping addresses. */
1881 while (place
< sorted_symcount
1882 && ! is_valid_next_sym (sorted_syms
[place
]))
1885 if (place
>= sorted_symcount
)
1888 nextsym
= sorted_syms
[place
];
1891 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1892 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1893 else if (nextsym
== NULL
)
1894 nextstop_offset
= stop_offset
;
1896 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1898 if (nextstop_offset
> stop_offset
)
1899 nextstop_offset
= stop_offset
;
1901 /* If a symbol is explicitly marked as being an object
1902 rather than a function, just dump the bytes without
1903 disassembling them. */
1906 || bfd_asymbol_value (sym
) > addr
1907 || ((sym
->flags
& BSF_OBJECT
) == 0
1908 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1910 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1912 || (sym
->flags
& BSF_FUNCTION
) != 0)
1917 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1918 addr_offset
, nextstop_offset
,
1919 rel_offset
, &rel_pp
, rel_ppend
);
1921 addr_offset
= nextstop_offset
;
1927 if (rel_ppstart
!= NULL
)
1931 /* Disassemble the contents of an object file. */
1934 disassemble_data (bfd
*abfd
)
1936 struct disassemble_info disasm_info
;
1937 struct objdump_disasm_info aux
;
1941 prev_functionname
= NULL
;
1944 /* We make a copy of syms to sort. We don't want to sort syms
1945 because that will screw up the relocs. */
1946 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1947 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1948 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1949 sorted_symcount
* sizeof (asymbol
*));
1951 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1953 for (i
= 0; i
< synthcount
; ++i
)
1955 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1959 /* Sort the symbols into section and symbol order. */
1960 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1962 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1964 disasm_info
.application_data
= (void *) &aux
;
1966 aux
.require_sec
= FALSE
;
1967 aux
.dynrelbuf
= NULL
;
1968 aux
.dynrelcount
= 0;
1971 disasm_info
.print_address_func
= objdump_print_address
;
1972 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1974 if (machine
!= NULL
)
1976 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1979 fatal (_("Can't use supplied machine %s"), machine
);
1981 abfd
->arch_info
= info
;
1984 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1986 struct bfd_target
*xvec
;
1988 xvec
= xmalloc (sizeof (struct bfd_target
));
1989 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1990 xvec
->byteorder
= endian
;
1994 /* Use libopcodes to locate a suitable disassembler. */
1995 aux
.disassemble_fn
= disassembler (abfd
);
1996 if (!aux
.disassemble_fn
)
1998 non_fatal (_("Can't disassemble for architecture %s\n"),
1999 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2004 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2005 disasm_info
.arch
= bfd_get_arch (abfd
);
2006 disasm_info
.mach
= bfd_get_mach (abfd
);
2007 disasm_info
.disassembler_options
= disassembler_options
;
2008 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2009 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2010 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2011 disasm_info
.disassembler_needs_relocs
= FALSE
;
2013 if (bfd_big_endian (abfd
))
2014 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2015 else if (bfd_little_endian (abfd
))
2016 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2018 /* ??? Aborting here seems too drastic. We could default to big or little
2020 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2022 /* Allow the target to customize the info structure. */
2023 disassemble_init_for_target (& disasm_info
);
2025 /* Pre-load the dynamic relocs if we are going
2026 to be dumping them along with the disassembly. */
2027 if (dump_dynamic_reloc_info
)
2029 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2032 bfd_fatal (bfd_get_filename (abfd
));
2036 aux
.dynrelbuf
= xmalloc (relsize
);
2037 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2040 if (aux
.dynrelcount
< 0)
2041 bfd_fatal (bfd_get_filename (abfd
));
2043 /* Sort the relocs by address. */
2044 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2048 disasm_info
.symtab
= sorted_syms
;
2049 disasm_info
.symtab_size
= sorted_symcount
;
2051 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2053 if (aux
.dynrelbuf
!= NULL
)
2054 free (aux
.dynrelbuf
);
2059 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2061 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2065 int section_is_compressed
;
2067 /* If it is already loaded, do nothing. */
2068 if (section
->start
!= NULL
)
2071 /* Locate the debug section. */
2072 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2075 section
->name
= section
->uncompressed_name
;
2076 section_is_compressed
= 0;
2080 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2083 section
->name
= section
->compressed_name
;
2084 section_is_compressed
= 1;
2090 /* Compute a bias to be added to offsets found within the DWARF debug
2091 information. These offsets are meant to be relative to the start of
2092 the dwarf section, and hence the bias should be 0. For MACH-O however
2093 a dwarf section is really just a region of a much larger section and so
2094 the bias is the address of the start of that area within the larger
2095 section. This test is important for PE and COFF based targets which
2096 use DWARF debug information, since unlike ELF, they do not allow the
2097 dwarf sections to be placed at address 0. */
2098 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2099 section
->address
= bfd_get_section_vma (abfd
, sec
);
2101 section
->address
= 0;
2103 section
->size
= bfd_get_section_size (sec
);
2104 section
->start
= xmalloc (section
->size
);
2106 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2107 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2112 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2117 free_debug_section (debug
);
2118 printf (_("\nCan't get contents for section '%s'.\n"),
2123 if (section_is_compressed
)
2125 bfd_size_type size
= section
->size
;
2126 if (! bfd_uncompress_section_contents (§ion
->start
, &size
))
2128 free_debug_section (debug
);
2129 printf (_("\nCan't uncompress section '%s'.\n"), section
->name
);
2132 section
->size
= size
;
2139 free_debug_section (enum dwarf_section_display_enum debug
)
2141 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2143 if (section
->start
== NULL
)
2146 free ((char *) section
->start
);
2147 section
->start
= NULL
;
2148 section
->address
= 0;
2153 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2154 void *arg ATTRIBUTE_UNUSED
)
2156 const char *name
= bfd_get_section_name (abfd
, section
);
2158 enum dwarf_section_display_enum i
;
2160 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2161 match
= ".debug_info";
2165 for (i
= 0; i
< max
; i
++)
2166 if (strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2167 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2169 if (!debug_displays
[i
].eh_frame
)
2171 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2173 if (load_debug_section (i
, abfd
))
2175 debug_displays
[i
].display (sec
, abfd
);
2177 if (i
!= info
&& i
!= abbrev
)
2178 free_debug_section (i
);
2185 static const char *mach_o_uncompressed_dwarf_sections
[] = {
2186 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2187 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2188 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2189 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2190 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2191 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2192 ".eh_frame", /* .eh_frame */
2193 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2194 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2195 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2196 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2197 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2198 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2199 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2200 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2201 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2204 static const char *mach_o_compressed_dwarf_sections
[] = {
2205 "LC_SEGMENT.__DWARFA.__zdebug_abbrev", /* .zdebug_abbrev */
2206 "LC_SEGMENT.__DWARFA.__zdebug_aranges", /* .zdebug_aranges */
2207 "LC_SEGMENT.__DWARFA.__zdebug_frame", /* .zdebug_frame */
2208 "LC_SEGMENT.__DWARFA.__zdebug_info", /* .zdebug_info */
2209 "LC_SEGMENT.__DWARFA.__zdebug_line", /* .zdebug_line */
2210 "LC_SEGMENT.__DWARFA.__zdebug_pubnames", /* .zdebug_pubnames */
2211 ".eh_frame", /* .eh_frame */
2212 "LC_SEGMENT.__DWARFA.__zdebug_macinfo", /* .zdebug_macinfo */
2213 "LC_SEGMENT.__DWARFA.__zdebug_str", /* .zdebug_str */
2214 "LC_SEGMENT.__DWARFA.__zdebug_loc", /* .zdebug_loc */
2215 "LC_SEGMENT.__DWARFA.__zdebug_pubtypes", /* .zdebug_pubtypes */
2216 "LC_SEGMENT.__DWARFA.__zdebug_ranges", /* .zdebug_ranges */
2217 "LC_SEGMENT.__DWARFA.__zdebug_static_func", /* .zdebug_static_func */
2218 "LC_SEGMENT.__DWARFA.__zdebug_static_vars", /* .zdebug_static_vars */
2219 "LC_SEGMENT.__DWARFA.__zdebug_types", /* .zdebug_types */
2220 "LC_SEGMENT.__DWARFA.__zdebug_weaknames" /* .zdebug_weaknames */
2223 static const char *generic_uncompressed_dwarf_sections
[max
];
2224 static const char *generic_compressed_dwarf_sections
[max
];
2227 check_mach_o_dwarf (bfd
*abfd
)
2229 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2230 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2231 enum dwarf_section_display_enum i
;
2233 if (generic_uncompressed_dwarf_sections
[0] == NULL
)
2234 for (i
= 0; i
< max
; i
++)
2236 generic_uncompressed_dwarf_sections
[i
]
2237 = debug_displays
[i
].section
.uncompressed_name
;
2238 generic_compressed_dwarf_sections
[i
]
2239 = debug_displays
[i
].section
.compressed_name
;
2242 if (old_flavour
!= current_flavour
)
2244 if (current_flavour
== bfd_target_mach_o_flavour
)
2245 for (i
= 0; i
< max
; i
++)
2247 debug_displays
[i
].section
.uncompressed_name
2248 = mach_o_uncompressed_dwarf_sections
[i
];
2249 debug_displays
[i
].section
.compressed_name
2250 = mach_o_compressed_dwarf_sections
[i
];
2252 else if (old_flavour
== bfd_target_mach_o_flavour
)
2253 for (i
= 0; i
< max
; i
++)
2255 debug_displays
[i
].section
.uncompressed_name
2256 = generic_uncompressed_dwarf_sections
[i
];
2257 debug_displays
[i
].section
.compressed_name
2258 = generic_compressed_dwarf_sections
[i
];
2261 old_flavour
= current_flavour
;
2265 /* Dump the dwarf debugging information. */
2268 dump_dwarf (bfd
*abfd
)
2270 is_relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2272 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2273 targets will return 64. */
2274 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2276 if (bfd_big_endian (abfd
))
2277 byte_get
= byte_get_big_endian
;
2278 else if (bfd_little_endian (abfd
))
2279 byte_get
= byte_get_little_endian
;
2283 check_mach_o_dwarf (abfd
);
2285 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2287 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2288 init_dwarf_regnames (bed
->elf_machine_code
);
2291 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2293 free_debug_memory ();
2296 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2297 it. Return NULL on failure. */
2300 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2306 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2307 if (stabsect
== NULL
)
2309 printf (_("No %s section present\n\n"), sect_name
);
2313 size
= bfd_section_size (abfd
, stabsect
);
2314 contents
= xmalloc (size
);
2316 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2318 non_fatal (_("Reading %s section of %s failed: %s"),
2319 sect_name
, bfd_get_filename (abfd
),
2320 bfd_errmsg (bfd_get_error ()));
2331 /* Stabs entries use a 12 byte format:
2332 4 byte string table index
2334 1 byte stab other field
2335 2 byte stab desc field
2337 FIXME: This will have to change for a 64 bit object format. */
2339 #define STRDXOFF (0)
2341 #define OTHEROFF (5)
2344 #define STABSIZE (12)
2346 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2347 using string table section STRSECT_NAME (in `strtab'). */
2350 print_section_stabs (bfd
*abfd
,
2351 const char *stabsect_name
,
2352 unsigned *string_offset_ptr
)
2355 unsigned file_string_table_offset
= 0;
2356 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2357 bfd_byte
*stabp
, *stabs_end
;
2360 stabs_end
= stabp
+ stab_size
;
2362 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2363 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2365 /* Loop through all symbols and print them.
2367 We start the index at -1 because there is a dummy symbol on
2368 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2369 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2373 unsigned char type
, other
;
2374 unsigned short desc
;
2377 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2378 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2379 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2380 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2381 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2383 printf ("\n%-6d ", i
);
2384 /* Either print the stab name, or, if unnamed, print its number
2385 again (makes consistent formatting for tools like awk). */
2386 name
= bfd_get_stab_name (type
);
2388 printf ("%-6s", name
);
2389 else if (type
== N_UNDF
)
2392 printf ("%-6d", type
);
2393 printf (" %-6d %-6d ", other
, desc
);
2394 bfd_printf_vma (abfd
, value
);
2395 printf (" %-6lu", strx
);
2397 /* Symbols with type == 0 (N_UNDF) specify the length of the
2398 string table associated with this file. We use that info
2399 to know how to relocate the *next* file's string table indices. */
2402 file_string_table_offset
= next_file_string_table_offset
;
2403 next_file_string_table_offset
+= value
;
2407 /* Using the (possibly updated) string table offset, print the
2408 string (if any) associated with this symbol. */
2409 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2410 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2416 *string_offset_ptr
= next_file_string_table_offset
;
2421 const char * section_name
;
2422 const char * string_section_name
;
2423 unsigned string_offset
;
2428 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2431 stab_section_names
* sought
= (stab_section_names
*) names
;
2433 /* Check for section names for which stabsect_name is a prefix, to
2434 handle .stab.N, etc. */
2435 len
= strlen (sought
->section_name
);
2437 /* If the prefix matches, and the files section name ends with a
2438 nul or a digit, then we match. I.e., we want either an exact
2439 match or a section followed by a number. */
2440 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2441 && (section
->name
[len
] == 0
2442 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2445 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2450 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2453 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2459 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2461 stab_section_names s
;
2463 s
.section_name
= stabsect_name
;
2464 s
.string_section_name
= strsect_name
;
2465 s
.string_offset
= 0;
2467 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2473 /* Dump the any sections containing stabs debugging information. */
2476 dump_stabs (bfd
*abfd
)
2478 dump_stabs_section (abfd
, ".stab", ".stabstr");
2479 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2480 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2481 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2485 dump_bfd_header (bfd
*abfd
)
2489 printf (_("architecture: %s, "),
2490 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2491 bfd_get_mach (abfd
)));
2492 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2494 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2495 PF (HAS_RELOC
, "HAS_RELOC");
2496 PF (EXEC_P
, "EXEC_P");
2497 PF (HAS_LINENO
, "HAS_LINENO");
2498 PF (HAS_DEBUG
, "HAS_DEBUG");
2499 PF (HAS_SYMS
, "HAS_SYMS");
2500 PF (HAS_LOCALS
, "HAS_LOCALS");
2501 PF (DYNAMIC
, "DYNAMIC");
2502 PF (WP_TEXT
, "WP_TEXT");
2503 PF (D_PAGED
, "D_PAGED");
2504 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2505 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2506 printf (_("\nstart address 0x"));
2507 bfd_printf_vma (abfd
, abfd
->start_address
);
2513 dump_bfd_private_header (bfd
*abfd
)
2515 bfd_print_private_bfd_data (abfd
, stdout
);
2519 /* Display a section in hexadecimal format with associated characters.
2520 Each line prefixed by the zero padded address. */
2523 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2526 bfd_size_type datasize
;
2527 bfd_size_type addr_offset
;
2528 bfd_size_type start_offset
;
2529 bfd_size_type stop_offset
;
2530 unsigned int opb
= bfd_octets_per_byte (abfd
);
2531 /* Bytes per line. */
2532 const int onaline
= 16;
2537 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2540 if (! process_section_p (section
))
2543 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2546 /* Compute the address range to display. */
2547 if (start_address
== (bfd_vma
) -1
2548 || start_address
< section
->vma
)
2551 start_offset
= start_address
- section
->vma
;
2553 if (stop_address
== (bfd_vma
) -1)
2554 stop_offset
= datasize
/ opb
;
2557 if (stop_address
< section
->vma
)
2560 stop_offset
= stop_address
- section
->vma
;
2562 if (stop_offset
> datasize
/ opb
)
2563 stop_offset
= datasize
/ opb
;
2566 if (start_offset
>= stop_offset
)
2569 printf (_("Contents of section %s:"), section
->name
);
2570 if (display_file_offsets
)
2571 printf (_(" (Starting at file offset: 0x%lx)"), (long int)(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
);
2816 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2819 if (section_name
== NULL
)
2820 section_name
= "*unknown*";
2821 printf ("[%s]", section_name
);
2827 bfd_printf_vma (abfd
, q
->addend
);
2835 dump_relocs_in_section (bfd
*abfd
,
2837 void *dummy ATTRIBUTE_UNUSED
)
2843 if ( bfd_is_abs_section (section
)
2844 || bfd_is_und_section (section
)
2845 || bfd_is_com_section (section
)
2846 || (! process_section_p (section
))
2847 || ((section
->flags
& SEC_RELOC
) == 0))
2850 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2852 bfd_fatal (bfd_get_filename (abfd
));
2854 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2858 printf (" (none)\n\n");
2862 relpp
= xmalloc (relsize
);
2863 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2866 bfd_fatal (bfd_get_filename (abfd
));
2867 else if (relcount
== 0)
2868 printf (" (none)\n\n");
2872 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2879 dump_relocs (bfd
*abfd
)
2881 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2885 dump_dynamic_relocs (bfd
*abfd
)
2891 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2893 bfd_fatal (bfd_get_filename (abfd
));
2895 printf ("DYNAMIC RELOCATION RECORDS");
2898 printf (" (none)\n\n");
2901 relpp
= xmalloc (relsize
);
2902 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2905 bfd_fatal (bfd_get_filename (abfd
));
2906 else if (relcount
== 0)
2907 printf (" (none)\n\n");
2911 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2918 /* Creates a table of paths, to search for source files. */
2921 add_include_path (const char *path
)
2925 include_path_count
++;
2926 include_paths
= xrealloc (include_paths
,
2927 include_path_count
* sizeof (*include_paths
));
2928 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2929 if (path
[1] == ':' && path
[2] == 0)
2930 path
= concat (path
, ".", (const char *) 0);
2932 include_paths
[include_path_count
- 1] = path
;
2936 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2940 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2942 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2943 section
->vma
+= adjust_section_vma
;
2945 section
->lma
+= adjust_section_vma
;
2949 /* Dump selected contents of ABFD. */
2952 dump_bfd (bfd
*abfd
)
2954 /* If we are adjusting section VMA's, change them all now. Changing
2955 the BFD information is a hack. However, we must do it, or
2956 bfd_find_nearest_line will not do the right thing. */
2957 if (adjust_section_vma
!= 0)
2959 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2960 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2963 if (! dump_debugging_tags
)
2964 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2967 print_arelt_descr (stdout
, abfd
, TRUE
);
2968 if (dump_file_header
)
2969 dump_bfd_header (abfd
);
2970 if (dump_private_headers
)
2971 dump_bfd_private_header (abfd
);
2972 if (! dump_debugging_tags
)
2974 if (dump_section_headers
)
2975 dump_headers (abfd
);
2981 || dump_dwarf_section_info
)
2982 syms
= slurp_symtab (abfd
);
2983 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2984 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2985 dynsyms
= slurp_dynamic_symtab (abfd
);
2988 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2989 dynsymcount
, dynsyms
, &synthsyms
);
2995 dump_symbols (abfd
, FALSE
);
2996 if (dump_dynamic_symtab
)
2997 dump_symbols (abfd
, TRUE
);
2998 if (dump_dwarf_section_info
)
3000 if (dump_stab_section_info
)
3002 if (dump_reloc_info
&& ! disassemble
)
3004 if (dump_dynamic_reloc_info
&& ! disassemble
)
3005 dump_dynamic_relocs (abfd
);
3006 if (dump_section_contents
)
3009 disassemble_data (abfd
);
3015 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
3016 if (dhandle
!= NULL
)
3018 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
3020 dump_debugging_tags
? TRUE
: FALSE
))
3022 non_fatal (_("%s: printing debugging information failed"),
3023 bfd_get_filename (abfd
));
3027 /* PR 6483: If there was no STABS or IEEE debug
3028 info in the file, try DWARF instead. */
3029 else if (! dump_dwarf_section_info
)
3059 display_bfd (bfd
*abfd
)
3063 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
3069 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3071 nonfatal (bfd_get_filename (abfd
));
3072 list_matching_formats (matching
);
3077 if (bfd_get_error () != bfd_error_file_not_recognized
)
3079 nonfatal (bfd_get_filename (abfd
));
3083 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
3089 nonfatal (bfd_get_filename (abfd
));
3091 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
3093 list_matching_formats (matching
);
3099 display_file (char *filename
, char *target
)
3104 if (get_file_size (filename
) < 1)
3110 file
= bfd_openr (filename
, target
);
3113 nonfatal (filename
);
3117 /* If the file is an archive, process all of its elements. */
3118 if (bfd_check_format (file
, bfd_archive
))
3120 bfd
*last_arfile
= NULL
;
3122 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3125 bfd_set_error (bfd_error_no_error
);
3127 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3130 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3131 nonfatal (bfd_get_filename (file
));
3135 display_bfd (arfile
);
3137 if (last_arfile
!= NULL
)
3138 bfd_close (last_arfile
);
3139 last_arfile
= arfile
;
3142 if (last_arfile
!= NULL
)
3143 bfd_close (last_arfile
);
3152 main (int argc
, char **argv
)
3155 char *target
= default_target
;
3156 bfd_boolean seenflag
= FALSE
;
3158 #if defined (HAVE_SETLOCALE)
3159 #if defined (HAVE_LC_MESSAGES)
3160 setlocale (LC_MESSAGES
, "");
3162 setlocale (LC_CTYPE
, "");
3165 bindtextdomain (PACKAGE
, LOCALEDIR
);
3166 textdomain (PACKAGE
);
3168 program_name
= *argv
;
3169 xmalloc_set_program_name (program_name
);
3171 START_PROGRESS (program_name
, 0);
3173 expandargv (&argc
, &argv
);
3176 set_default_bfd_target ();
3178 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW",
3179 long_options
, (int *) 0))
3185 break; /* We've been given a long option. */
3190 if (disassembler_options
)
3191 /* Ignore potential memory leak for now. */
3192 disassembler_options
= concat (disassembler_options
, ",",
3193 optarg
, (const char *) NULL
);
3195 disassembler_options
= optarg
;
3198 if (only_used
== only_size
)
3201 only
= xrealloc (only
, only_size
* sizeof (char *));
3203 only
[only_used
++] = optarg
;
3206 display_file_offsets
= TRUE
;
3209 with_line_numbers
= TRUE
;
3218 enum demangling_styles style
;
3220 style
= cplus_demangle_name_to_style (optarg
);
3221 if (style
== unknown_demangling
)
3222 fatal (_("unknown demangling style `%s'"),
3225 cplus_demangle_set_style (style
);
3231 case OPTION_ADJUST_VMA
:
3232 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3234 case OPTION_START_ADDRESS
:
3235 start_address
= parse_vma (optarg
, "--start-address");
3236 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3237 fatal (_("error: the start address should be before the end address"));
3239 case OPTION_STOP_ADDRESS
:
3240 stop_address
= parse_vma (optarg
, "--stop-address");
3241 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
3242 fatal (_("error: the stop address should be after the start address"));
3245 if (strcmp (optarg
, "B") == 0)
3246 endian
= BFD_ENDIAN_BIG
;
3247 else if (strcmp (optarg
, "L") == 0)
3248 endian
= BFD_ENDIAN_LITTLE
;
3251 non_fatal (_("unrecognized -E option"));
3256 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3257 endian
= BFD_ENDIAN_BIG
;
3258 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3259 endian
= BFD_ENDIAN_LITTLE
;
3262 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3268 dump_file_header
= TRUE
;
3272 formats_info
= TRUE
;
3276 add_include_path (optarg
);
3279 dump_private_headers
= TRUE
;
3283 dump_private_headers
= TRUE
;
3285 dump_reloc_info
= TRUE
;
3286 dump_file_header
= TRUE
;
3287 dump_ar_hdrs
= TRUE
;
3288 dump_section_headers
= TRUE
;
3296 dump_dynamic_symtab
= TRUE
;
3304 disassemble_zeroes
= TRUE
;
3308 disassemble_all
= TRUE
;
3313 with_source_code
= TRUE
;
3322 dump_debugging_tags
= 1;
3327 dump_dwarf_section_info
= TRUE
;
3330 do_debug_abbrevs
= 1;
3332 do_debug_pubnames
= 1;
3333 do_debug_aranges
= 1;
3334 do_debug_ranges
= 1;
3335 do_debug_frames
= 1;
3336 do_debug_macinfo
= 1;
3341 dump_stab_section_info
= TRUE
;
3345 dump_section_contents
= TRUE
;
3349 dump_reloc_info
= TRUE
;
3353 dump_dynamic_reloc_info
= TRUE
;
3357 dump_ar_hdrs
= TRUE
;
3361 dump_section_headers
= TRUE
;
3369 show_version
= TRUE
;
3379 print_version ("objdump");
3385 exit_status
= display_info ();
3389 display_file ("a.out", target
);
3391 for (; optind
< argc
;)
3392 display_file (argv
[optind
++], target
);
3395 END_PROGRESS (program_name
);