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
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 2, 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, MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
57 #include "safe-ctype.h"
59 #include "libiberty.h"
70 /* Internal headers for the ELF .stab-dump code - sorry. */
71 #define BYTES_IN_WORD 32
72 #include "aout/aout64.h"
75 static int exit_status
= 0;
77 static char *default_target
= NULL
; /* Default at runtime. */
79 /* The following variables are set based on arguments passed on the
81 static int show_version
= 0; /* Show the version number. */
82 static int dump_section_contents
; /* -s */
83 static int dump_section_headers
; /* -h */
84 static bfd_boolean dump_file_header
; /* -f */
85 static int dump_symtab
; /* -t */
86 static int dump_dynamic_symtab
; /* -T */
87 static int dump_reloc_info
; /* -r */
88 static int dump_dynamic_reloc_info
; /* -R */
89 static int dump_ar_hdrs
; /* -a */
90 static int dump_private_headers
; /* -p */
91 static int prefix_addresses
; /* --prefix-addresses */
92 static int with_line_numbers
; /* -l */
93 static bfd_boolean with_source_code
; /* -S */
94 static int show_raw_insn
; /* --show-raw-insn */
95 static int dump_dwarf_section_info
; /* --dwarf */
96 static int dump_stab_section_info
; /* --stabs */
97 static int do_demangle
; /* -C, --demangle */
98 static bfd_boolean disassemble
; /* -d */
99 static bfd_boolean disassemble_all
; /* -D */
100 static int disassemble_zeroes
; /* --disassemble-zeroes */
101 static bfd_boolean formats_info
; /* -i */
102 static int wide_output
; /* -w */
103 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
104 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
105 static int dump_debugging
; /* --debugging */
106 static int dump_debugging_tags
; /* --debugging-tags */
107 static int dump_special_syms
= 0; /* --special-syms */
108 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
109 static int file_start_context
= 0; /* --file-start-context */
111 /* Pointer to an array of section names provided by
112 one or more "-j secname" command line options. */
114 /* The total number of slots in the only[] array. */
115 static size_t only_size
= 0;
116 /* The number of occupied slots in the only[] array. */
117 static size_t only_used
= 0;
119 /* Variables for handling include file path table. */
120 static const char **include_paths
;
121 static int include_path_count
;
123 /* Extra info to pass to the section disassembler and address printing
125 struct objdump_disasm_info
129 bfd_boolean require_sec
;
130 arelent
** dynrelbuf
;
132 disassembler_ftype disassemble_fn
;
136 /* Architecture to disassemble for, or default if NULL. */
137 static char *machine
= NULL
;
139 /* Target specific options to the disassembler. */
140 static char *disassembler_options
= NULL
;
142 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
143 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
145 /* The symbol table. */
146 static asymbol
**syms
;
148 /* Number of symbols in `syms'. */
149 static long symcount
= 0;
151 /* The sorted symbol table. */
152 static asymbol
**sorted_syms
;
154 /* Number of symbols in `sorted_syms'. */
155 static long sorted_symcount
= 0;
157 /* The dynamic symbol table. */
158 static asymbol
**dynsyms
;
160 /* The synthetic symbol table. */
161 static asymbol
*synthsyms
;
162 static long synthcount
= 0;
164 /* Number of symbols in `dynsyms'. */
165 static long dynsymcount
= 0;
167 static bfd_byte
*stabs
;
168 static bfd_size_type stab_size
;
171 static bfd_size_type stabstr_size
;
174 usage (FILE *stream
, int status
)
176 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
177 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
178 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
179 fprintf (stream
, _("\
180 -a, --archive-headers Display archive header information\n\
181 -f, --file-headers Display the contents of the overall file header\n\
182 -p, --private-headers Display object format specific file header contents\n\
183 -h, --[section-]headers Display the contents of the section headers\n\
184 -x, --all-headers Display the contents of all headers\n\
185 -d, --disassemble Display assembler contents of executable sections\n\
186 -D, --disassemble-all Display assembler contents of all sections\n\
187 -S, --source Intermix source code with disassembly\n\
188 -s, --full-contents Display the full contents of all sections requested\n\
189 -g, --debugging Display debug information in object file\n\
190 -e, --debugging-tags Display debug information using ctags style\n\
191 -G, --stabs Display (in raw form) any STABS info in the file\n\
192 -W, --dwarf Display DWARF info in the file\n\
193 -t, --syms Display the contents of the symbol table(s)\n\
194 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
195 -r, --reloc Display the relocation entries in the file\n\
196 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
197 @<file> Read options from <file>\n\
198 -v, --version Display this program's version number\n\
199 -i, --info List object formats and architectures supported\n\
200 -H, --help Display this information\n\
204 fprintf (stream
, _("\n The following switches are optional:\n"));
205 fprintf (stream
, _("\
206 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
207 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
208 -j, --section=NAME Only display information for section NAME\n\
209 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
210 -EB --endian=big Assume big endian format when disassembling\n\
211 -EL --endian=little Assume little endian format when disassembling\n\
212 --file-start-context Include context from start of file (with -S)\n\
213 -I, --include=DIR Add DIR to search list for source files\n\
214 -l, --line-numbers Include line numbers and filenames in output\n\
215 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
216 The STYLE, if specified, can be `auto', `gnu',\n\
217 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
219 -w, --wide Format output for more than 80 columns\n\
220 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
221 --start-address=ADDR Only process data whose address is >= ADDR\n\
222 --stop-address=ADDR Only process data whose address is <= ADDR\n\
223 --prefix-addresses Print complete address alongside disassembly\n\
224 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
225 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
226 --special-syms Include special symbols in symbol dumps\n\
228 list_supported_targets (program_name
, stream
);
229 list_supported_architectures (program_name
, stream
);
231 disassembler_usage (stream
);
233 if (REPORT_BUGS_TO
[0] && status
== 0)
234 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
238 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
242 OPTION_START_ADDRESS
,
247 static struct option long_options
[]=
249 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
250 {"all-headers", no_argument
, NULL
, 'x'},
251 {"private-headers", no_argument
, NULL
, 'p'},
252 {"architecture", required_argument
, NULL
, 'm'},
253 {"archive-headers", no_argument
, NULL
, 'a'},
254 {"debugging", no_argument
, NULL
, 'g'},
255 {"debugging-tags", no_argument
, NULL
, 'e'},
256 {"demangle", optional_argument
, NULL
, 'C'},
257 {"disassemble", no_argument
, NULL
, 'd'},
258 {"disassemble-all", no_argument
, NULL
, 'D'},
259 {"disassembler-options", required_argument
, NULL
, 'M'},
260 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
261 {"dynamic-reloc", no_argument
, NULL
, 'R'},
262 {"dynamic-syms", no_argument
, NULL
, 'T'},
263 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
264 {"file-headers", no_argument
, NULL
, 'f'},
265 {"file-start-context", no_argument
, &file_start_context
, 1},
266 {"full-contents", no_argument
, NULL
, 's'},
267 {"headers", no_argument
, NULL
, 'h'},
268 {"help", no_argument
, NULL
, 'H'},
269 {"info", no_argument
, NULL
, 'i'},
270 {"line-numbers", no_argument
, NULL
, 'l'},
271 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
272 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
273 {"reloc", no_argument
, NULL
, 'r'},
274 {"section", required_argument
, NULL
, 'j'},
275 {"section-headers", no_argument
, NULL
, 'h'},
276 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
277 {"source", no_argument
, NULL
, 'S'},
278 {"special-syms", no_argument
, &dump_special_syms
, 1},
279 {"include", required_argument
, NULL
, 'I'},
280 {"dwarf", no_argument
, NULL
, 'W'},
281 {"stabs", no_argument
, NULL
, 'G'},
282 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
283 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
284 {"syms", no_argument
, NULL
, 't'},
285 {"target", required_argument
, NULL
, 'b'},
286 {"version", no_argument
, NULL
, 'V'},
287 {"wide", no_argument
, NULL
, 'w'},
288 {0, no_argument
, 0, 0}
292 nonfatal (const char *msg
)
299 dump_section_header (bfd
*abfd
, asection
*section
,
300 void *ignored ATTRIBUTE_UNUSED
)
303 unsigned int opb
= bfd_octets_per_byte (abfd
);
305 /* Ignore linker created section. See elfNN_ia64_object_p in
307 if (section
->flags
& SEC_LINKER_CREATED
)
310 printf ("%3d %-13s %08lx ", section
->index
,
311 bfd_get_section_name (abfd
, section
),
312 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
313 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
315 bfd_printf_vma (abfd
, section
->lma
);
316 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
317 bfd_get_section_alignment (abfd
, section
));
323 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
325 PF (SEC_HAS_CONTENTS
, "CONTENTS");
326 PF (SEC_ALLOC
, "ALLOC");
327 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
328 PF (SEC_LOAD
, "LOAD");
329 PF (SEC_RELOC
, "RELOC");
330 PF (SEC_READONLY
, "READONLY");
331 PF (SEC_CODE
, "CODE");
332 PF (SEC_DATA
, "DATA");
334 PF (SEC_DEBUGGING
, "DEBUGGING");
335 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
336 PF (SEC_EXCLUDE
, "EXCLUDE");
337 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
338 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
340 PF (SEC_TIC54X_BLOCK
, "BLOCK");
341 PF (SEC_TIC54X_CLINK
, "CLINK");
343 PF (SEC_SMALL_DATA
, "SMALL_DATA");
344 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
345 PF (SEC_COFF_SHARED
, "SHARED");
346 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
347 PF (SEC_GROUP
, "GROUP");
349 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
352 struct coff_comdat_info
*comdat
;
354 switch (section
->flags
& SEC_LINK_DUPLICATES
)
358 case SEC_LINK_DUPLICATES_DISCARD
:
359 ls
= "LINK_ONCE_DISCARD";
361 case SEC_LINK_DUPLICATES_ONE_ONLY
:
362 ls
= "LINK_ONCE_ONE_ONLY";
364 case SEC_LINK_DUPLICATES_SAME_SIZE
:
365 ls
= "LINK_ONCE_SAME_SIZE";
367 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
368 ls
= "LINK_ONCE_SAME_CONTENTS";
371 printf ("%s%s", comma
, ls
);
373 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
375 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
385 dump_headers (bfd
*abfd
)
387 printf (_("Sections:\n"));
390 printf (_("Idx Name Size VMA LMA File off Algn"));
392 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
393 if (bfd_get_arch_size (abfd
) == 32)
394 printf (_("Idx Name Size VMA LMA File off Algn"));
396 printf (_("Idx Name Size VMA LMA File off Algn"));
400 printf (_(" Flags"));
401 if (abfd
->flags
& HAS_LOAD_PAGE
)
405 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
409 slurp_symtab (bfd
*abfd
)
414 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
420 storage
= bfd_get_symtab_upper_bound (abfd
);
422 bfd_fatal (bfd_get_filename (abfd
));
424 sy
= xmalloc (storage
);
426 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
428 bfd_fatal (bfd_get_filename (abfd
));
432 /* Read in the dynamic symbols. */
435 slurp_dynamic_symtab (bfd
*abfd
)
440 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
443 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
445 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
450 bfd_fatal (bfd_get_filename (abfd
));
453 sy
= xmalloc (storage
);
455 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
457 bfd_fatal (bfd_get_filename (abfd
));
461 /* Filter out (in place) symbols that are useless for disassembly.
462 COUNT is the number of elements in SYMBOLS.
463 Return the number of useful symbols. */
466 remove_useless_symbols (asymbol
**symbols
, long count
)
468 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
472 asymbol
*sym
= *in_ptr
++;
474 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
476 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
478 if (bfd_is_und_section (sym
->section
)
479 || bfd_is_com_section (sym
->section
))
484 return out_ptr
- symbols
;
487 /* Sort symbols into value order. */
490 compare_symbols (const void *ap
, const void *bp
)
492 const asymbol
*a
= * (const asymbol
**) ap
;
493 const asymbol
*b
= * (const asymbol
**) bp
;
503 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
505 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
508 if (a
->section
> b
->section
)
510 else if (a
->section
< b
->section
)
513 an
= bfd_asymbol_name (a
);
514 bn
= bfd_asymbol_name (b
);
518 /* The symbols gnu_compiled and gcc2_compiled convey no real
519 information, so put them after other symbols with the same value. */
520 af
= (strstr (an
, "gnu_compiled") != NULL
521 || strstr (an
, "gcc2_compiled") != NULL
);
522 bf
= (strstr (bn
, "gnu_compiled") != NULL
523 || strstr (bn
, "gcc2_compiled") != NULL
);
530 /* We use a heuristic for the file name, to try to sort it after
531 more useful symbols. It may not work on non Unix systems, but it
532 doesn't really matter; the only difference is precisely which
533 symbol names get printed. */
535 #define file_symbol(s, sn, snl) \
536 (((s)->flags & BSF_FILE) != 0 \
537 || ((sn)[(snl) - 2] == '.' \
538 && ((sn)[(snl) - 1] == 'o' \
539 || (sn)[(snl) - 1] == 'a')))
541 af
= file_symbol (a
, an
, anl
);
542 bf
= file_symbol (b
, bn
, bnl
);
549 /* Try to sort global symbols before local symbols before function
550 symbols before debugging symbols. */
555 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
557 if ((aflags
& BSF_DEBUGGING
) != 0)
562 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
564 if ((aflags
& BSF_FUNCTION
) != 0)
569 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
571 if ((aflags
& BSF_LOCAL
) != 0)
576 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
578 if ((aflags
& BSF_GLOBAL
) != 0)
584 /* Symbols that start with '.' might be section names, so sort them
585 after symbols that don't start with '.'. */
586 if (an
[0] == '.' && bn
[0] != '.')
588 if (an
[0] != '.' && bn
[0] == '.')
591 /* Finally, if we can't distinguish them in any other way, try to
592 get consistent results by sorting the symbols by name. */
593 return strcmp (an
, bn
);
596 /* Sort relocs into address order. */
599 compare_relocs (const void *ap
, const void *bp
)
601 const arelent
*a
= * (const arelent
**) ap
;
602 const arelent
*b
= * (const arelent
**) bp
;
604 if (a
->address
> b
->address
)
606 else if (a
->address
< b
->address
)
609 /* So that associated relocations tied to the same address show up
610 in the correct order, we don't do any further sorting. */
619 /* Print an address (VMA) to the output stream in INFO.
620 If SKIP_ZEROES is TRUE, omit leading zeroes. */
623 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
624 bfd_boolean skip_zeroes
)
628 struct objdump_disasm_info
*aux
;
630 aux
= (struct objdump_disasm_info
*) info
->application_data
;
631 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
636 for (p
= buf
; *p
== '0'; ++p
)
641 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
644 /* Print the name of a symbol. */
647 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
654 name
= bfd_asymbol_name (sym
);
655 if (do_demangle
&& name
[0] != '\0')
657 /* Demangle the name. */
658 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
664 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
672 /* Locate a symbol given a bfd and a section (from INFO->application_data),
673 and a VMA. If INFO->application_data->require_sec is TRUE, then always
674 require the symbol to be in the section. Returns NULL if there is no
675 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
676 of the symbol in sorted_syms. */
679 find_symbol_for_address (bfd_vma vma
,
680 struct disassemble_info
*info
,
683 /* @@ Would it speed things up to cache the last two symbols returned,
684 and maybe their address ranges? For many processors, only one memory
685 operand can be present at a time, so the 2-entry cache wouldn't be
686 constantly churned by code doing heavy memory accesses. */
688 /* Indices in `sorted_syms'. */
690 long max
= sorted_symcount
;
692 struct objdump_disasm_info
*aux
;
696 bfd_boolean want_section
;
698 if (sorted_symcount
< 1)
701 aux
= (struct objdump_disasm_info
*) info
->application_data
;
704 opb
= bfd_octets_per_byte (abfd
);
706 /* Perform a binary search looking for the closest symbol to the
707 required value. We are searching the range (min, max]. */
708 while (min
+ 1 < max
)
712 thisplace
= (max
+ min
) / 2;
713 sym
= sorted_syms
[thisplace
];
715 if (bfd_asymbol_value (sym
) > vma
)
717 else if (bfd_asymbol_value (sym
) < vma
)
726 /* The symbol we want is now in min, the low end of the range we
727 were searching. If there are several symbols with the same
728 value, we want the first one. */
731 && (bfd_asymbol_value (sorted_syms
[thisplace
])
732 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
735 /* If the file is relocatable, and the symbol could be from this
736 section, prefer a symbol from this section over symbols from
737 others, even if the other symbol's value might be closer.
739 Note that this may be wrong for some symbol references if the
740 sections have overlapping memory ranges, but in that case there's
741 no way to tell what's desired without looking at the relocation
744 Also give the target a chance to reject symbols. */
745 want_section
= (aux
->require_sec
746 || ((abfd
->flags
& HAS_RELOC
) != 0
747 && vma
>= bfd_get_section_vma (abfd
, sec
)
748 && vma
< (bfd_get_section_vma (abfd
, sec
)
749 + bfd_section_size (abfd
, sec
) / opb
)));
750 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
751 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
756 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
758 if (bfd_asymbol_value (sorted_syms
[i
])
759 != bfd_asymbol_value (sorted_syms
[thisplace
]))
764 newplace
= sorted_symcount
;
768 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
769 && info
->symbol_is_valid (sorted_syms
[i
], info
))
771 if (newplace
== sorted_symcount
)
774 if (bfd_asymbol_value (sorted_syms
[i
])
775 != bfd_asymbol_value (sorted_syms
[newplace
]))
778 /* Remember this symbol and keep searching until we reach
779 an earlier address. */
784 if (newplace
!= sorted_symcount
)
785 thisplace
= newplace
;
788 /* We didn't find a good symbol with a smaller value.
789 Look for one with a larger value. */
790 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
792 if ((sorted_syms
[i
]->section
== sec
|| !want_section
)
793 && info
->symbol_is_valid (sorted_syms
[i
], info
))
801 if ((sorted_syms
[thisplace
]->section
!= sec
&& want_section
)
802 || !info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
803 /* There is no suitable symbol. */
810 return sorted_syms
[thisplace
];
813 /* Print an address and the offset to the nearest symbol. */
816 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
817 bfd_vma vma
, struct disassemble_info
*info
,
818 bfd_boolean skip_zeroes
)
820 objdump_print_value (vma
, info
, skip_zeroes
);
826 (*info
->fprintf_func
) (info
->stream
, " <%s",
827 bfd_get_section_name (abfd
, sec
));
828 secaddr
= bfd_get_section_vma (abfd
, sec
);
831 (*info
->fprintf_func
) (info
->stream
, "-0x");
832 objdump_print_value (secaddr
- vma
, info
, TRUE
);
834 else if (vma
> secaddr
)
836 (*info
->fprintf_func
) (info
->stream
, "+0x");
837 objdump_print_value (vma
- secaddr
, info
, TRUE
);
839 (*info
->fprintf_func
) (info
->stream
, ">");
843 (*info
->fprintf_func
) (info
->stream
, " <");
844 objdump_print_symname (abfd
, info
, sym
);
845 if (bfd_asymbol_value (sym
) > vma
)
847 (*info
->fprintf_func
) (info
->stream
, "-0x");
848 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
850 else if (vma
> bfd_asymbol_value (sym
))
852 (*info
->fprintf_func
) (info
->stream
, "+0x");
853 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
855 (*info
->fprintf_func
) (info
->stream
, ">");
859 /* Print an address (VMA), symbolically if possible.
860 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
863 objdump_print_addr (bfd_vma vma
,
864 struct disassemble_info
*info
,
865 bfd_boolean skip_zeroes
)
867 struct objdump_disasm_info
*aux
;
868 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
869 bfd_boolean skip_find
= FALSE
;
871 if (sorted_symcount
< 1)
873 (*info
->fprintf_func
) (info
->stream
, "0x");
874 objdump_print_value (vma
, info
, skip_zeroes
);
878 aux
= (struct objdump_disasm_info
*) info
->application_data
;
880 if (aux
->reloc
!= NULL
881 && aux
->reloc
->sym_ptr_ptr
!= NULL
882 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
884 sym
= * aux
->reloc
->sym_ptr_ptr
;
886 /* Adjust the vma to the reloc. */
887 vma
+= bfd_asymbol_value (sym
);
889 if (bfd_is_und_section (bfd_get_section (sym
)))
894 sym
= find_symbol_for_address (vma
, info
, NULL
);
896 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
900 /* Print VMA to INFO. This function is passed to the disassembler
904 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
906 objdump_print_addr (vma
, info
, ! prefix_addresses
);
909 /* Determine if the given address has a symbol associated with it. */
912 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
916 sym
= find_symbol_for_address (vma
, info
, NULL
);
918 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
921 /* Hold the last function name and the last line number we displayed
924 static char *prev_functionname
;
925 static unsigned int prev_line
;
927 /* We keep a list of all files that we have seen when doing a
928 disassembly with source, so that we know how much of the file to
929 display. This can be important for inlined functions. */
931 struct print_file_list
933 struct print_file_list
*next
;
934 const char *filename
;
938 const char **linemap
;
944 static struct print_file_list
*print_files
;
946 /* The number of preceding context lines to show when we start
947 displaying a file for the first time. */
949 #define SHOW_PRECEDING_CONTEXT_LINES (5)
951 /* Read a complete file into memory. */
954 slurp_file (const char *fn
, size_t *size
)
957 int ps
= getpagesize ();
962 int fd
= open (fn
, O_RDONLY
);
966 if (fstat (fd
, &st
) < 0)
970 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
971 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
972 if (map
!= (char *)-1L)
978 map
= malloc (*size
);
979 if (!map
|| (size_t) read (fd
, (char *)map
, *size
) != *size
)
988 #define line_map_decrease 5
990 /* Precompute array of lines for a mapped file. */
993 index_file (const char *map
, size_t size
, unsigned int *maxline
)
995 const char *p
, *lstart
, *end
;
996 int chars_per_line
= 45; /* First iteration will use 40. */
998 const char **linemap
= NULL
;
999 unsigned long line_map_size
= 0;
1005 for (p
= map
; p
< end
; p
++)
1009 if (p
+ 1 < end
&& p
[1] == '\r')
1012 else if (*p
== '\r')
1014 if (p
+ 1 < end
&& p
[1] == '\n')
1020 /* End of line found. */
1022 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1024 unsigned long newsize
;
1026 chars_per_line
-= line_map_decrease
;
1027 if (chars_per_line
<= 1)
1029 line_map_size
= size
/ chars_per_line
+ 1;
1030 if (line_map_size
< lineno
+ 1)
1031 line_map_size
= lineno
+ 1;
1032 newsize
= line_map_size
* sizeof (char *);
1033 linemap
= xrealloc (linemap
, newsize
);
1036 linemap
[lineno
++] = lstart
;
1044 /* Tries to open MODNAME, and if successful adds a node to print_files
1045 linked list and returns that node. Returns NULL on failure. */
1047 static struct print_file_list
*
1048 try_print_file_open (const char *origname
, const char *modname
)
1050 struct print_file_list
*p
;
1052 p
= xmalloc (sizeof (struct print_file_list
));
1054 p
->map
= slurp_file (modname
, &p
->mapsize
);
1061 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1063 p
->filename
= origname
;
1064 p
->modname
= modname
;
1065 p
->next
= print_files
;
1071 /* If the the source file, as described in the symtab, is not found
1072 try to locate it in one of the paths specified with -I
1073 If found, add location to print_files linked list. */
1075 static struct print_file_list
*
1076 update_source_path (const char *filename
)
1078 struct print_file_list
*p
;
1082 if (filename
== NULL
)
1085 p
= try_print_file_open (filename
, filename
);
1089 if (include_path_count
== 0)
1092 /* Get the name of the file. */
1093 fname
= strrchr (filename
, '/');
1094 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1096 /* We could have a mixed forward/back slash case. */
1097 char *backslash
= strrchr (filename
, '\\');
1098 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1100 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1101 fname
= filename
+ 1;
1109 /* If file exists under a new path, we need to add it to the list
1110 so that show_line knows about it. */
1111 for (i
= 0; i
< include_path_count
; i
++)
1113 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1115 p
= try_print_file_open (filename
, modname
);
1125 /* Print a source file line. */
1128 print_line (struct print_file_list
*p
, unsigned int line
)
1133 if (line
>= p
->maxline
)
1135 l
= p
->linemap
[line
];
1136 fwrite (l
, 1, strcspn (l
, "\n\r"), stdout
);
1140 /* Print a range of source code lines. */
1143 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1147 while (start
<= end
)
1149 print_line (p
, start
);
1154 /* Show the line number, or the source line, in a disassembly
1158 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1160 const char *filename
;
1161 const char *functionname
;
1164 if (! with_line_numbers
&& ! with_source_code
)
1167 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1168 &functionname
, &line
))
1171 if (filename
!= NULL
&& *filename
== '\0')
1173 if (functionname
!= NULL
&& *functionname
== '\0')
1174 functionname
= NULL
;
1176 if (with_line_numbers
)
1178 if (functionname
!= NULL
1179 && (prev_functionname
== NULL
1180 || strcmp (functionname
, prev_functionname
) != 0))
1181 printf ("%s():\n", functionname
);
1182 if (line
> 0 && line
!= prev_line
)
1183 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1186 if (with_source_code
1190 struct print_file_list
**pp
, *p
;
1193 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1194 if (strcmp ((*pp
)->filename
, filename
) == 0)
1199 p
= update_source_path (filename
);
1201 if (p
!= NULL
&& line
!= p
->last_line
)
1203 if (file_start_context
&& p
->first
)
1207 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1210 if (p
->last_line
>= l
&& p
->last_line
<= line
)
1211 l
= p
->last_line
+ 1;
1213 dump_lines (p
, l
, line
);
1214 p
->last_line
= line
;
1219 if (functionname
!= NULL
1220 && (prev_functionname
== NULL
1221 || strcmp (functionname
, prev_functionname
) != 0))
1223 if (prev_functionname
!= NULL
)
1224 free (prev_functionname
);
1225 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1226 strcpy (prev_functionname
, functionname
);
1229 if (line
> 0 && line
!= prev_line
)
1233 /* Pseudo FILE object for strings. */
1241 /* sprintf to a "stream". */
1243 static int ATTRIBUTE_PRINTF_2
1244 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1251 size_t space
= f
->alloc
- f
->pos
;
1253 va_start (args
, format
);
1254 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1260 f
->alloc
= (f
->alloc
+ n
) * 2;
1261 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1268 /* Returns TRUE if the specified section should be dumped. */
1271 process_section_p (asection
* section
)
1278 for (i
= 0; i
< only_used
; i
++)
1279 if (strcmp (only
[i
], section
->name
) == 0)
1286 /* The number of zeroes we want to see before we start skipping them.
1287 The number is arbitrarily chosen. */
1289 #define DEFAULT_SKIP_ZEROES 8
1291 /* The number of zeroes to skip at the end of a section. If the
1292 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1293 SKIP_ZEROES, they will be disassembled. If there are fewer than
1294 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1295 attempt to avoid disassembling zeroes inserted by section
1298 #define DEFAULT_SKIP_ZEROES_AT_END 3
1300 /* Disassemble some data in memory between given values. */
1303 disassemble_bytes (struct disassemble_info
* info
,
1304 disassembler_ftype disassemble_fn
,
1307 bfd_vma start_offset
,
1308 bfd_vma stop_offset
,
1311 arelent
** relppend
)
1313 struct objdump_disasm_info
*aux
;
1315 int octets_per_line
;
1316 bfd_boolean done_dot
;
1317 int skip_addr_chars
;
1318 bfd_vma addr_offset
;
1319 unsigned int opb
= info
->octets_per_byte
;
1320 unsigned int skip_zeroes
= info
->skip_zeroes
;
1321 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1325 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1329 sfile
.buffer
= xmalloc (sfile
.alloc
);
1333 octets_per_line
= 4;
1335 octets_per_line
= 16;
1337 /* Figure out how many characters to skip at the start of an
1338 address, to make the disassembly look nicer. We discard leading
1339 zeroes in chunks of 4, ensuring that there is always a leading
1341 skip_addr_chars
= 0;
1342 if (! prefix_addresses
)
1350 + bfd_section_size (section
->owner
, section
) / opb
));
1352 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1355 skip_addr_chars
+= 4;
1360 info
->insn_info_valid
= 0;
1363 addr_offset
= start_offset
;
1364 while (addr_offset
< stop_offset
)
1367 bfd_boolean need_nl
= FALSE
;
1368 int previous_octets
;
1370 /* Remember the length of the previous instruction. */
1371 previous_octets
= octets
;
1374 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1376 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1379 if (! disassemble_zeroes
1380 && (info
->insn_info_valid
== 0
1381 || info
->branch_delay_insns
== 0)
1382 && (z
- addr_offset
* opb
>= skip_zeroes
1383 || (z
== stop_offset
* opb
&&
1384 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1388 /* If there are more nonzero octets to follow, we only skip
1389 zeroes in multiples of 4, to try to avoid running over
1390 the start of an instruction which happens to start with
1392 if (z
!= stop_offset
* opb
)
1393 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1395 octets
= z
- addr_offset
* opb
;
1405 if (with_line_numbers
|| with_source_code
)
1406 show_line (aux
->abfd
, section
, addr_offset
);
1408 if (! prefix_addresses
)
1412 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1413 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1417 printf ("%s:\t", buf
+ skip_addr_chars
);
1421 aux
->require_sec
= TRUE
;
1422 objdump_print_address (section
->vma
+ addr_offset
, info
);
1423 aux
->require_sec
= FALSE
;
1430 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1431 info
->stream
= &sfile
;
1432 info
->bytes_per_line
= 0;
1433 info
->bytes_per_chunk
= 0;
1436 if (info
->disassembler_needs_relocs
1437 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1438 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1439 && *relppp
< relppend
)
1441 bfd_signed_vma distance_to_rel
;
1443 distance_to_rel
= (**relppp
)->address
1444 - (rel_offset
+ addr_offset
);
1446 /* Check to see if the current reloc is associated with
1447 the instruction that we are about to disassemble. */
1448 if (distance_to_rel
== 0
1449 /* FIXME: This is wrong. We are trying to catch
1450 relocs that are addressed part way through the
1451 current instruction, as might happen with a packed
1452 VLIW instruction. Unfortunately we do not know the
1453 length of the current instruction since we have not
1454 disassembled it yet. Instead we take a guess based
1455 upon the length of the previous instruction. The
1456 proper solution is to have a new target-specific
1457 disassembler function which just returns the length
1458 of an instruction at a given address without trying
1459 to display its disassembly. */
1460 || (distance_to_rel
> 0
1461 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1463 info
->flags
= INSN_HAS_RELOC
;
1464 aux
->reloc
= **relppp
;
1470 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1471 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1472 info
->stream
= stdout
;
1473 if (info
->bytes_per_line
!= 0)
1474 octets_per_line
= info
->bytes_per_line
;
1478 printf ("%s\n", sfile
.buffer
);
1486 octets
= octets_per_line
;
1487 if (addr_offset
+ octets
/ opb
> stop_offset
)
1488 octets
= (stop_offset
- addr_offset
) * opb
;
1490 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1492 if (ISPRINT (data
[j
]))
1493 buf
[j
- addr_offset
* opb
] = data
[j
];
1495 buf
[j
- addr_offset
* opb
] = '.';
1497 buf
[j
- addr_offset
* opb
] = '\0';
1500 if (prefix_addresses
1502 : show_raw_insn
>= 0)
1506 /* If ! prefix_addresses and ! wide_output, we print
1507 octets_per_line octets per line. */
1509 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1510 pb
= octets_per_line
;
1512 if (info
->bytes_per_chunk
)
1513 bpc
= info
->bytes_per_chunk
;
1517 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1521 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1523 for (k
= bpc
- 1; k
>= 0; k
--)
1524 printf ("%02x", (unsigned) data
[j
+ k
]);
1529 for (k
= 0; k
< bpc
; k
++)
1530 printf ("%02x", (unsigned) data
[j
+ k
]);
1535 for (; pb
< octets_per_line
; pb
+= bpc
)
1539 for (k
= 0; k
< bpc
; k
++)
1544 /* Separate raw data from instruction by extra space. */
1554 printf ("%s", sfile
.buffer
);
1556 if (prefix_addresses
1558 : show_raw_insn
>= 0)
1566 j
= addr_offset
* opb
+ pb
;
1568 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1569 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1573 printf ("%s:\t", buf
+ skip_addr_chars
);
1575 pb
+= octets_per_line
;
1578 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1582 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1584 for (k
= bpc
- 1; k
>= 0; k
--)
1585 printf ("%02x", (unsigned) data
[j
+ k
]);
1590 for (k
= 0; k
< bpc
; k
++)
1591 printf ("%02x", (unsigned) data
[j
+ k
]);
1604 while ((*relppp
) < relppend
1605 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1607 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1618 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1621 if (q
->howto
== NULL
)
1622 printf (": *unknown*\t");
1623 else if (q
->howto
->name
)
1624 printf (": %s\t", q
->howto
->name
);
1626 printf (": %d\t", q
->howto
->type
);
1628 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1629 printf ("*unknown*");
1632 const char *sym_name
;
1634 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1635 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1636 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1641 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1642 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1643 if (sym_name
== NULL
|| *sym_name
== '\0')
1644 sym_name
= "*unknown*";
1645 printf ("%s", sym_name
);
1652 objdump_print_value (q
->addend
, info
, TRUE
);
1664 addr_offset
+= octets
/ opb
;
1667 free (sfile
.buffer
);
1671 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1673 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1674 struct objdump_disasm_info
* paux
;
1675 unsigned int opb
= pinfo
->octets_per_byte
;
1676 bfd_byte
* data
= NULL
;
1677 bfd_size_type datasize
= 0;
1678 arelent
** rel_pp
= NULL
;
1679 arelent
** rel_ppstart
= NULL
;
1680 arelent
** rel_ppend
;
1681 unsigned long stop_offset
;
1682 asymbol
* sym
= NULL
;
1686 unsigned long addr_offset
;
1688 /* Sections that do not contain machine
1689 code are not normally disassembled. */
1690 if (! disassemble_all
1692 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1693 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1696 if (! process_section_p (section
))
1699 datasize
= bfd_get_section_size (section
);
1703 /* Decide which set of relocs to use. Load them if necessary. */
1704 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1705 if (paux
->dynrelbuf
)
1707 rel_pp
= paux
->dynrelbuf
;
1708 rel_count
= paux
->dynrelcount
;
1709 /* Dynamic reloc addresses are absolute, non-dynamic are section
1710 relative. REL_OFFSET specifies the reloc address corresponding
1711 to the start of this section. */
1712 rel_offset
= section
->vma
;
1720 if ((section
->flags
& SEC_RELOC
) != 0
1721 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1725 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1727 bfd_fatal (bfd_get_filename (abfd
));
1731 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1732 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1734 bfd_fatal (bfd_get_filename (abfd
));
1736 /* Sort the relocs by address. */
1737 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1742 rel_ppend
= rel_pp
+ rel_count
;
1744 data
= xmalloc (datasize
);
1746 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1748 paux
->sec
= section
;
1749 pinfo
->buffer
= data
;
1750 pinfo
->buffer_vma
= section
->vma
;
1751 pinfo
->buffer_length
= datasize
;
1752 pinfo
->section
= section
;
1754 if (start_address
== (bfd_vma
) -1
1755 || start_address
< pinfo
->buffer_vma
)
1758 addr_offset
= start_address
- pinfo
->buffer_vma
;
1760 if (stop_address
== (bfd_vma
) -1)
1761 stop_offset
= datasize
/ opb
;
1764 if (stop_address
< pinfo
->buffer_vma
)
1767 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1768 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1769 stop_offset
= pinfo
->buffer_length
/ opb
;
1772 /* Skip over the relocs belonging to addresses below the
1774 while (rel_pp
< rel_ppend
1775 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1778 printf (_("Disassembly of section %s:\n"), section
->name
);
1780 /* Find the nearest symbol forwards from our current position. */
1781 paux
->require_sec
= TRUE
;
1782 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1783 paux
->require_sec
= FALSE
;
1785 /* Disassemble a block of instructions up to the address associated with
1786 the symbol we have just found. Then print the symbol and find the
1787 next symbol on. Repeat until we have disassembled the entire section
1788 or we have reached the end of the address range we are interested in. */
1789 while (addr_offset
< stop_offset
)
1793 unsigned long nextstop_offset
;
1796 addr
= section
->vma
+ addr_offset
;
1798 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1803 (x
< sorted_symcount
1804 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1808 pinfo
->symbols
= sorted_syms
+ place
;
1809 pinfo
->num_symbols
= x
- place
;
1810 pinfo
->symtab_pos
= place
;
1814 pinfo
->symbols
= NULL
;
1815 pinfo
->num_symbols
= 0;
1816 pinfo
->symtab_pos
= -1;
1819 if (! prefix_addresses
)
1821 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1822 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1824 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1827 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1829 else if (sym
== NULL
)
1833 #define is_valid_next_sym(SYM) \
1834 ((SYM)->section == section \
1835 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1836 && pinfo->symbol_is_valid (SYM, pinfo))
1838 /* Search forward for the next appropriate symbol in
1839 SECTION. Note that all the symbols are sorted
1840 together into one big array, and that some sections
1841 may have overlapping addresses. */
1842 while (place
< sorted_symcount
1843 && ! is_valid_next_sym (sorted_syms
[place
]))
1846 if (place
>= sorted_symcount
)
1849 nextsym
= sorted_syms
[place
];
1852 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1853 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1854 else if (nextsym
== NULL
)
1855 nextstop_offset
= stop_offset
;
1857 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1859 if (nextstop_offset
> stop_offset
)
1860 nextstop_offset
= stop_offset
;
1862 /* If a symbol is explicitly marked as being an object
1863 rather than a function, just dump the bytes without
1864 disassembling them. */
1867 || bfd_asymbol_value (sym
) > addr
1868 || ((sym
->flags
& BSF_OBJECT
) == 0
1869 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1871 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1873 || (sym
->flags
& BSF_FUNCTION
) != 0)
1878 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1879 addr_offset
, nextstop_offset
,
1880 rel_offset
, &rel_pp
, rel_ppend
);
1882 addr_offset
= nextstop_offset
;
1888 if (rel_ppstart
!= NULL
)
1892 /* Disassemble the contents of an object file. */
1895 disassemble_data (bfd
*abfd
)
1897 struct disassemble_info disasm_info
;
1898 struct objdump_disasm_info aux
;
1902 prev_functionname
= NULL
;
1905 /* We make a copy of syms to sort. We don't want to sort syms
1906 because that will screw up the relocs. */
1907 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1908 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1909 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1910 sorted_symcount
* sizeof (asymbol
*));
1912 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1914 for (i
= 0; i
< synthcount
; ++i
)
1916 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1920 /* Sort the symbols into section and symbol order. */
1921 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1923 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1925 disasm_info
.application_data
= (void *) &aux
;
1927 aux
.require_sec
= FALSE
;
1928 aux
.dynrelbuf
= NULL
;
1929 aux
.dynrelcount
= 0;
1932 disasm_info
.print_address_func
= objdump_print_address
;
1933 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1935 if (machine
!= NULL
)
1937 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1940 fatal (_("Can't use supplied machine %s"), machine
);
1942 abfd
->arch_info
= info
;
1945 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1947 struct bfd_target
*xvec
;
1949 xvec
= xmalloc (sizeof (struct bfd_target
));
1950 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1951 xvec
->byteorder
= endian
;
1955 /* Use libopcodes to locate a suitable disassembler. */
1956 aux
.disassemble_fn
= disassembler (abfd
);
1957 if (!aux
.disassemble_fn
)
1959 non_fatal (_("Can't disassemble for architecture %s\n"),
1960 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1965 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1966 disasm_info
.arch
= bfd_get_arch (abfd
);
1967 disasm_info
.mach
= bfd_get_mach (abfd
);
1968 disasm_info
.disassembler_options
= disassembler_options
;
1969 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1970 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1971 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1972 disasm_info
.disassembler_needs_relocs
= FALSE
;
1974 if (bfd_big_endian (abfd
))
1975 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1976 else if (bfd_little_endian (abfd
))
1977 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1979 /* ??? Aborting here seems too drastic. We could default to big or little
1981 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1983 /* Allow the target to customize the info structure. */
1984 disassemble_init_for_target (& disasm_info
);
1986 /* Pre-load the dynamic relocs if we are going
1987 to be dumping them along with the disassembly. */
1988 if (dump_dynamic_reloc_info
)
1990 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1993 bfd_fatal (bfd_get_filename (abfd
));
1997 aux
.dynrelbuf
= xmalloc (relsize
);
1998 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2001 if (aux
.dynrelcount
< 0)
2002 bfd_fatal (bfd_get_filename (abfd
));
2004 /* Sort the relocs by address. */
2005 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2009 disasm_info
.symtab
= sorted_syms
;
2010 disasm_info
.symtab_size
= sorted_symcount
;
2012 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2014 if (aux
.dynrelbuf
!= NULL
)
2015 free (aux
.dynrelbuf
);
2020 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2022 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2027 /* If it is already loaded, do nothing. */
2028 if (section
->start
!= NULL
)
2031 /* Locate the debug section. */
2032 sec
= bfd_get_section_by_name (abfd
, section
->name
);
2036 /* Compute a bias to be added to offsets found within the DWARF debug
2037 information. These offsets are meant to be relative to the start of
2038 the dwarf section, and hence the bias should be 0. For MACH-O however
2039 a dwarf section is really just a region of a much larger section and so
2040 the bias is the address of the start of that area within the larger
2041 section. This test is important for PE and COFF based targets which
2042 use DWARF debug information, since unlike ELF, they do not allow the
2043 dwarf sections to be placed at address 0. */
2044 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
2045 section
->address
= bfd_get_section_vma (abfd
, sec
);
2047 section
->address
= 0;
2049 section
->size
= bfd_get_section_size (sec
);
2050 section
->start
= xmalloc (section
->size
);
2052 if (is_relocatable
&& debug_displays
[debug
].relocate
)
2053 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2058 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2063 free_debug_section (debug
);
2064 printf (_("\nCan't get contents for section '%s'.\n"),
2072 free_debug_section (enum dwarf_section_display_enum debug
)
2074 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2076 if (section
->start
== NULL
)
2079 free ((char *) section
->start
);
2080 section
->start
= NULL
;
2081 section
->address
= 0;
2086 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2087 void *arg ATTRIBUTE_UNUSED
)
2089 const char *name
= bfd_get_section_name (abfd
, section
);
2091 enum dwarf_section_display_enum i
;
2093 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2094 match
= ".debug_info";
2098 for (i
= 0; i
< max
; i
++)
2099 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2101 if (!debug_displays
[i
].eh_frame
)
2103 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2105 if (load_debug_section (i
, abfd
))
2107 debug_displays
[i
].display (sec
, abfd
);
2109 if (i
!= info
&& i
!= abbrev
)
2110 free_debug_section (i
);
2117 static const char *mach_o_dwarf_sections
[] = {
2118 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2119 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2120 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2121 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2122 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2123 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2124 ".eh_frame", /* .eh_frame */
2125 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2126 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2127 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2128 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2129 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2130 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2131 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2132 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2133 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2136 static const char *generic_dwarf_sections
[max
];
2139 check_mach_o_dwarf (bfd
*abfd
)
2141 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2142 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2143 enum dwarf_section_display_enum i
;
2145 if (generic_dwarf_sections
[0] == NULL
)
2146 for (i
= 0; i
< max
; i
++)
2147 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2149 if (old_flavour
!= current_flavour
)
2151 if (current_flavour
== bfd_target_mach_o_flavour
)
2152 for (i
= 0; i
< max
; i
++)
2153 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2154 else if (old_flavour
== bfd_target_mach_o_flavour
)
2155 for (i
= 0; i
< max
; i
++)
2156 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2158 old_flavour
= current_flavour
;
2162 /* Dump the dwarf debugging information. */
2165 dump_dwarf (bfd
*abfd
)
2167 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2170 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2171 targets will return 64. */
2172 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2174 if (bfd_big_endian (abfd
))
2175 byte_get
= byte_get_big_endian
;
2176 else if (bfd_little_endian (abfd
))
2177 byte_get
= byte_get_little_endian
;
2181 check_mach_o_dwarf (abfd
);
2183 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2185 free_debug_memory ();
2188 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2189 it. Return NULL on failure. */
2192 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2198 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2199 if (stabsect
== NULL
)
2201 printf (_("No %s section present\n\n"), sect_name
);
2205 size
= bfd_section_size (abfd
, stabsect
);
2206 contents
= xmalloc (size
);
2208 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2210 non_fatal (_("Reading %s section of %s failed: %s"),
2211 sect_name
, bfd_get_filename (abfd
),
2212 bfd_errmsg (bfd_get_error ()));
2223 /* Stabs entries use a 12 byte format:
2224 4 byte string table index
2226 1 byte stab other field
2227 2 byte stab desc field
2229 FIXME: This will have to change for a 64 bit object format. */
2231 #define STRDXOFF (0)
2233 #define OTHEROFF (5)
2236 #define STABSIZE (12)
2238 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2239 using string table section STRSECT_NAME (in `strtab'). */
2242 print_section_stabs (bfd
*abfd
,
2243 const char *stabsect_name
,
2244 unsigned *string_offset_ptr
)
2247 unsigned file_string_table_offset
= 0;
2248 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2249 bfd_byte
*stabp
, *stabs_end
;
2252 stabs_end
= stabp
+ stab_size
;
2254 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2255 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2257 /* Loop through all symbols and print them.
2259 We start the index at -1 because there is a dummy symbol on
2260 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2261 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2265 unsigned char type
, other
;
2266 unsigned short desc
;
2269 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2270 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2271 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2272 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2273 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2275 printf ("\n%-6d ", i
);
2276 /* Either print the stab name, or, if unnamed, print its number
2277 again (makes consistent formatting for tools like awk). */
2278 name
= bfd_get_stab_name (type
);
2280 printf ("%-6s", name
);
2281 else if (type
== N_UNDF
)
2284 printf ("%-6d", type
);
2285 printf (" %-6d %-6d ", other
, desc
);
2286 bfd_printf_vma (abfd
, value
);
2287 printf (" %-6lu", strx
);
2289 /* Symbols with type == 0 (N_UNDF) specify the length of the
2290 string table associated with this file. We use that info
2291 to know how to relocate the *next* file's string table indices. */
2294 file_string_table_offset
= next_file_string_table_offset
;
2295 next_file_string_table_offset
+= value
;
2299 /* Using the (possibly updated) string table offset, print the
2300 string (if any) associated with this symbol. */
2301 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2302 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2308 *string_offset_ptr
= next_file_string_table_offset
;
2313 const char * section_name
;
2314 const char * string_section_name
;
2315 unsigned string_offset
;
2320 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2323 stab_section_names
* sought
= (stab_section_names
*) names
;
2325 /* Check for section names for which stabsect_name is a prefix, to
2326 handle .stab.N, etc. */
2327 len
= strlen (sought
->section_name
);
2329 /* If the prefix matches, and the files section name ends with a
2330 nul or a digit, then we match. I.e., we want either an exact
2331 match or a section followed by a number. */
2332 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2333 && (section
->name
[len
] == 0
2334 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2337 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2342 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2345 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2351 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2353 stab_section_names s
;
2355 s
.section_name
= stabsect_name
;
2356 s
.string_section_name
= strsect_name
;
2357 s
.string_offset
= 0;
2359 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2365 /* Dump the any sections containing stabs debugging information. */
2368 dump_stabs (bfd
*abfd
)
2370 dump_stabs_section (abfd
, ".stab", ".stabstr");
2371 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2372 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2373 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2377 dump_bfd_header (bfd
*abfd
)
2381 printf (_("architecture: %s, "),
2382 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2383 bfd_get_mach (abfd
)));
2384 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2386 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2387 PF (HAS_RELOC
, "HAS_RELOC");
2388 PF (EXEC_P
, "EXEC_P");
2389 PF (HAS_LINENO
, "HAS_LINENO");
2390 PF (HAS_DEBUG
, "HAS_DEBUG");
2391 PF (HAS_SYMS
, "HAS_SYMS");
2392 PF (HAS_LOCALS
, "HAS_LOCALS");
2393 PF (DYNAMIC
, "DYNAMIC");
2394 PF (WP_TEXT
, "WP_TEXT");
2395 PF (D_PAGED
, "D_PAGED");
2396 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2397 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2398 printf (_("\nstart address 0x"));
2399 bfd_printf_vma (abfd
, abfd
->start_address
);
2405 dump_bfd_private_header (bfd
*abfd
)
2407 bfd_print_private_bfd_data (abfd
, stdout
);
2411 /* Display a section in hexadecimal format with associated characters.
2412 Each line prefixed by the zero padded address. */
2415 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2418 bfd_size_type datasize
;
2419 bfd_size_type addr_offset
;
2420 bfd_size_type start_offset
;
2421 bfd_size_type stop_offset
;
2422 unsigned int opb
= bfd_octets_per_byte (abfd
);
2423 /* Bytes per line. */
2424 const int onaline
= 16;
2429 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2432 if (! process_section_p (section
))
2435 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2438 printf (_("Contents of section %s:\n"), section
->name
);
2440 data
= xmalloc (datasize
);
2442 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2444 /* Compute the address range to display. */
2445 if (start_address
== (bfd_vma
) -1
2446 || start_address
< section
->vma
)
2449 start_offset
= start_address
- section
->vma
;
2451 if (stop_address
== (bfd_vma
) -1)
2452 stop_offset
= datasize
/ opb
;
2455 if (stop_address
< section
->vma
)
2458 stop_offset
= stop_address
- section
->vma
;
2460 if (stop_offset
> datasize
/ opb
)
2461 stop_offset
= datasize
/ opb
;
2466 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2467 if (strlen (buf
) >= sizeof (buf
))
2471 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2473 count
= strlen (buf
) - count
;
2477 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2478 if (strlen (buf
) >= sizeof (buf
))
2482 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2484 count
= strlen (buf
) - count
;
2488 for (addr_offset
= start_offset
;
2489 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2493 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2494 count
= strlen (buf
);
2495 if ((size_t) count
>= sizeof (buf
))
2499 while (count
< width
)
2504 fputs (buf
+ count
- width
, stdout
);
2507 for (j
= addr_offset
* opb
;
2508 j
< addr_offset
* opb
+ onaline
; j
++)
2510 if (j
< stop_offset
* opb
)
2511 printf ("%02x", (unsigned) (data
[j
]));
2519 for (j
= addr_offset
* opb
;
2520 j
< addr_offset
* opb
+ onaline
; j
++)
2522 if (j
>= stop_offset
* opb
)
2525 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2532 /* Actually display the various requested regions. */
2535 dump_data (bfd
*abfd
)
2537 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2540 /* Should perhaps share code and display with nm? */
2543 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2553 printf ("DYNAMIC SYMBOL TABLE:\n");
2559 printf ("SYMBOL TABLE:\n");
2563 printf (_("no symbols\n"));
2565 for (count
= 0; count
< max
; count
++)
2569 if (*current
== NULL
)
2570 printf (_("no information for symbol number %ld\n"), count
);
2572 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2573 printf (_("could not determine the type of symbol number %ld\n"),
2576 else if (process_section_p ((* current
)->section
)
2577 && (dump_special_syms
2578 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2580 const char *name
= (*current
)->name
;
2582 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2586 /* If we want to demangle the name, we demangle it
2587 here, and temporarily clobber it while calling
2588 bfd_print_symbol. FIXME: This is a gross hack. */
2589 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2591 (*current
)->name
= alloc
;
2592 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2593 bfd_print_symbol_all
);
2596 (*current
)->name
= name
;
2601 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2602 bfd_print_symbol_all
);
2612 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2615 char *last_filename
, *last_functionname
;
2616 unsigned int last_line
;
2618 /* Get column headers lined up reasonably. */
2626 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2627 width
= strlen (buf
) - 7;
2629 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2632 last_filename
= NULL
;
2633 last_functionname
= NULL
;
2636 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2639 const char *filename
, *functionname
;
2641 const char *sym_name
;
2642 const char *section_name
;
2644 if (start_address
!= (bfd_vma
) -1
2645 && q
->address
< start_address
)
2647 if (stop_address
!= (bfd_vma
) -1
2648 && q
->address
> stop_address
)
2651 if (with_line_numbers
2653 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2654 &filename
, &functionname
, &line
))
2656 if (functionname
!= NULL
2657 && (last_functionname
== NULL
2658 || strcmp (functionname
, last_functionname
) != 0))
2660 printf ("%s():\n", functionname
);
2661 if (last_functionname
!= NULL
)
2662 free (last_functionname
);
2663 last_functionname
= xstrdup (functionname
);
2667 && (line
!= last_line
2668 || (filename
!= NULL
2669 && last_filename
!= NULL
2670 && strcmp (filename
, last_filename
) != 0)))
2672 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2674 if (last_filename
!= NULL
)
2675 free (last_filename
);
2676 if (filename
== NULL
)
2677 last_filename
= NULL
;
2679 last_filename
= xstrdup (filename
);
2683 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2685 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2686 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2691 section_name
= NULL
;
2694 bfd_printf_vma (abfd
, q
->address
);
2695 if (q
->howto
== NULL
)
2696 printf (" *unknown* ");
2697 else if (q
->howto
->name
)
2698 printf (" %-16s ", q
->howto
->name
);
2700 printf (" %-16d ", q
->howto
->type
);
2702 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2705 if (section_name
== NULL
)
2706 section_name
= "*unknown*";
2707 printf ("[%s]", section_name
);
2713 bfd_printf_vma (abfd
, q
->addend
);
2721 dump_relocs_in_section (bfd
*abfd
,
2723 void *dummy ATTRIBUTE_UNUSED
)
2729 if ( bfd_is_abs_section (section
)
2730 || bfd_is_und_section (section
)
2731 || bfd_is_com_section (section
)
2732 || (! process_section_p (section
))
2733 || ((section
->flags
& SEC_RELOC
) == 0))
2736 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2738 bfd_fatal (bfd_get_filename (abfd
));
2740 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2744 printf (" (none)\n\n");
2748 relpp
= xmalloc (relsize
);
2749 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2752 bfd_fatal (bfd_get_filename (abfd
));
2753 else if (relcount
== 0)
2754 printf (" (none)\n\n");
2758 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2765 dump_relocs (bfd
*abfd
)
2767 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2771 dump_dynamic_relocs (bfd
*abfd
)
2777 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2779 bfd_fatal (bfd_get_filename (abfd
));
2781 printf ("DYNAMIC RELOCATION RECORDS");
2784 printf (" (none)\n\n");
2787 relpp
= xmalloc (relsize
);
2788 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2791 bfd_fatal (bfd_get_filename (abfd
));
2792 else if (relcount
== 0)
2793 printf (" (none)\n\n");
2797 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2804 /* Creates a table of paths, to search for source files. */
2807 add_include_path (const char *path
)
2811 include_path_count
++;
2812 include_paths
= xrealloc (include_paths
,
2813 include_path_count
* sizeof (*include_paths
));
2814 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2815 if (path
[1] == ':' && path
[2] == 0)
2816 path
= concat (path
, ".", (const char *) 0);
2818 include_paths
[include_path_count
- 1] = path
;
2822 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2826 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2828 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2829 section
->vma
+= adjust_section_vma
;
2831 section
->lma
+= adjust_section_vma
;
2835 /* Dump selected contents of ABFD. */
2838 dump_bfd (bfd
*abfd
)
2840 /* If we are adjusting section VMA's, change them all now. Changing
2841 the BFD information is a hack. However, we must do it, or
2842 bfd_find_nearest_line will not do the right thing. */
2843 if (adjust_section_vma
!= 0)
2845 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2846 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2849 if (! dump_debugging_tags
)
2850 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2853 print_arelt_descr (stdout
, abfd
, TRUE
);
2854 if (dump_file_header
)
2855 dump_bfd_header (abfd
);
2856 if (dump_private_headers
)
2857 dump_bfd_private_header (abfd
);
2858 if (! dump_debugging_tags
)
2860 if (dump_section_headers
)
2861 dump_headers (abfd
);
2867 || dump_dwarf_section_info
)
2868 syms
= slurp_symtab (abfd
);
2869 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2870 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2871 dynsyms
= slurp_dynamic_symtab (abfd
);
2874 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2875 dynsymcount
, dynsyms
, &synthsyms
);
2881 dump_symbols (abfd
, FALSE
);
2882 if (dump_dynamic_symtab
)
2883 dump_symbols (abfd
, TRUE
);
2884 if (dump_dwarf_section_info
)
2886 if (dump_stab_section_info
)
2888 if (dump_reloc_info
&& ! disassemble
)
2890 if (dump_dynamic_reloc_info
&& ! disassemble
)
2891 dump_dynamic_relocs (abfd
);
2892 if (dump_section_contents
)
2895 disassemble_data (abfd
);
2901 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2902 if (dhandle
!= NULL
)
2904 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2906 dump_debugging_tags
? TRUE
: FALSE
))
2908 non_fatal (_("%s: printing debugging information failed"),
2909 bfd_get_filename (abfd
));
2939 display_bfd (bfd
*abfd
)
2943 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2949 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2951 nonfatal (bfd_get_filename (abfd
));
2952 list_matching_formats (matching
);
2957 if (bfd_get_error () != bfd_error_file_not_recognized
)
2959 nonfatal (bfd_get_filename (abfd
));
2963 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2969 nonfatal (bfd_get_filename (abfd
));
2971 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2973 list_matching_formats (matching
);
2979 display_file (char *filename
, char *target
)
2984 if (get_file_size (filename
) < 1)
2990 file
= bfd_openr (filename
, target
);
2993 nonfatal (filename
);
2997 /* If the file is an archive, process all of its elements. */
2998 if (bfd_check_format (file
, bfd_archive
))
3000 bfd
*last_arfile
= NULL
;
3002 printf (_("In archive %s:\n"), bfd_get_filename (file
));
3005 bfd_set_error (bfd_error_no_error
);
3007 arfile
= bfd_openr_next_archived_file (file
, arfile
);
3010 if (bfd_get_error () != bfd_error_no_more_archived_files
)
3011 nonfatal (bfd_get_filename (file
));
3015 display_bfd (arfile
);
3017 if (last_arfile
!= NULL
)
3018 bfd_close (last_arfile
);
3019 last_arfile
= arfile
;
3022 if (last_arfile
!= NULL
)
3023 bfd_close (last_arfile
);
3032 main (int argc
, char **argv
)
3035 char *target
= default_target
;
3036 bfd_boolean seenflag
= FALSE
;
3038 #if defined (HAVE_SETLOCALE)
3039 #if defined (HAVE_LC_MESSAGES)
3040 setlocale (LC_MESSAGES
, "");
3042 setlocale (LC_CTYPE
, "");
3045 bindtextdomain (PACKAGE
, LOCALEDIR
);
3046 textdomain (PACKAGE
);
3048 program_name
= *argv
;
3049 xmalloc_set_program_name (program_name
);
3051 START_PROGRESS (program_name
, 0);
3053 expandargv (&argc
, &argv
);
3056 set_default_bfd_target ();
3058 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3059 long_options
, (int *) 0))
3065 break; /* We've been given a long option. */
3070 if (disassembler_options
)
3071 /* Ignore potential memory leak for now. */
3072 disassembler_options
= concat (disassembler_options
, ",",
3075 disassembler_options
= optarg
;
3078 if (only_used
== only_size
)
3081 only
= xrealloc (only
, only_size
* sizeof (char *));
3083 only
[only_used
++] = optarg
;
3086 with_line_numbers
= TRUE
;
3095 enum demangling_styles style
;
3097 style
= cplus_demangle_name_to_style (optarg
);
3098 if (style
== unknown_demangling
)
3099 fatal (_("unknown demangling style `%s'"),
3102 cplus_demangle_set_style (style
);
3108 case OPTION_ADJUST_VMA
:
3109 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3111 case OPTION_START_ADDRESS
:
3112 start_address
= parse_vma (optarg
, "--start-address");
3114 case OPTION_STOP_ADDRESS
:
3115 stop_address
= parse_vma (optarg
, "--stop-address");
3118 if (strcmp (optarg
, "B") == 0)
3119 endian
= BFD_ENDIAN_BIG
;
3120 else if (strcmp (optarg
, "L") == 0)
3121 endian
= BFD_ENDIAN_LITTLE
;
3124 non_fatal (_("unrecognized -E option"));
3129 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3130 endian
= BFD_ENDIAN_BIG
;
3131 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3132 endian
= BFD_ENDIAN_LITTLE
;
3135 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3141 dump_file_header
= TRUE
;
3145 formats_info
= TRUE
;
3149 add_include_path (optarg
);
3152 dump_private_headers
= TRUE
;
3156 dump_private_headers
= TRUE
;
3158 dump_reloc_info
= TRUE
;
3159 dump_file_header
= TRUE
;
3160 dump_ar_hdrs
= TRUE
;
3161 dump_section_headers
= TRUE
;
3169 dump_dynamic_symtab
= TRUE
;
3177 disassemble_zeroes
= TRUE
;
3181 disassemble_all
= TRUE
;
3186 with_source_code
= TRUE
;
3195 dump_debugging_tags
= 1;
3200 dump_dwarf_section_info
= TRUE
;
3203 do_debug_abbrevs
= 1;
3205 do_debug_pubnames
= 1;
3206 do_debug_aranges
= 1;
3207 do_debug_ranges
= 1;
3208 do_debug_frames
= 1;
3209 do_debug_macinfo
= 1;
3214 dump_stab_section_info
= TRUE
;
3218 dump_section_contents
= TRUE
;
3222 dump_reloc_info
= TRUE
;
3226 dump_dynamic_reloc_info
= TRUE
;
3230 dump_ar_hdrs
= TRUE
;
3234 dump_section_headers
= TRUE
;
3242 show_version
= TRUE
;
3252 print_version ("objdump");
3258 exit_status
= display_info ();
3262 display_file ("a.out", target
);
3264 for (; optind
< argc
;)
3265 display_file (argv
[optind
++], target
);
3268 END_PROGRESS (program_name
);