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"
64 /* Internal headers for the ELF .stab-dump code - sorry. */
65 #define BYTES_IN_WORD 32
66 #include "aout/aout64.h"
69 static int exit_status
= 0;
71 static char *default_target
= NULL
; /* Default at runtime. */
73 /* The following variables are set based on arguments passed on the
75 static int show_version
= 0; /* Show the version number. */
76 static int dump_section_contents
; /* -s */
77 static int dump_section_headers
; /* -h */
78 static bfd_boolean dump_file_header
; /* -f */
79 static int dump_symtab
; /* -t */
80 static int dump_dynamic_symtab
; /* -T */
81 static int dump_reloc_info
; /* -r */
82 static int dump_dynamic_reloc_info
; /* -R */
83 static int dump_ar_hdrs
; /* -a */
84 static int dump_private_headers
; /* -p */
85 static int prefix_addresses
; /* --prefix-addresses */
86 static int with_line_numbers
; /* -l */
87 static bfd_boolean with_source_code
; /* -S */
88 static int show_raw_insn
; /* --show-raw-insn */
89 static int dump_dwarf_section_info
; /* --dwarf */
90 static int dump_stab_section_info
; /* --stabs */
91 static int do_demangle
; /* -C, --demangle */
92 static bfd_boolean disassemble
; /* -d */
93 static bfd_boolean disassemble_all
; /* -D */
94 static int disassemble_zeroes
; /* --disassemble-zeroes */
95 static bfd_boolean formats_info
; /* -i */
96 static int wide_output
; /* -w */
97 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
98 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
99 static int dump_debugging
; /* --debugging */
100 static int dump_debugging_tags
; /* --debugging-tags */
101 static int dump_special_syms
= 0; /* --special-syms */
102 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
103 static int file_start_context
= 0; /* --file-start-context */
105 /* Pointer to an array of section names provided by
106 one or more "-j secname" command line options. */
108 /* The total number of slots in the only[] array. */
109 static size_t only_size
= 0;
110 /* The number of occupied slots in the only[] array. */
111 static size_t only_used
= 0;
113 /* Variables for handling include file path table. */
114 static const char **include_paths
;
115 static int include_path_count
;
117 /* Extra info to pass to the section disassembler and address printing
119 struct objdump_disasm_info
123 bfd_boolean require_sec
;
124 arelent
** dynrelbuf
;
126 disassembler_ftype disassemble_fn
;
130 /* Architecture to disassemble for, or default if NULL. */
131 static char *machine
= NULL
;
133 /* Target specific options to the disassembler. */
134 static char *disassembler_options
= NULL
;
136 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
137 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
139 /* The symbol table. */
140 static asymbol
**syms
;
142 /* Number of symbols in `syms'. */
143 static long symcount
= 0;
145 /* The sorted symbol table. */
146 static asymbol
**sorted_syms
;
148 /* Number of symbols in `sorted_syms'. */
149 static long sorted_symcount
= 0;
151 /* The dynamic symbol table. */
152 static asymbol
**dynsyms
;
154 /* The synthetic symbol table. */
155 static asymbol
*synthsyms
;
156 static long synthcount
= 0;
158 /* Number of symbols in `dynsyms'. */
159 static long dynsymcount
= 0;
161 static bfd_byte
*stabs
;
162 static bfd_size_type stab_size
;
165 static bfd_size_type stabstr_size
;
168 usage (FILE *stream
, int status
)
170 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
171 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
172 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
173 fprintf (stream
, _("\
174 -a, --archive-headers Display archive header information\n\
175 -f, --file-headers Display the contents of the overall file header\n\
176 -p, --private-headers Display object format specific file header contents\n\
177 -h, --[section-]headers Display the contents of the section headers\n\
178 -x, --all-headers Display the contents of all headers\n\
179 -d, --disassemble Display assembler contents of executable sections\n\
180 -D, --disassemble-all Display assembler contents of all sections\n\
181 -S, --source Intermix source code with disassembly\n\
182 -s, --full-contents Display the full contents of all sections requested\n\
183 -g, --debugging Display debug information in object file\n\
184 -e, --debugging-tags Display debug information using ctags style\n\
185 -G, --stabs Display (in raw form) any STABS info in the file\n\
186 -W, --dwarf Display DWARF info in the file\n\
187 -t, --syms Display the contents of the symbol table(s)\n\
188 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
189 -r, --reloc Display the relocation entries in the file\n\
190 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
191 @<file> Read options from <file>\n\
192 -v, --version Display this program's version number\n\
193 -i, --info List object formats and architectures supported\n\
194 -H, --help Display this information\n\
198 fprintf (stream
, _("\n The following switches are optional:\n"));
199 fprintf (stream
, _("\
200 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
201 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
202 -j, --section=NAME Only display information for section NAME\n\
203 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
204 -EB --endian=big Assume big endian format when disassembling\n\
205 -EL --endian=little Assume little endian format when disassembling\n\
206 --file-start-context Include context from start of file (with -S)\n\
207 -I, --include=DIR Add DIR to search list for source files\n\
208 -l, --line-numbers Include line numbers and filenames in output\n\
209 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
210 The STYLE, if specified, can be `auto', `gnu',\n\
211 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
213 -w, --wide Format output for more than 80 columns\n\
214 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
215 --start-address=ADDR Only process data whose address is >= ADDR\n\
216 --stop-address=ADDR Only process data whose address is <= ADDR\n\
217 --prefix-addresses Print complete address alongside disassembly\n\
218 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
219 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
220 --special-syms Include special symbols in symbol dumps\n\
222 list_supported_targets (program_name
, stream
);
223 list_supported_architectures (program_name
, stream
);
225 disassembler_usage (stream
);
227 if (REPORT_BUGS_TO
[0] && status
== 0)
228 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
232 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
236 OPTION_START_ADDRESS
,
241 static struct option long_options
[]=
243 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
244 {"all-headers", no_argument
, NULL
, 'x'},
245 {"private-headers", no_argument
, NULL
, 'p'},
246 {"architecture", required_argument
, NULL
, 'm'},
247 {"archive-headers", no_argument
, NULL
, 'a'},
248 {"debugging", no_argument
, NULL
, 'g'},
249 {"debugging-tags", no_argument
, NULL
, 'e'},
250 {"demangle", optional_argument
, NULL
, 'C'},
251 {"disassemble", no_argument
, NULL
, 'd'},
252 {"disassemble-all", no_argument
, NULL
, 'D'},
253 {"disassembler-options", required_argument
, NULL
, 'M'},
254 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
255 {"dynamic-reloc", no_argument
, NULL
, 'R'},
256 {"dynamic-syms", no_argument
, NULL
, 'T'},
257 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
258 {"file-headers", no_argument
, NULL
, 'f'},
259 {"file-start-context", no_argument
, &file_start_context
, 1},
260 {"full-contents", no_argument
, NULL
, 's'},
261 {"headers", no_argument
, NULL
, 'h'},
262 {"help", no_argument
, NULL
, 'H'},
263 {"info", no_argument
, NULL
, 'i'},
264 {"line-numbers", no_argument
, NULL
, 'l'},
265 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
266 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
267 {"reloc", no_argument
, NULL
, 'r'},
268 {"section", required_argument
, NULL
, 'j'},
269 {"section-headers", no_argument
, NULL
, 'h'},
270 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
271 {"source", no_argument
, NULL
, 'S'},
272 {"special-syms", no_argument
, &dump_special_syms
, 1},
273 {"include", required_argument
, NULL
, 'I'},
274 {"dwarf", no_argument
, NULL
, 'W'},
275 {"stabs", no_argument
, NULL
, 'G'},
276 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
277 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
278 {"syms", no_argument
, NULL
, 't'},
279 {"target", required_argument
, NULL
, 'b'},
280 {"version", no_argument
, NULL
, 'V'},
281 {"wide", no_argument
, NULL
, 'w'},
282 {0, no_argument
, 0, 0}
286 nonfatal (const char *msg
)
293 dump_section_header (bfd
*abfd
, asection
*section
,
294 void *ignored ATTRIBUTE_UNUSED
)
297 unsigned int opb
= bfd_octets_per_byte (abfd
);
299 /* Ignore linker created section. See elfNN_ia64_object_p in
301 if (section
->flags
& SEC_LINKER_CREATED
)
304 printf ("%3d %-13s %08lx ", section
->index
,
305 bfd_get_section_name (abfd
, section
),
306 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
307 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
309 bfd_printf_vma (abfd
, section
->lma
);
310 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
311 bfd_get_section_alignment (abfd
, section
));
317 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
319 PF (SEC_HAS_CONTENTS
, "CONTENTS");
320 PF (SEC_ALLOC
, "ALLOC");
321 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
322 PF (SEC_LOAD
, "LOAD");
323 PF (SEC_RELOC
, "RELOC");
324 PF (SEC_READONLY
, "READONLY");
325 PF (SEC_CODE
, "CODE");
326 PF (SEC_DATA
, "DATA");
328 PF (SEC_DEBUGGING
, "DEBUGGING");
329 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
330 PF (SEC_EXCLUDE
, "EXCLUDE");
331 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
332 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
334 PF (SEC_TIC54X_BLOCK
, "BLOCK");
335 PF (SEC_TIC54X_CLINK
, "CLINK");
337 PF (SEC_SMALL_DATA
, "SMALL_DATA");
338 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
339 PF (SEC_COFF_SHARED
, "SHARED");
340 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
341 PF (SEC_GROUP
, "GROUP");
343 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
346 struct coff_comdat_info
*comdat
;
348 switch (section
->flags
& SEC_LINK_DUPLICATES
)
352 case SEC_LINK_DUPLICATES_DISCARD
:
353 ls
= "LINK_ONCE_DISCARD";
355 case SEC_LINK_DUPLICATES_ONE_ONLY
:
356 ls
= "LINK_ONCE_ONE_ONLY";
358 case SEC_LINK_DUPLICATES_SAME_SIZE
:
359 ls
= "LINK_ONCE_SAME_SIZE";
361 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
362 ls
= "LINK_ONCE_SAME_CONTENTS";
365 printf ("%s%s", comma
, ls
);
367 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
369 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
379 dump_headers (bfd
*abfd
)
381 printf (_("Sections:\n"));
384 printf (_("Idx Name Size VMA LMA File off Algn"));
386 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
387 if (bfd_get_arch_size (abfd
) == 32)
388 printf (_("Idx Name Size VMA LMA File off Algn"));
390 printf (_("Idx Name Size VMA LMA File off Algn"));
394 printf (_(" Flags"));
395 if (abfd
->flags
& HAS_LOAD_PAGE
)
399 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
403 slurp_symtab (bfd
*abfd
)
408 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
414 storage
= bfd_get_symtab_upper_bound (abfd
);
416 bfd_fatal (bfd_get_filename (abfd
));
418 sy
= xmalloc (storage
);
420 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
422 bfd_fatal (bfd_get_filename (abfd
));
426 /* Read in the dynamic symbols. */
429 slurp_dynamic_symtab (bfd
*abfd
)
434 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
437 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
439 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
444 bfd_fatal (bfd_get_filename (abfd
));
447 sy
= xmalloc (storage
);
449 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
451 bfd_fatal (bfd_get_filename (abfd
));
455 /* Filter out (in place) symbols that are useless for disassembly.
456 COUNT is the number of elements in SYMBOLS.
457 Return the number of useful symbols. */
460 remove_useless_symbols (asymbol
**symbols
, long count
)
462 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
466 asymbol
*sym
= *in_ptr
++;
468 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
470 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
472 if (bfd_is_und_section (sym
->section
)
473 || bfd_is_com_section (sym
->section
))
478 return out_ptr
- symbols
;
481 /* Sort symbols into value order. */
484 compare_symbols (const void *ap
, const void *bp
)
486 const asymbol
*a
= * (const asymbol
**) ap
;
487 const asymbol
*b
= * (const asymbol
**) bp
;
497 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
499 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
502 if (a
->section
> b
->section
)
504 else if (a
->section
< b
->section
)
507 an
= bfd_asymbol_name (a
);
508 bn
= bfd_asymbol_name (b
);
512 /* The symbols gnu_compiled and gcc2_compiled convey no real
513 information, so put them after other symbols with the same value. */
514 af
= (strstr (an
, "gnu_compiled") != NULL
515 || strstr (an
, "gcc2_compiled") != NULL
);
516 bf
= (strstr (bn
, "gnu_compiled") != NULL
517 || strstr (bn
, "gcc2_compiled") != NULL
);
524 /* We use a heuristic for the file name, to try to sort it after
525 more useful symbols. It may not work on non Unix systems, but it
526 doesn't really matter; the only difference is precisely which
527 symbol names get printed. */
529 #define file_symbol(s, sn, snl) \
530 (((s)->flags & BSF_FILE) != 0 \
531 || ((sn)[(snl) - 2] == '.' \
532 && ((sn)[(snl) - 1] == 'o' \
533 || (sn)[(snl) - 1] == 'a')))
535 af
= file_symbol (a
, an
, anl
);
536 bf
= file_symbol (b
, bn
, bnl
);
543 /* Try to sort global symbols before local symbols before function
544 symbols before debugging symbols. */
549 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
551 if ((aflags
& BSF_DEBUGGING
) != 0)
556 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
558 if ((aflags
& BSF_FUNCTION
) != 0)
563 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
565 if ((aflags
& BSF_LOCAL
) != 0)
570 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
572 if ((aflags
& BSF_GLOBAL
) != 0)
578 /* Symbols that start with '.' might be section names, so sort them
579 after symbols that don't start with '.'. */
580 if (an
[0] == '.' && bn
[0] != '.')
582 if (an
[0] != '.' && bn
[0] == '.')
585 /* Finally, if we can't distinguish them in any other way, try to
586 get consistent results by sorting the symbols by name. */
587 return strcmp (an
, bn
);
590 /* Sort relocs into address order. */
593 compare_relocs (const void *ap
, const void *bp
)
595 const arelent
*a
= * (const arelent
**) ap
;
596 const arelent
*b
= * (const arelent
**) bp
;
598 if (a
->address
> b
->address
)
600 else if (a
->address
< b
->address
)
603 /* So that associated relocations tied to the same address show up
604 in the correct order, we don't do any further sorting. */
613 /* Print an address (VMA) to the output stream in INFO.
614 If SKIP_ZEROES is TRUE, omit leading zeroes. */
617 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
618 bfd_boolean skip_zeroes
)
622 struct objdump_disasm_info
*aux
;
624 aux
= (struct objdump_disasm_info
*) info
->application_data
;
625 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
630 for (p
= buf
; *p
== '0'; ++p
)
635 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
638 /* Print the name of a symbol. */
641 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
648 name
= bfd_asymbol_name (sym
);
649 if (do_demangle
&& name
[0] != '\0')
651 /* Demangle the name. */
652 alloc
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
658 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
666 /* Locate a symbol given a bfd and a section (from INFO->application_data),
667 and a VMA. If INFO->application_data->require_sec is TRUE, then always
668 require the symbol to be in the section. Returns NULL if there is no
669 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
670 of the symbol in sorted_syms. */
673 find_symbol_for_address (bfd_vma vma
,
674 struct disassemble_info
*info
,
677 /* @@ Would it speed things up to cache the last two symbols returned,
678 and maybe their address ranges? For many processors, only one memory
679 operand can be present at a time, so the 2-entry cache wouldn't be
680 constantly churned by code doing heavy memory accesses. */
682 /* Indices in `sorted_syms'. */
684 long max
= sorted_symcount
;
686 struct objdump_disasm_info
*aux
;
691 if (sorted_symcount
< 1)
694 aux
= (struct objdump_disasm_info
*) info
->application_data
;
697 opb
= bfd_octets_per_byte (abfd
);
699 /* Perform a binary search looking for the closest symbol to the
700 required value. We are searching the range (min, max]. */
701 while (min
+ 1 < max
)
705 thisplace
= (max
+ min
) / 2;
706 sym
= sorted_syms
[thisplace
];
708 if (bfd_asymbol_value (sym
) > vma
)
710 else if (bfd_asymbol_value (sym
) < vma
)
719 /* The symbol we want is now in min, the low end of the range we
720 were searching. If there are several symbols with the same
721 value, we want the first one. */
724 && (bfd_asymbol_value (sorted_syms
[thisplace
])
725 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
728 /* If the file is relocatable, and the symbol could be from this
729 section, prefer a symbol from this section over symbols from
730 others, even if the other symbol's value might be closer.
732 Note that this may be wrong for some symbol references if the
733 sections have overlapping memory ranges, but in that case there's
734 no way to tell what's desired without looking at the relocation
736 if (sorted_syms
[thisplace
]->section
!= sec
738 || ((abfd
->flags
& HAS_RELOC
) != 0
739 && vma
>= bfd_get_section_vma (abfd
, sec
)
740 && vma
< (bfd_get_section_vma (abfd
, sec
)
741 + bfd_section_size (abfd
, sec
) / opb
))))
745 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
747 if (bfd_asymbol_value (sorted_syms
[i
])
748 != bfd_asymbol_value (sorted_syms
[thisplace
]))
756 if (sorted_syms
[i
]->section
== sec
758 || sorted_syms
[i
- 1]->section
!= sec
759 || (bfd_asymbol_value (sorted_syms
[i
])
760 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
767 if (sorted_syms
[thisplace
]->section
!= sec
)
769 /* We didn't find a good symbol with a smaller value.
770 Look for one with a larger value. */
771 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
773 if (sorted_syms
[i
]->section
== sec
)
781 if (sorted_syms
[thisplace
]->section
!= sec
783 || ((abfd
->flags
& HAS_RELOC
) != 0
784 && vma
>= bfd_get_section_vma (abfd
, sec
)
785 && vma
< (bfd_get_section_vma (abfd
, sec
)
786 + bfd_section_size (abfd
, sec
)))))
787 /* There is no suitable symbol. */
791 /* Give the target a chance to reject the symbol. */
792 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
795 if (thisplace
>= sorted_symcount
796 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
803 return sorted_syms
[thisplace
];
806 /* Print an address and the offset to the nearest symbol. */
809 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
810 bfd_vma vma
, struct disassemble_info
*info
,
811 bfd_boolean skip_zeroes
)
813 objdump_print_value (vma
, info
, skip_zeroes
);
819 (*info
->fprintf_func
) (info
->stream
, " <%s",
820 bfd_get_section_name (abfd
, sec
));
821 secaddr
= bfd_get_section_vma (abfd
, sec
);
824 (*info
->fprintf_func
) (info
->stream
, "-0x");
825 objdump_print_value (secaddr
- vma
, info
, TRUE
);
827 else if (vma
> secaddr
)
829 (*info
->fprintf_func
) (info
->stream
, "+0x");
830 objdump_print_value (vma
- secaddr
, info
, TRUE
);
832 (*info
->fprintf_func
) (info
->stream
, ">");
836 (*info
->fprintf_func
) (info
->stream
, " <");
837 objdump_print_symname (abfd
, info
, sym
);
838 if (bfd_asymbol_value (sym
) > vma
)
840 (*info
->fprintf_func
) (info
->stream
, "-0x");
841 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
843 else if (vma
> bfd_asymbol_value (sym
))
845 (*info
->fprintf_func
) (info
->stream
, "+0x");
846 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
848 (*info
->fprintf_func
) (info
->stream
, ">");
852 /* Print an address (VMA), symbolically if possible.
853 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
856 objdump_print_addr (bfd_vma vma
,
857 struct disassemble_info
*info
,
858 bfd_boolean skip_zeroes
)
860 struct objdump_disasm_info
*aux
;
861 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
862 bfd_boolean skip_find
= FALSE
;
864 if (sorted_symcount
< 1)
866 (*info
->fprintf_func
) (info
->stream
, "0x");
867 objdump_print_value (vma
, info
, skip_zeroes
);
871 aux
= (struct objdump_disasm_info
*) info
->application_data
;
873 if (aux
->reloc
!= NULL
874 && aux
->reloc
->sym_ptr_ptr
!= NULL
875 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
877 sym
= * aux
->reloc
->sym_ptr_ptr
;
879 /* Adjust the vma to the reloc. */
880 vma
+= bfd_asymbol_value (sym
);
882 if (bfd_is_und_section (bfd_get_section (sym
)))
887 sym
= find_symbol_for_address (vma
, info
, NULL
);
889 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
893 /* Print VMA to INFO. This function is passed to the disassembler
897 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
899 objdump_print_addr (vma
, info
, ! prefix_addresses
);
902 /* Determine if the given address has a symbol associated with it. */
905 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
909 sym
= find_symbol_for_address (vma
, info
, NULL
);
911 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
914 /* Hold the last function name and the last line number we displayed
917 static char *prev_functionname
;
918 static unsigned int prev_line
;
920 /* We keep a list of all files that we have seen when doing a
921 disassembly with source, so that we know how much of the file to
922 display. This can be important for inlined functions. */
924 struct print_file_list
926 struct print_file_list
*next
;
927 const char *filename
;
933 static struct print_file_list
*print_files
;
935 /* The number of preceding context lines to show when we start
936 displaying a file for the first time. */
938 #define SHOW_PRECEDING_CONTEXT_LINES (5)
940 /* Tries to open MODNAME, and if successful adds a node to print_files
941 linked list and returns that node. Returns NULL on failure. */
943 static struct print_file_list
*
944 try_print_file_open (const char *origname
, const char *modname
)
946 struct print_file_list
*p
;
949 f
= fopen (modname
, "r");
953 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
955 fclose (print_files
->f
);
956 print_files
->f
= NULL
;
959 p
= xmalloc (sizeof (struct print_file_list
));
960 p
->filename
= origname
;
961 p
->modname
= modname
;
964 p
->next
= print_files
;
969 /* If the the source file, as described in the symtab, is not found
970 try to locate it in one of the paths specified with -I
971 If found, add location to print_files linked list. */
973 static struct print_file_list
*
974 update_source_path (const char *filename
)
976 struct print_file_list
*p
;
980 if (filename
== NULL
)
983 p
= try_print_file_open (filename
, filename
);
987 if (include_path_count
== 0)
990 /* Get the name of the file. */
991 fname
= strrchr (filename
, '/');
992 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
994 /* We could have a mixed forward/back slash case. */
995 char *backslash
= strrchr (filename
, '\\');
996 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
998 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
999 fname
= filename
+ 1;
1007 /* If file exists under a new path, we need to add it to the list
1008 so that show_line knows about it. */
1009 for (i
= 0; i
< include_path_count
; i
++)
1011 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1013 p
= try_print_file_open (filename
, modname
);
1023 /* Skip ahead to a given line in a file, optionally printing each
1027 skip_to_line (struct print_file_list
*p
, unsigned int line
,
1030 while (p
->line
< line
)
1034 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1044 if (strchr (buf
, '\n') != NULL
)
1049 /* Show the line number, or the source line, in a disassembly
1053 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1055 const char *filename
;
1056 const char *functionname
;
1059 if (! with_line_numbers
&& ! with_source_code
)
1062 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1063 &functionname
, &line
))
1066 if (filename
!= NULL
&& *filename
== '\0')
1068 if (functionname
!= NULL
&& *functionname
== '\0')
1069 functionname
= NULL
;
1071 if (with_line_numbers
)
1073 if (functionname
!= NULL
1074 && (prev_functionname
== NULL
1075 || strcmp (functionname
, prev_functionname
) != 0))
1076 printf ("%s():\n", functionname
);
1077 if (line
> 0 && line
!= prev_line
)
1078 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1081 if (with_source_code
1085 struct print_file_list
**pp
, *p
;
1087 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1088 if (strcmp ((*pp
)->filename
, filename
) == 0)
1094 if (p
!= print_files
)
1098 /* We have reencountered a file name which we saw
1099 earlier. This implies that either we are dumping out
1100 code from an included file, or the same file was
1101 linked in more than once. There are two common cases
1102 of an included file: inline functions in a header
1103 file, and a bison or flex skeleton file. In the
1104 former case we want to just start printing (but we
1105 back up a few lines to give context); in the latter
1106 case we want to continue from where we left off. I
1107 can't think of a good way to distinguish the cases,
1108 so I used a heuristic based on the file name. */
1109 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1113 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1120 p
->f
= fopen (p
->modname
, "r");
1124 skip_to_line (p
, l
, FALSE
);
1126 if (print_files
->f
!= NULL
)
1128 fclose (print_files
->f
);
1129 print_files
->f
= NULL
;
1135 skip_to_line (p
, line
, TRUE
);
1137 p
->next
= print_files
;
1143 p
= update_source_path (filename
);
1149 if (file_start_context
)
1152 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1155 skip_to_line (p
, l
, FALSE
);
1157 skip_to_line (p
, line
, TRUE
);
1162 if (functionname
!= NULL
1163 && (prev_functionname
== NULL
1164 || strcmp (functionname
, prev_functionname
) != 0))
1166 if (prev_functionname
!= NULL
)
1167 free (prev_functionname
);
1168 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1169 strcpy (prev_functionname
, functionname
);
1172 if (line
> 0 && line
!= prev_line
)
1176 /* Pseudo FILE object for strings. */
1184 /* sprintf to a "stream". */
1186 static int ATTRIBUTE_PRINTF_2
1187 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1194 size_t space
= f
->alloc
- f
->pos
;
1196 va_start (args
, format
);
1197 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1203 f
->alloc
= (f
->alloc
+ n
) * 2;
1204 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1211 /* Returns TRUE if the specified section should be dumped. */
1214 process_section_p (asection
* section
)
1221 for (i
= 0; i
< only_used
; i
++)
1222 if (strcmp (only
[i
], section
->name
) == 0)
1229 /* The number of zeroes we want to see before we start skipping them.
1230 The number is arbitrarily chosen. */
1232 #define DEFAULT_SKIP_ZEROES 8
1234 /* The number of zeroes to skip at the end of a section. If the
1235 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1236 SKIP_ZEROES, they will be disassembled. If there are fewer than
1237 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1238 attempt to avoid disassembling zeroes inserted by section
1241 #define DEFAULT_SKIP_ZEROES_AT_END 3
1243 /* Disassemble some data in memory between given values. */
1246 disassemble_bytes (struct disassemble_info
* info
,
1247 disassembler_ftype disassemble_fn
,
1250 bfd_vma start_offset
,
1251 bfd_vma stop_offset
,
1254 arelent
** relppend
)
1256 struct objdump_disasm_info
*aux
;
1258 int octets_per_line
;
1259 bfd_boolean done_dot
;
1260 int skip_addr_chars
;
1261 bfd_vma addr_offset
;
1262 unsigned int opb
= info
->octets_per_byte
;
1263 unsigned int skip_zeroes
= info
->skip_zeroes
;
1264 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1268 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1272 sfile
.buffer
= xmalloc (sfile
.alloc
);
1276 octets_per_line
= 4;
1278 octets_per_line
= 16;
1280 /* Figure out how many characters to skip at the start of an
1281 address, to make the disassembly look nicer. We discard leading
1282 zeroes in chunks of 4, ensuring that there is always a leading
1284 skip_addr_chars
= 0;
1285 if (! prefix_addresses
)
1293 + bfd_section_size (section
->owner
, section
) / opb
));
1295 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1298 skip_addr_chars
+= 4;
1303 info
->insn_info_valid
= 0;
1306 addr_offset
= start_offset
;
1307 while (addr_offset
< stop_offset
)
1310 bfd_boolean need_nl
= FALSE
;
1311 int previous_octets
;
1313 /* Remember the length of the previous instruction. */
1314 previous_octets
= octets
;
1317 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1319 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1322 if (! disassemble_zeroes
1323 && (info
->insn_info_valid
== 0
1324 || info
->branch_delay_insns
== 0)
1325 && (z
- addr_offset
* opb
>= skip_zeroes
1326 || (z
== stop_offset
* opb
&&
1327 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1331 /* If there are more nonzero octets to follow, we only skip
1332 zeroes in multiples of 4, to try to avoid running over
1333 the start of an instruction which happens to start with
1335 if (z
!= stop_offset
* opb
)
1336 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1338 octets
= z
- addr_offset
* opb
;
1348 if (with_line_numbers
|| with_source_code
)
1349 show_line (aux
->abfd
, section
, addr_offset
);
1351 if (! prefix_addresses
)
1355 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1356 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1360 printf ("%s:\t", buf
+ skip_addr_chars
);
1364 aux
->require_sec
= TRUE
;
1365 objdump_print_address (section
->vma
+ addr_offset
, info
);
1366 aux
->require_sec
= FALSE
;
1373 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1374 info
->stream
= &sfile
;
1375 info
->bytes_per_line
= 0;
1376 info
->bytes_per_chunk
= 0;
1379 if (info
->disassembler_needs_relocs
1380 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1381 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1382 && *relppp
< relppend
)
1384 bfd_signed_vma distance_to_rel
;
1386 distance_to_rel
= (**relppp
)->address
1387 - (rel_offset
+ addr_offset
);
1389 /* Check to see if the current reloc is associated with
1390 the instruction that we are about to disassemble. */
1391 if (distance_to_rel
== 0
1392 /* FIXME: This is wrong. We are trying to catch
1393 relocs that are addressed part way through the
1394 current instruction, as might happen with a packed
1395 VLIW instruction. Unfortunately we do not know the
1396 length of the current instruction since we have not
1397 disassembled it yet. Instead we take a guess based
1398 upon the length of the previous instruction. The
1399 proper solution is to have a new target-specific
1400 disassembler function which just returns the length
1401 of an instruction at a given address without trying
1402 to display its disassembly. */
1403 || (distance_to_rel
> 0
1404 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1406 info
->flags
= INSN_HAS_RELOC
;
1407 aux
->reloc
= **relppp
;
1413 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1414 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1415 info
->stream
= stdout
;
1416 if (info
->bytes_per_line
!= 0)
1417 octets_per_line
= info
->bytes_per_line
;
1421 printf ("%s\n", sfile
.buffer
);
1429 octets
= octets_per_line
;
1430 if (addr_offset
+ octets
/ opb
> stop_offset
)
1431 octets
= (stop_offset
- addr_offset
) * opb
;
1433 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1435 if (ISPRINT (data
[j
]))
1436 buf
[j
- addr_offset
* opb
] = data
[j
];
1438 buf
[j
- addr_offset
* opb
] = '.';
1440 buf
[j
- addr_offset
* opb
] = '\0';
1443 if (prefix_addresses
1445 : show_raw_insn
>= 0)
1449 /* If ! prefix_addresses and ! wide_output, we print
1450 octets_per_line octets per line. */
1452 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1453 pb
= octets_per_line
;
1455 if (info
->bytes_per_chunk
)
1456 bpc
= info
->bytes_per_chunk
;
1460 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1464 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1466 for (k
= bpc
- 1; k
>= 0; k
--)
1467 printf ("%02x", (unsigned) data
[j
+ k
]);
1472 for (k
= 0; k
< bpc
; k
++)
1473 printf ("%02x", (unsigned) data
[j
+ k
]);
1478 for (; pb
< octets_per_line
; pb
+= bpc
)
1482 for (k
= 0; k
< bpc
; k
++)
1487 /* Separate raw data from instruction by extra space. */
1497 printf ("%s", sfile
.buffer
);
1499 if (prefix_addresses
1501 : show_raw_insn
>= 0)
1509 j
= addr_offset
* opb
+ pb
;
1511 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1512 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1516 printf ("%s:\t", buf
+ skip_addr_chars
);
1518 pb
+= octets_per_line
;
1521 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1525 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1527 for (k
= bpc
- 1; k
>= 0; k
--)
1528 printf ("%02x", (unsigned) data
[j
+ k
]);
1533 for (k
= 0; k
< bpc
; k
++)
1534 printf ("%02x", (unsigned) data
[j
+ k
]);
1547 while ((*relppp
) < relppend
1548 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1550 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1561 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1564 if (q
->howto
== NULL
)
1565 printf (": *unknown*\t");
1566 else if (q
->howto
->name
)
1567 printf (": %s\t", q
->howto
->name
);
1569 printf (": %d\t", q
->howto
->type
);
1571 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1572 printf ("*unknown*");
1575 const char *sym_name
;
1577 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1578 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1579 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1584 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1585 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1586 if (sym_name
== NULL
|| *sym_name
== '\0')
1587 sym_name
= "*unknown*";
1588 printf ("%s", sym_name
);
1595 objdump_print_value (q
->addend
, info
, TRUE
);
1607 addr_offset
+= octets
/ opb
;
1610 free (sfile
.buffer
);
1614 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1616 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1617 struct objdump_disasm_info
* paux
;
1618 unsigned int opb
= pinfo
->octets_per_byte
;
1619 bfd_byte
* data
= NULL
;
1620 bfd_size_type datasize
= 0;
1621 arelent
** rel_pp
= NULL
;
1622 arelent
** rel_ppstart
= NULL
;
1623 arelent
** rel_ppend
;
1624 unsigned long stop_offset
;
1625 asymbol
* sym
= NULL
;
1629 unsigned long addr_offset
;
1631 /* Sections that do not contain machine
1632 code are not normally disassembled. */
1633 if (! disassemble_all
1635 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1636 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1639 if (! process_section_p (section
))
1642 datasize
= bfd_get_section_size (section
);
1646 /* Decide which set of relocs to use. Load them if necessary. */
1647 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1648 if (paux
->dynrelbuf
)
1650 rel_pp
= paux
->dynrelbuf
;
1651 rel_count
= paux
->dynrelcount
;
1652 /* Dynamic reloc addresses are absolute, non-dynamic are section
1653 relative. REL_OFFSET specifies the reloc address corresponding
1654 to the start of this section. */
1655 rel_offset
= section
->vma
;
1663 if ((section
->flags
& SEC_RELOC
) != 0
1664 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1668 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1670 bfd_fatal (bfd_get_filename (abfd
));
1674 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1675 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1677 bfd_fatal (bfd_get_filename (abfd
));
1679 /* Sort the relocs by address. */
1680 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1685 rel_ppend
= rel_pp
+ rel_count
;
1687 data
= xmalloc (datasize
);
1689 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1691 paux
->sec
= section
;
1692 pinfo
->buffer
= data
;
1693 pinfo
->buffer_vma
= section
->vma
;
1694 pinfo
->buffer_length
= datasize
;
1695 pinfo
->section
= section
;
1697 if (start_address
== (bfd_vma
) -1
1698 || start_address
< pinfo
->buffer_vma
)
1701 addr_offset
= start_address
- pinfo
->buffer_vma
;
1703 if (stop_address
== (bfd_vma
) -1)
1704 stop_offset
= datasize
/ opb
;
1707 if (stop_address
< pinfo
->buffer_vma
)
1710 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1711 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1712 stop_offset
= pinfo
->buffer_length
/ opb
;
1715 /* Skip over the relocs belonging to addresses below the
1717 while (rel_pp
< rel_ppend
1718 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1721 printf (_("Disassembly of section %s:\n"), section
->name
);
1723 /* Find the nearest symbol forwards from our current position. */
1724 paux
->require_sec
= TRUE
;
1725 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1726 paux
->require_sec
= FALSE
;
1728 /* Disassemble a block of instructions up to the address associated with
1729 the symbol we have just found. Then print the symbol and find the
1730 next symbol on. Repeat until we have disassembled the entire section
1731 or we have reached the end of the address range we are interested in. */
1732 while (addr_offset
< stop_offset
)
1736 unsigned long nextstop_offset
;
1739 addr
= section
->vma
+ addr_offset
;
1741 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1746 (x
< sorted_symcount
1747 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1751 pinfo
->symbols
= sorted_syms
+ place
;
1752 pinfo
->num_symbols
= x
- place
;
1753 pinfo
->symtab_pos
= place
;
1757 pinfo
->symbols
= NULL
;
1758 pinfo
->num_symbols
= 0;
1759 pinfo
->symtab_pos
= -1;
1762 if (! prefix_addresses
)
1764 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1765 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1767 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1770 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1772 else if (sym
== NULL
)
1776 #define is_valid_next_sym(SYM) \
1777 ((SYM)->section == section \
1778 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1779 && pinfo->symbol_is_valid (SYM, pinfo))
1781 /* Search forward for the next appropriate symbol in
1782 SECTION. Note that all the symbols are sorted
1783 together into one big array, and that some sections
1784 may have overlapping addresses. */
1785 while (place
< sorted_symcount
1786 && ! is_valid_next_sym (sorted_syms
[place
]))
1789 if (place
>= sorted_symcount
)
1792 nextsym
= sorted_syms
[place
];
1795 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1796 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1797 else if (nextsym
== NULL
)
1798 nextstop_offset
= stop_offset
;
1800 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1802 if (nextstop_offset
> stop_offset
)
1803 nextstop_offset
= stop_offset
;
1805 /* If a symbol is explicitly marked as being an object
1806 rather than a function, just dump the bytes without
1807 disassembling them. */
1810 || bfd_asymbol_value (sym
) > addr
1811 || ((sym
->flags
& BSF_OBJECT
) == 0
1812 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1814 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1816 || (sym
->flags
& BSF_FUNCTION
) != 0)
1821 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1822 addr_offset
, nextstop_offset
,
1823 rel_offset
, &rel_pp
, rel_ppend
);
1825 addr_offset
= nextstop_offset
;
1831 if (rel_ppstart
!= NULL
)
1835 /* Disassemble the contents of an object file. */
1838 disassemble_data (bfd
*abfd
)
1840 struct disassemble_info disasm_info
;
1841 struct objdump_disasm_info aux
;
1845 prev_functionname
= NULL
;
1848 /* We make a copy of syms to sort. We don't want to sort syms
1849 because that will screw up the relocs. */
1850 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1851 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1852 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1853 sorted_symcount
* sizeof (asymbol
*));
1855 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1857 for (i
= 0; i
< synthcount
; ++i
)
1859 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1863 /* Sort the symbols into section and symbol order. */
1864 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1866 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1868 disasm_info
.application_data
= (void *) &aux
;
1870 aux
.require_sec
= FALSE
;
1871 aux
.dynrelbuf
= NULL
;
1872 aux
.dynrelcount
= 0;
1875 disasm_info
.print_address_func
= objdump_print_address
;
1876 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1878 if (machine
!= NULL
)
1880 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1883 fatal (_("Can't use supplied machine %s"), machine
);
1885 abfd
->arch_info
= info
;
1888 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1890 struct bfd_target
*xvec
;
1892 xvec
= xmalloc (sizeof (struct bfd_target
));
1893 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1894 xvec
->byteorder
= endian
;
1898 /* Use libopcodes to locate a suitable disassembler. */
1899 aux
.disassemble_fn
= disassembler (abfd
);
1900 if (!aux
.disassemble_fn
)
1902 non_fatal (_("Can't disassemble for architecture %s\n"),
1903 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1908 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1909 disasm_info
.arch
= bfd_get_arch (abfd
);
1910 disasm_info
.mach
= bfd_get_mach (abfd
);
1911 disasm_info
.disassembler_options
= disassembler_options
;
1912 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1913 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1914 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1915 disasm_info
.disassembler_needs_relocs
= FALSE
;
1917 if (bfd_big_endian (abfd
))
1918 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1919 else if (bfd_little_endian (abfd
))
1920 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1922 /* ??? Aborting here seems too drastic. We could default to big or little
1924 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1926 /* Allow the target to customize the info structure. */
1927 disassemble_init_for_target (& disasm_info
);
1929 /* Pre-load the dynamic relocs if we are going
1930 to be dumping them along with the disassembly. */
1931 if (dump_dynamic_reloc_info
)
1933 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1936 bfd_fatal (bfd_get_filename (abfd
));
1940 aux
.dynrelbuf
= xmalloc (relsize
);
1941 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1944 if (aux
.dynrelcount
< 0)
1945 bfd_fatal (bfd_get_filename (abfd
));
1947 /* Sort the relocs by address. */
1948 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1952 disasm_info
.symtab
= sorted_syms
;
1953 disasm_info
.symtab_size
= sorted_symcount
;
1955 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1957 if (aux
.dynrelbuf
!= NULL
)
1958 free (aux
.dynrelbuf
);
1963 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
1965 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
1970 /* If it is already loaded, do nothing. */
1971 if (section
->start
!= NULL
)
1974 /* Locate the debug section. */
1975 sec
= bfd_get_section_by_name (abfd
, section
->name
);
1979 /* Compute a bias to be added to offsets found within the DWARF debug
1980 information. These offsets are meant to be relative to the start of
1981 the dwarf section, and hence the bias should be 0. For MACH-O however
1982 a dwarf section is really just a region of a much larger section and so
1983 the bias is the address of the start of that area within the larger
1984 section. This test is important for PE and COFF based targets which
1985 use DWARF debug information, since unlike ELF, they do not allow the
1986 dwarf sections to be placed at address 0. */
1987 if (bfd_get_flavour (abfd
) == bfd_target_mach_o_flavour
)
1988 section
->address
= bfd_get_section_vma (abfd
, sec
);
1990 section
->address
= 0;
1992 section
->size
= bfd_get_section_size (sec
);
1993 section
->start
= xmalloc (section
->size
);
1995 if (is_relocatable
&& debug_displays
[debug
].relocate
)
1996 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2001 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
2006 free_debug_section (debug
);
2007 printf (_("\nCan't get contents for section '%s'.\n"),
2015 free_debug_section (enum dwarf_section_display_enum debug
)
2017 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2019 if (section
->start
== NULL
)
2022 free ((char *) section
->start
);
2023 section
->start
= NULL
;
2024 section
->address
= 0;
2029 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2030 void *arg ATTRIBUTE_UNUSED
)
2032 const char *name
= bfd_get_section_name (abfd
, section
);
2034 enum dwarf_section_display_enum i
;
2036 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2037 match
= ".debug_info";
2041 for (i
= 0; i
< max
; i
++)
2042 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2044 if (!debug_displays
[i
].eh_frame
)
2046 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2048 if (load_debug_section (i
, abfd
))
2050 debug_displays
[i
].display (sec
, abfd
);
2052 if (i
!= info
&& i
!= abbrev
)
2053 free_debug_section (i
);
2060 static const char *mach_o_dwarf_sections
[] = {
2061 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2062 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2063 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2064 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2065 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2066 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2067 ".eh_frame", /* .eh_frame */
2068 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2069 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2070 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2071 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2072 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2073 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2074 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2075 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2076 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2079 static const char *generic_dwarf_sections
[max
];
2082 check_mach_o_dwarf (bfd
*abfd
)
2084 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2085 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2086 enum dwarf_section_display_enum i
;
2088 if (generic_dwarf_sections
[0] == NULL
)
2089 for (i
= 0; i
< max
; i
++)
2090 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2092 if (old_flavour
!= current_flavour
)
2094 if (current_flavour
== bfd_target_mach_o_flavour
)
2095 for (i
= 0; i
< max
; i
++)
2096 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2097 else if (old_flavour
== bfd_target_mach_o_flavour
)
2098 for (i
= 0; i
< max
; i
++)
2099 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2101 old_flavour
= current_flavour
;
2105 /* Dump the dwarf debugging information. */
2108 dump_dwarf (bfd
*abfd
)
2110 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2113 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2114 targets will return 64. */
2115 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2117 if (bfd_big_endian (abfd
))
2118 byte_get
= byte_get_big_endian
;
2119 else if (bfd_little_endian (abfd
))
2120 byte_get
= byte_get_little_endian
;
2124 check_mach_o_dwarf (abfd
);
2126 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2128 free_debug_memory ();
2131 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2132 it. Return NULL on failure. */
2135 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2141 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2142 if (stabsect
== NULL
)
2144 printf (_("No %s section present\n\n"), sect_name
);
2148 size
= bfd_section_size (abfd
, stabsect
);
2149 contents
= xmalloc (size
);
2151 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2153 non_fatal (_("Reading %s section of %s failed: %s"),
2154 sect_name
, bfd_get_filename (abfd
),
2155 bfd_errmsg (bfd_get_error ()));
2166 /* Stabs entries use a 12 byte format:
2167 4 byte string table index
2169 1 byte stab other field
2170 2 byte stab desc field
2172 FIXME: This will have to change for a 64 bit object format. */
2174 #define STRDXOFF (0)
2176 #define OTHEROFF (5)
2179 #define STABSIZE (12)
2181 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2182 using string table section STRSECT_NAME (in `strtab'). */
2185 print_section_stabs (bfd
*abfd
,
2186 const char *stabsect_name
,
2187 unsigned *string_offset_ptr
)
2190 unsigned file_string_table_offset
= 0;
2191 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2192 bfd_byte
*stabp
, *stabs_end
;
2195 stabs_end
= stabp
+ stab_size
;
2197 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2198 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2200 /* Loop through all symbols and print them.
2202 We start the index at -1 because there is a dummy symbol on
2203 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2204 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2208 unsigned char type
, other
;
2209 unsigned short desc
;
2212 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2213 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2214 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2215 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2216 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2218 printf ("\n%-6d ", i
);
2219 /* Either print the stab name, or, if unnamed, print its number
2220 again (makes consistent formatting for tools like awk). */
2221 name
= bfd_get_stab_name (type
);
2223 printf ("%-6s", name
);
2224 else if (type
== N_UNDF
)
2227 printf ("%-6d", type
);
2228 printf (" %-6d %-6d ", other
, desc
);
2229 bfd_printf_vma (abfd
, value
);
2230 printf (" %-6lu", strx
);
2232 /* Symbols with type == 0 (N_UNDF) specify the length of the
2233 string table associated with this file. We use that info
2234 to know how to relocate the *next* file's string table indices. */
2237 file_string_table_offset
= next_file_string_table_offset
;
2238 next_file_string_table_offset
+= value
;
2242 /* Using the (possibly updated) string table offset, print the
2243 string (if any) associated with this symbol. */
2244 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2245 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2251 *string_offset_ptr
= next_file_string_table_offset
;
2256 const char * section_name
;
2257 const char * string_section_name
;
2258 unsigned string_offset
;
2263 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2266 stab_section_names
* sought
= (stab_section_names
*) names
;
2268 /* Check for section names for which stabsect_name is a prefix, to
2269 handle .stab.N, etc. */
2270 len
= strlen (sought
->section_name
);
2272 /* If the prefix matches, and the files section name ends with a
2273 nul or a digit, then we match. I.e., we want either an exact
2274 match or a section followed by a number. */
2275 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2276 && (section
->name
[len
] == 0
2277 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2280 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2285 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2288 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2294 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2296 stab_section_names s
;
2298 s
.section_name
= stabsect_name
;
2299 s
.string_section_name
= strsect_name
;
2300 s
.string_offset
= 0;
2302 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2308 /* Dump the any sections containing stabs debugging information. */
2311 dump_stabs (bfd
*abfd
)
2313 dump_stabs_section (abfd
, ".stab", ".stabstr");
2314 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2315 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2316 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2320 dump_bfd_header (bfd
*abfd
)
2324 printf (_("architecture: %s, "),
2325 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2326 bfd_get_mach (abfd
)));
2327 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2329 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2330 PF (HAS_RELOC
, "HAS_RELOC");
2331 PF (EXEC_P
, "EXEC_P");
2332 PF (HAS_LINENO
, "HAS_LINENO");
2333 PF (HAS_DEBUG
, "HAS_DEBUG");
2334 PF (HAS_SYMS
, "HAS_SYMS");
2335 PF (HAS_LOCALS
, "HAS_LOCALS");
2336 PF (DYNAMIC
, "DYNAMIC");
2337 PF (WP_TEXT
, "WP_TEXT");
2338 PF (D_PAGED
, "D_PAGED");
2339 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2340 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2341 printf (_("\nstart address 0x"));
2342 bfd_printf_vma (abfd
, abfd
->start_address
);
2348 dump_bfd_private_header (bfd
*abfd
)
2350 bfd_print_private_bfd_data (abfd
, stdout
);
2354 /* Display a section in hexadecimal format with associated characters.
2355 Each line prefixed by the zero padded address. */
2358 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2361 bfd_size_type datasize
;
2362 bfd_size_type addr_offset
;
2363 bfd_size_type start_offset
;
2364 bfd_size_type stop_offset
;
2365 unsigned int opb
= bfd_octets_per_byte (abfd
);
2366 /* Bytes per line. */
2367 const int onaline
= 16;
2372 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2375 if (! process_section_p (section
))
2378 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2381 printf (_("Contents of section %s:\n"), section
->name
);
2383 data
= xmalloc (datasize
);
2385 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2387 /* Compute the address range to display. */
2388 if (start_address
== (bfd_vma
) -1
2389 || start_address
< section
->vma
)
2392 start_offset
= start_address
- section
->vma
;
2394 if (stop_address
== (bfd_vma
) -1)
2395 stop_offset
= datasize
/ opb
;
2398 if (stop_address
< section
->vma
)
2401 stop_offset
= stop_address
- section
->vma
;
2403 if (stop_offset
> datasize
/ opb
)
2404 stop_offset
= datasize
/ opb
;
2409 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2410 if (strlen (buf
) >= sizeof (buf
))
2414 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2416 count
= strlen (buf
) - count
;
2420 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2421 if (strlen (buf
) >= sizeof (buf
))
2425 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2427 count
= strlen (buf
) - count
;
2431 for (addr_offset
= start_offset
;
2432 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2436 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2437 count
= strlen (buf
);
2438 if ((size_t) count
>= sizeof (buf
))
2442 while (count
< width
)
2447 fputs (buf
+ count
- width
, stdout
);
2450 for (j
= addr_offset
* opb
;
2451 j
< addr_offset
* opb
+ onaline
; j
++)
2453 if (j
< stop_offset
* opb
)
2454 printf ("%02x", (unsigned) (data
[j
]));
2462 for (j
= addr_offset
* opb
;
2463 j
< addr_offset
* opb
+ onaline
; j
++)
2465 if (j
>= stop_offset
* opb
)
2468 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2475 /* Actually display the various requested regions. */
2478 dump_data (bfd
*abfd
)
2480 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2483 /* Should perhaps share code and display with nm? */
2486 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2496 printf ("DYNAMIC SYMBOL TABLE:\n");
2502 printf ("SYMBOL TABLE:\n");
2506 printf (_("no symbols\n"));
2508 for (count
= 0; count
< max
; count
++)
2512 if (*current
== NULL
)
2513 printf (_("no information for symbol number %ld\n"), count
);
2515 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2516 printf (_("could not determine the type of symbol number %ld\n"),
2519 else if (process_section_p ((* current
)->section
)
2520 && (dump_special_syms
2521 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2523 const char *name
= (*current
)->name
;
2525 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2529 /* If we want to demangle the name, we demangle it
2530 here, and temporarily clobber it while calling
2531 bfd_print_symbol. FIXME: This is a gross hack. */
2532 alloc
= bfd_demangle (cur_bfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
2534 (*current
)->name
= alloc
;
2535 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2536 bfd_print_symbol_all
);
2539 (*current
)->name
= name
;
2544 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2545 bfd_print_symbol_all
);
2555 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2558 char *last_filename
, *last_functionname
;
2559 unsigned int last_line
;
2561 /* Get column headers lined up reasonably. */
2569 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2570 width
= strlen (buf
) - 7;
2572 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2575 last_filename
= NULL
;
2576 last_functionname
= NULL
;
2579 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2582 const char *filename
, *functionname
;
2584 const char *sym_name
;
2585 const char *section_name
;
2587 if (start_address
!= (bfd_vma
) -1
2588 && q
->address
< start_address
)
2590 if (stop_address
!= (bfd_vma
) -1
2591 && q
->address
> stop_address
)
2594 if (with_line_numbers
2596 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2597 &filename
, &functionname
, &line
))
2599 if (functionname
!= NULL
2600 && (last_functionname
== NULL
2601 || strcmp (functionname
, last_functionname
) != 0))
2603 printf ("%s():\n", functionname
);
2604 if (last_functionname
!= NULL
)
2605 free (last_functionname
);
2606 last_functionname
= xstrdup (functionname
);
2610 && (line
!= last_line
2611 || (filename
!= NULL
2612 && last_filename
!= NULL
2613 && strcmp (filename
, last_filename
) != 0)))
2615 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2617 if (last_filename
!= NULL
)
2618 free (last_filename
);
2619 if (filename
== NULL
)
2620 last_filename
= NULL
;
2622 last_filename
= xstrdup (filename
);
2626 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2628 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2629 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2634 section_name
= NULL
;
2637 bfd_printf_vma (abfd
, q
->address
);
2638 if (q
->howto
== NULL
)
2639 printf (" *unknown* ");
2640 else if (q
->howto
->name
)
2641 printf (" %-16s ", q
->howto
->name
);
2643 printf (" %-16d ", q
->howto
->type
);
2645 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2648 if (section_name
== NULL
)
2649 section_name
= "*unknown*";
2650 printf ("[%s]", section_name
);
2656 bfd_printf_vma (abfd
, q
->addend
);
2664 dump_relocs_in_section (bfd
*abfd
,
2666 void *dummy ATTRIBUTE_UNUSED
)
2672 if ( bfd_is_abs_section (section
)
2673 || bfd_is_und_section (section
)
2674 || bfd_is_com_section (section
)
2675 || (! process_section_p (section
))
2676 || ((section
->flags
& SEC_RELOC
) == 0))
2679 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2681 bfd_fatal (bfd_get_filename (abfd
));
2683 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2687 printf (" (none)\n\n");
2691 relpp
= xmalloc (relsize
);
2692 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2695 bfd_fatal (bfd_get_filename (abfd
));
2696 else if (relcount
== 0)
2697 printf (" (none)\n\n");
2701 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2708 dump_relocs (bfd
*abfd
)
2710 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2714 dump_dynamic_relocs (bfd
*abfd
)
2720 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2722 bfd_fatal (bfd_get_filename (abfd
));
2724 printf ("DYNAMIC RELOCATION RECORDS");
2727 printf (" (none)\n\n");
2730 relpp
= xmalloc (relsize
);
2731 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2734 bfd_fatal (bfd_get_filename (abfd
));
2735 else if (relcount
== 0)
2736 printf (" (none)\n\n");
2740 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2747 /* Creates a table of paths, to search for source files. */
2750 add_include_path (const char *path
)
2754 include_path_count
++;
2755 include_paths
= xrealloc (include_paths
,
2756 include_path_count
* sizeof (*include_paths
));
2757 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2758 if (path
[1] == ':' && path
[2] == 0)
2759 path
= concat (path
, ".", (const char *) 0);
2761 include_paths
[include_path_count
- 1] = path
;
2765 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2769 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2771 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2772 section
->vma
+= adjust_section_vma
;
2774 section
->lma
+= adjust_section_vma
;
2778 /* Dump selected contents of ABFD. */
2781 dump_bfd (bfd
*abfd
)
2783 /* If we are adjusting section VMA's, change them all now. Changing
2784 the BFD information is a hack. However, we must do it, or
2785 bfd_find_nearest_line will not do the right thing. */
2786 if (adjust_section_vma
!= 0)
2788 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2789 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2792 if (! dump_debugging_tags
)
2793 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2796 print_arelt_descr (stdout
, abfd
, TRUE
);
2797 if (dump_file_header
)
2798 dump_bfd_header (abfd
);
2799 if (dump_private_headers
)
2800 dump_bfd_private_header (abfd
);
2801 if (! dump_debugging_tags
)
2803 if (dump_section_headers
)
2804 dump_headers (abfd
);
2810 || dump_dwarf_section_info
)
2811 syms
= slurp_symtab (abfd
);
2812 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2813 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2814 dynsyms
= slurp_dynamic_symtab (abfd
);
2817 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2818 dynsymcount
, dynsyms
, &synthsyms
);
2824 dump_symbols (abfd
, FALSE
);
2825 if (dump_dynamic_symtab
)
2826 dump_symbols (abfd
, TRUE
);
2827 if (dump_dwarf_section_info
)
2829 if (dump_stab_section_info
)
2831 if (dump_reloc_info
&& ! disassemble
)
2833 if (dump_dynamic_reloc_info
&& ! disassemble
)
2834 dump_dynamic_relocs (abfd
);
2835 if (dump_section_contents
)
2838 disassemble_data (abfd
);
2844 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2845 if (dhandle
!= NULL
)
2847 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
2849 dump_debugging_tags
? TRUE
: FALSE
))
2851 non_fatal (_("%s: printing debugging information failed"),
2852 bfd_get_filename (abfd
));
2882 display_bfd (bfd
*abfd
)
2886 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2892 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2894 nonfatal (bfd_get_filename (abfd
));
2895 list_matching_formats (matching
);
2900 if (bfd_get_error () != bfd_error_file_not_recognized
)
2902 nonfatal (bfd_get_filename (abfd
));
2906 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2912 nonfatal (bfd_get_filename (abfd
));
2914 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2916 list_matching_formats (matching
);
2922 display_file (char *filename
, char *target
)
2927 if (get_file_size (filename
) < 1)
2933 file
= bfd_openr (filename
, target
);
2936 nonfatal (filename
);
2940 /* If the file is an archive, process all of its elements. */
2941 if (bfd_check_format (file
, bfd_archive
))
2943 bfd
*last_arfile
= NULL
;
2945 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2948 bfd_set_error (bfd_error_no_error
);
2950 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2953 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2954 nonfatal (bfd_get_filename (file
));
2958 display_bfd (arfile
);
2960 if (last_arfile
!= NULL
)
2961 bfd_close (last_arfile
);
2962 last_arfile
= arfile
;
2965 if (last_arfile
!= NULL
)
2966 bfd_close (last_arfile
);
2975 main (int argc
, char **argv
)
2978 char *target
= default_target
;
2979 bfd_boolean seenflag
= FALSE
;
2981 #if defined (HAVE_SETLOCALE)
2982 #if defined (HAVE_LC_MESSAGES)
2983 setlocale (LC_MESSAGES
, "");
2985 setlocale (LC_CTYPE
, "");
2988 bindtextdomain (PACKAGE
, LOCALEDIR
);
2989 textdomain (PACKAGE
);
2991 program_name
= *argv
;
2992 xmalloc_set_program_name (program_name
);
2994 START_PROGRESS (program_name
, 0);
2996 expandargv (&argc
, &argv
);
2999 set_default_bfd_target ();
3001 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3002 long_options
, (int *) 0))
3008 break; /* We've been given a long option. */
3013 if (disassembler_options
)
3014 /* Ignore potential memory leak for now. */
3015 disassembler_options
= concat (disassembler_options
, ",",
3018 disassembler_options
= optarg
;
3021 if (only_used
== only_size
)
3024 only
= xrealloc (only
, only_size
* sizeof (char *));
3026 only
[only_used
++] = optarg
;
3029 with_line_numbers
= TRUE
;
3038 enum demangling_styles style
;
3040 style
= cplus_demangle_name_to_style (optarg
);
3041 if (style
== unknown_demangling
)
3042 fatal (_("unknown demangling style `%s'"),
3045 cplus_demangle_set_style (style
);
3051 case OPTION_ADJUST_VMA
:
3052 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3054 case OPTION_START_ADDRESS
:
3055 start_address
= parse_vma (optarg
, "--start-address");
3057 case OPTION_STOP_ADDRESS
:
3058 stop_address
= parse_vma (optarg
, "--stop-address");
3061 if (strcmp (optarg
, "B") == 0)
3062 endian
= BFD_ENDIAN_BIG
;
3063 else if (strcmp (optarg
, "L") == 0)
3064 endian
= BFD_ENDIAN_LITTLE
;
3067 non_fatal (_("unrecognized -E option"));
3072 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3073 endian
= BFD_ENDIAN_BIG
;
3074 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3075 endian
= BFD_ENDIAN_LITTLE
;
3078 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3084 dump_file_header
= TRUE
;
3088 formats_info
= TRUE
;
3092 add_include_path (optarg
);
3095 dump_private_headers
= TRUE
;
3099 dump_private_headers
= TRUE
;
3101 dump_reloc_info
= TRUE
;
3102 dump_file_header
= TRUE
;
3103 dump_ar_hdrs
= TRUE
;
3104 dump_section_headers
= TRUE
;
3112 dump_dynamic_symtab
= TRUE
;
3120 disassemble_zeroes
= TRUE
;
3124 disassemble_all
= TRUE
;
3129 with_source_code
= TRUE
;
3138 dump_debugging_tags
= 1;
3143 dump_dwarf_section_info
= TRUE
;
3146 do_debug_abbrevs
= 1;
3148 do_debug_pubnames
= 1;
3149 do_debug_aranges
= 1;
3150 do_debug_ranges
= 1;
3151 do_debug_frames
= 1;
3152 do_debug_macinfo
= 1;
3157 dump_stab_section_info
= TRUE
;
3161 dump_section_contents
= TRUE
;
3165 dump_reloc_info
= TRUE
;
3169 dump_dynamic_reloc_info
= TRUE
;
3173 dump_ar_hdrs
= TRUE
;
3177 dump_section_headers
= TRUE
;
3185 show_version
= TRUE
;
3195 print_version ("objdump");
3201 exit_status
= display_info ();
3205 display_file ("a.out", target
);
3207 for (; optind
< argc
;)
3208 display_file (argv
[optind
++], target
);
3211 END_PROGRESS (program_name
);