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
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. */
58 #include "safe-ctype.h"
60 #include "libiberty.h"
65 /* Internal headers for the ELF .stab-dump code - sorry. */
66 #define BYTES_IN_WORD 32
67 #include "aout/aout64.h"
69 #if !HAVE_DECL_FPRINTF
70 /* This is needed by init_disassemble_info(). */
71 extern int fprintf (FILE *, const char *, ...);
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
);
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
= demangle (abfd
, name
);
663 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
671 /* Locate a symbol given a bfd and a section (from INFO->application_data),
672 and a VMA. If INFO->application_data->require_sec is TRUE, then always
673 require the symbol to be in the section. Returns NULL if there is no
674 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
675 of the symbol in sorted_syms. */
678 find_symbol_for_address (bfd_vma vma
,
679 struct disassemble_info
*info
,
682 /* @@ Would it speed things up to cache the last two symbols returned,
683 and maybe their address ranges? For many processors, only one memory
684 operand can be present at a time, so the 2-entry cache wouldn't be
685 constantly churned by code doing heavy memory accesses. */
687 /* Indices in `sorted_syms'. */
689 long max
= sorted_symcount
;
691 struct objdump_disasm_info
*aux
;
696 if (sorted_symcount
< 1)
699 aux
= (struct objdump_disasm_info
*) info
->application_data
;
702 opb
= bfd_octets_per_byte (abfd
);
704 /* Perform a binary search looking for the closest symbol to the
705 required value. We are searching the range (min, max]. */
706 while (min
+ 1 < max
)
710 thisplace
= (max
+ min
) / 2;
711 sym
= sorted_syms
[thisplace
];
713 if (bfd_asymbol_value (sym
) > vma
)
715 else if (bfd_asymbol_value (sym
) < vma
)
724 /* The symbol we want is now in min, the low end of the range we
725 were searching. If there are several symbols with the same
726 value, we want the first one. */
729 && (bfd_asymbol_value (sorted_syms
[thisplace
])
730 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
733 /* If the file is relocatable, and the symbol could be from this
734 section, prefer a symbol from this section over symbols from
735 others, even if the other symbol's value might be closer.
737 Note that this may be wrong for some symbol references if the
738 sections have overlapping memory ranges, but in that case there's
739 no way to tell what's desired without looking at the relocation
741 if (sorted_syms
[thisplace
]->section
!= sec
743 || ((abfd
->flags
& HAS_RELOC
) != 0
744 && vma
>= bfd_get_section_vma (abfd
, sec
)
745 && vma
< (bfd_get_section_vma (abfd
, sec
)
746 + bfd_section_size (abfd
, sec
) / opb
))))
750 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
752 if (bfd_asymbol_value (sorted_syms
[i
])
753 != bfd_asymbol_value (sorted_syms
[thisplace
]))
761 if (sorted_syms
[i
]->section
== sec
763 || sorted_syms
[i
- 1]->section
!= sec
764 || (bfd_asymbol_value (sorted_syms
[i
])
765 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
772 if (sorted_syms
[thisplace
]->section
!= sec
)
774 /* We didn't find a good symbol with a smaller value.
775 Look for one with a larger value. */
776 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
778 if (sorted_syms
[i
]->section
== sec
)
786 if (sorted_syms
[thisplace
]->section
!= sec
788 || ((abfd
->flags
& HAS_RELOC
) != 0
789 && vma
>= bfd_get_section_vma (abfd
, sec
)
790 && vma
< (bfd_get_section_vma (abfd
, sec
)
791 + bfd_section_size (abfd
, sec
)))))
792 /* There is no suitable symbol. */
796 /* Give the target a chance to reject the symbol. */
797 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
800 if (thisplace
>= sorted_symcount
801 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
808 return sorted_syms
[thisplace
];
811 /* Print an address and the offset to the nearest symbol. */
814 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
815 bfd_vma vma
, struct disassemble_info
*info
,
816 bfd_boolean skip_zeroes
)
818 objdump_print_value (vma
, info
, skip_zeroes
);
824 (*info
->fprintf_func
) (info
->stream
, " <%s",
825 bfd_get_section_name (abfd
, sec
));
826 secaddr
= bfd_get_section_vma (abfd
, sec
);
829 (*info
->fprintf_func
) (info
->stream
, "-0x");
830 objdump_print_value (secaddr
- vma
, info
, TRUE
);
832 else if (vma
> secaddr
)
834 (*info
->fprintf_func
) (info
->stream
, "+0x");
835 objdump_print_value (vma
- secaddr
, info
, TRUE
);
837 (*info
->fprintf_func
) (info
->stream
, ">");
841 (*info
->fprintf_func
) (info
->stream
, " <");
842 objdump_print_symname (abfd
, info
, sym
);
843 if (bfd_asymbol_value (sym
) > vma
)
845 (*info
->fprintf_func
) (info
->stream
, "-0x");
846 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
848 else if (vma
> bfd_asymbol_value (sym
))
850 (*info
->fprintf_func
) (info
->stream
, "+0x");
851 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
853 (*info
->fprintf_func
) (info
->stream
, ">");
857 /* Print an address (VMA), symbolically if possible.
858 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
861 objdump_print_addr (bfd_vma vma
,
862 struct disassemble_info
*info
,
863 bfd_boolean skip_zeroes
)
865 struct objdump_disasm_info
*aux
;
866 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
867 bfd_boolean skip_find
= FALSE
;
869 if (sorted_symcount
< 1)
871 (*info
->fprintf_func
) (info
->stream
, "0x");
872 objdump_print_value (vma
, info
, skip_zeroes
);
876 aux
= (struct objdump_disasm_info
*) info
->application_data
;
878 if (aux
->reloc
!= NULL
879 && aux
->reloc
->sym_ptr_ptr
!= NULL
880 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
882 sym
= * aux
->reloc
->sym_ptr_ptr
;
884 /* Adjust the vma to the reloc. */
885 vma
+= bfd_asymbol_value (sym
);
887 if (bfd_is_und_section (bfd_get_section (sym
)))
892 sym
= find_symbol_for_address (vma
, info
, NULL
);
894 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
898 /* Print VMA to INFO. This function is passed to the disassembler
902 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
904 objdump_print_addr (vma
, info
, ! prefix_addresses
);
907 /* Determine of the given address has a symbol associated with it. */
910 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
914 sym
= find_symbol_for_address (vma
, info
, NULL
);
916 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
919 /* Hold the last function name and the last line number we displayed
922 static char *prev_functionname
;
923 static unsigned int prev_line
;
925 /* We keep a list of all files that we have seen when doing a
926 disassembly with source, so that we know how much of the file to
927 display. This can be important for inlined functions. */
929 struct print_file_list
931 struct print_file_list
*next
;
932 const char *filename
;
938 static struct print_file_list
*print_files
;
940 /* The number of preceding context lines to show when we start
941 displaying a file for the first time. */
943 #define SHOW_PRECEDING_CONTEXT_LINES (5)
945 /* Tries to open MODNAME, and if successful adds a node to print_files
946 linked list and returns that node. Returns NULL on failure. */
948 static struct print_file_list
*
949 try_print_file_open (const char *origname
, const char *modname
)
951 struct print_file_list
*p
;
954 f
= fopen (modname
, "r");
958 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
960 fclose (print_files
->f
);
961 print_files
->f
= NULL
;
964 p
= xmalloc (sizeof (struct print_file_list
));
965 p
->filename
= origname
;
966 p
->modname
= modname
;
969 p
->next
= print_files
;
974 /* If the the source file, as described in the symtab, is not found
975 try to locate it in one of the paths specified with -I
976 If found, add location to print_files linked list. */
978 static struct print_file_list
*
979 update_source_path (const char *filename
)
981 struct print_file_list
*p
;
985 if (filename
== NULL
)
988 p
= try_print_file_open (filename
, filename
);
992 if (include_path_count
== 0)
995 /* Get the name of the file. */
996 fname
= strrchr (filename
, '/');
997 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
999 /* We could have a mixed forward/back slash case. */
1000 char *backslash
= strrchr (filename
, '\\');
1001 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1003 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1004 fname
= filename
+ 1;
1012 /* If file exists under a new path, we need to add it to the list
1013 so that show_line knows about it. */
1014 for (i
= 0; i
< include_path_count
; i
++)
1016 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1018 p
= try_print_file_open (filename
, modname
);
1028 /* Skip ahead to a given line in a file, optionally printing each
1032 skip_to_line (struct print_file_list
*p
, unsigned int line
,
1035 while (p
->line
< line
)
1039 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1049 if (strchr (buf
, '\n') != NULL
)
1054 /* Show the line number, or the source line, in a disassembly
1058 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1060 const char *filename
;
1061 const char *functionname
;
1064 if (! with_line_numbers
&& ! with_source_code
)
1067 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1068 &functionname
, &line
))
1071 if (filename
!= NULL
&& *filename
== '\0')
1073 if (functionname
!= NULL
&& *functionname
== '\0')
1074 functionname
= NULL
;
1076 if (with_line_numbers
)
1078 if (functionname
!= NULL
1079 && (prev_functionname
== NULL
1080 || strcmp (functionname
, prev_functionname
) != 0))
1081 printf ("%s():\n", functionname
);
1082 if (line
> 0 && line
!= prev_line
)
1083 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1086 if (with_source_code
1090 struct print_file_list
**pp
, *p
;
1092 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1093 if (strcmp ((*pp
)->filename
, filename
) == 0)
1099 if (p
!= print_files
)
1103 /* We have reencountered a file name which we saw
1104 earlier. This implies that either we are dumping out
1105 code from an included file, or the same file was
1106 linked in more than once. There are two common cases
1107 of an included file: inline functions in a header
1108 file, and a bison or flex skeleton file. In the
1109 former case we want to just start printing (but we
1110 back up a few lines to give context); in the latter
1111 case we want to continue from where we left off. I
1112 can't think of a good way to distinguish the cases,
1113 so I used a heuristic based on the file name. */
1114 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1118 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1125 p
->f
= fopen (p
->modname
, "r");
1129 skip_to_line (p
, l
, FALSE
);
1131 if (print_files
->f
!= NULL
)
1133 fclose (print_files
->f
);
1134 print_files
->f
= NULL
;
1140 skip_to_line (p
, line
, TRUE
);
1142 p
->next
= print_files
;
1148 p
= update_source_path (filename
);
1154 if (file_start_context
)
1157 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1160 skip_to_line (p
, l
, FALSE
);
1162 skip_to_line (p
, line
, TRUE
);
1167 if (functionname
!= NULL
1168 && (prev_functionname
== NULL
1169 || strcmp (functionname
, prev_functionname
) != 0))
1171 if (prev_functionname
!= NULL
)
1172 free (prev_functionname
);
1173 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1174 strcpy (prev_functionname
, functionname
);
1177 if (line
> 0 && line
!= prev_line
)
1181 /* Pseudo FILE object for strings. */
1189 /* sprintf to a "stream". */
1191 static int ATTRIBUTE_PRINTF_2
1192 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1199 size_t space
= f
->alloc
- f
->pos
;
1201 va_start (args
, format
);
1202 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1208 f
->alloc
= (f
->alloc
+ n
) * 2;
1209 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1216 /* Returns TRUE if the specified section should be dumped. */
1219 process_section_p (asection
* section
)
1226 for (i
= 0; i
< only_used
; i
++)
1227 if (strcmp (only
[i
], section
->name
) == 0)
1234 /* The number of zeroes we want to see before we start skipping them.
1235 The number is arbitrarily chosen. */
1237 #define DEFAULT_SKIP_ZEROES 8
1239 /* The number of zeroes to skip at the end of a section. If the
1240 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1241 SKIP_ZEROES, they will be disassembled. If there are fewer than
1242 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1243 attempt to avoid disassembling zeroes inserted by section
1246 #define DEFAULT_SKIP_ZEROES_AT_END 3
1248 /* Disassemble some data in memory between given values. */
1251 disassemble_bytes (struct disassemble_info
* info
,
1252 disassembler_ftype disassemble_fn
,
1255 bfd_vma start_offset
,
1256 bfd_vma stop_offset
,
1259 arelent
** relppend
)
1261 struct objdump_disasm_info
*aux
;
1263 int octets_per_line
;
1264 bfd_boolean done_dot
;
1265 int skip_addr_chars
;
1266 bfd_vma addr_offset
;
1267 unsigned int opb
= info
->octets_per_byte
;
1268 unsigned int skip_zeroes
= info
->skip_zeroes
;
1269 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1273 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1277 sfile
.buffer
= xmalloc (sfile
.alloc
);
1281 octets_per_line
= 4;
1283 octets_per_line
= 16;
1285 /* Figure out how many characters to skip at the start of an
1286 address, to make the disassembly look nicer. We discard leading
1287 zeroes in chunks of 4, ensuring that there is always a leading
1289 skip_addr_chars
= 0;
1290 if (! prefix_addresses
)
1298 + bfd_section_size (section
->owner
, section
) / opb
));
1300 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1303 skip_addr_chars
+= 4;
1308 info
->insn_info_valid
= 0;
1311 addr_offset
= start_offset
;
1312 while (addr_offset
< stop_offset
)
1315 bfd_boolean need_nl
= FALSE
;
1316 int previous_octets
;
1318 /* Remember the length of the previous instruction. */
1319 previous_octets
= octets
;
1322 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1324 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1327 if (! disassemble_zeroes
1328 && (info
->insn_info_valid
== 0
1329 || info
->branch_delay_insns
== 0)
1330 && (z
- addr_offset
* opb
>= skip_zeroes
1331 || (z
== stop_offset
* opb
&&
1332 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1336 /* If there are more nonzero octets to follow, we only skip
1337 zeroes in multiples of 4, to try to avoid running over
1338 the start of an instruction which happens to start with
1340 if (z
!= stop_offset
* opb
)
1341 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1343 octets
= z
- addr_offset
* opb
;
1353 if (with_line_numbers
|| with_source_code
)
1354 show_line (aux
->abfd
, section
, addr_offset
);
1356 if (! prefix_addresses
)
1360 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1361 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1365 printf ("%s:\t", buf
+ skip_addr_chars
);
1369 aux
->require_sec
= TRUE
;
1370 objdump_print_address (section
->vma
+ addr_offset
, info
);
1371 aux
->require_sec
= FALSE
;
1378 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1379 info
->stream
= &sfile
;
1380 info
->bytes_per_line
= 0;
1381 info
->bytes_per_chunk
= 0;
1384 if (info
->disassembler_needs_relocs
1385 && *relppp
< relppend
)
1387 bfd_signed_vma distance_to_rel
;
1389 distance_to_rel
= (**relppp
)->address
1390 - (rel_offset
+ addr_offset
);
1392 /* Check to see if the current reloc is associated with
1393 the instruction that we are about to disassemble. */
1394 if (distance_to_rel
== 0
1395 /* FIXME: This is wrong. We are trying to catch
1396 relocs that are addressed part way through the
1397 current instruction, as might happen with a packed
1398 VLIW instruction. Unfortunately we do not know the
1399 length of the current instruction since we have not
1400 disassembled it yet. Instead we take a guess based
1401 upon the length of the previous instruction. The
1402 proper solution is to have a new target-specific
1403 disassembler function which just returns the length
1404 of an instruction at a given address without trying
1405 to display its disassembly. */
1406 || (distance_to_rel
> 0
1407 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1409 info
->flags
= INSN_HAS_RELOC
;
1410 aux
->reloc
= **relppp
;
1416 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1417 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1418 info
->stream
= stdout
;
1419 if (info
->bytes_per_line
!= 0)
1420 octets_per_line
= info
->bytes_per_line
;
1424 printf ("%s\n", sfile
.buffer
);
1432 octets
= octets_per_line
;
1433 if (addr_offset
+ octets
/ opb
> stop_offset
)
1434 octets
= (stop_offset
- addr_offset
) * opb
;
1436 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1438 if (ISPRINT (data
[j
]))
1439 buf
[j
- addr_offset
* opb
] = data
[j
];
1441 buf
[j
- addr_offset
* opb
] = '.';
1443 buf
[j
- addr_offset
* opb
] = '\0';
1446 if (prefix_addresses
1448 : show_raw_insn
>= 0)
1452 /* If ! prefix_addresses and ! wide_output, we print
1453 octets_per_line octets per line. */
1455 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1456 pb
= octets_per_line
;
1458 if (info
->bytes_per_chunk
)
1459 bpc
= info
->bytes_per_chunk
;
1463 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1467 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1469 for (k
= bpc
- 1; k
>= 0; k
--)
1470 printf ("%02x", (unsigned) data
[j
+ k
]);
1475 for (k
= 0; k
< bpc
; k
++)
1476 printf ("%02x", (unsigned) data
[j
+ k
]);
1481 for (; pb
< octets_per_line
; pb
+= bpc
)
1485 for (k
= 0; k
< bpc
; k
++)
1490 /* Separate raw data from instruction by extra space. */
1500 printf ("%s", sfile
.buffer
);
1502 if (prefix_addresses
1504 : show_raw_insn
>= 0)
1512 j
= addr_offset
* opb
+ pb
;
1514 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1515 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1519 printf ("%s:\t", buf
+ skip_addr_chars
);
1521 pb
+= octets_per_line
;
1524 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1528 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1530 for (k
= bpc
- 1; k
>= 0; k
--)
1531 printf ("%02x", (unsigned) data
[j
+ k
]);
1536 for (k
= 0; k
< bpc
; k
++)
1537 printf ("%02x", (unsigned) data
[j
+ k
]);
1550 while ((*relppp
) < relppend
1551 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1553 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1564 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1567 if (q
->howto
== NULL
)
1568 printf (": *unknown*\t");
1569 else if (q
->howto
->name
)
1570 printf (": %s\t", q
->howto
->name
);
1572 printf (": %d\t", q
->howto
->type
);
1574 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1575 printf ("*unknown*");
1578 const char *sym_name
;
1580 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1581 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1582 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1587 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1588 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1589 if (sym_name
== NULL
|| *sym_name
== '\0')
1590 sym_name
= "*unknown*";
1591 printf ("%s", sym_name
);
1598 objdump_print_value (q
->addend
, info
, TRUE
);
1610 addr_offset
+= octets
/ opb
;
1613 free (sfile
.buffer
);
1617 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1619 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1620 struct objdump_disasm_info
* paux
;
1621 unsigned int opb
= pinfo
->octets_per_byte
;
1622 bfd_byte
* data
= NULL
;
1623 bfd_size_type datasize
= 0;
1624 arelent
** rel_pp
= NULL
;
1625 arelent
** rel_ppstart
= NULL
;
1626 arelent
** rel_ppend
;
1627 unsigned long stop_offset
;
1628 asymbol
* sym
= NULL
;
1632 unsigned long addr_offset
;
1634 /* Sections that do not contain machine
1635 code are not normally disassembled. */
1636 if (! disassemble_all
1638 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1639 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1642 if (! process_section_p (section
))
1645 datasize
= bfd_get_section_size (section
);
1649 /* Decide which set of relocs to use. Load them if necessary. */
1650 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1651 if (paux
->dynrelbuf
)
1653 rel_pp
= paux
->dynrelbuf
;
1654 rel_count
= paux
->dynrelcount
;
1655 /* Dynamic reloc addresses are absolute, non-dynamic are section
1656 relative. REL_OFFSET specifies the reloc address corresponding
1657 to the start of this section. */
1658 rel_offset
= section
->vma
;
1666 if ((section
->flags
& SEC_RELOC
) != 0
1667 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
1671 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1673 bfd_fatal (bfd_get_filename (abfd
));
1677 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1678 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1680 bfd_fatal (bfd_get_filename (abfd
));
1682 /* Sort the relocs by address. */
1683 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1688 rel_ppend
= rel_pp
+ rel_count
;
1690 data
= xmalloc (datasize
);
1692 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1694 paux
->sec
= section
;
1695 pinfo
->buffer
= data
;
1696 pinfo
->buffer_vma
= section
->vma
;
1697 pinfo
->buffer_length
= datasize
;
1698 pinfo
->section
= section
;
1700 if (start_address
== (bfd_vma
) -1
1701 || start_address
< pinfo
->buffer_vma
)
1704 addr_offset
= start_address
- pinfo
->buffer_vma
;
1706 if (stop_address
== (bfd_vma
) -1)
1707 stop_offset
= datasize
/ opb
;
1710 if (stop_address
< pinfo
->buffer_vma
)
1713 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1714 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1715 stop_offset
= pinfo
->buffer_length
/ opb
;
1718 /* Skip over the relocs belonging to addresses below the
1720 while (rel_pp
< rel_ppend
1721 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1724 printf (_("Disassembly of section %s:\n"), section
->name
);
1726 /* Find the nearest symbol forwards from our current position. */
1727 paux
->require_sec
= TRUE
;
1728 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1729 paux
->require_sec
= FALSE
;
1731 /* Disassemble a block of instructions up to the address associated with
1732 the symbol we have just found. Then print the symbol and find the
1733 next symbol on. Repeat until we have disassembled the entire section
1734 or we have reached the end of the address range we are interested in. */
1735 while (addr_offset
< stop_offset
)
1739 unsigned long nextstop_offset
;
1742 addr
= section
->vma
+ addr_offset
;
1744 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1749 (x
< sorted_symcount
1750 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1754 pinfo
->symbols
= sorted_syms
+ place
;
1755 pinfo
->num_symbols
= x
- place
;
1759 pinfo
->symbols
= NULL
;
1760 pinfo
->num_symbols
= 0;
1763 if (! prefix_addresses
)
1765 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1766 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1768 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1771 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1773 else if (sym
== NULL
)
1777 #define is_valid_next_sym(SYM) \
1778 ((SYM)->section == section \
1779 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1780 && pinfo->symbol_is_valid (SYM, pinfo))
1782 /* Search forward for the next appropriate symbol in
1783 SECTION. Note that all the symbols are sorted
1784 together into one big array, and that some sections
1785 may have overlapping addresses. */
1786 while (place
< sorted_symcount
1787 && ! is_valid_next_sym (sorted_syms
[place
]))
1790 if (place
>= sorted_symcount
)
1793 nextsym
= sorted_syms
[place
];
1796 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1797 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1798 else if (nextsym
== NULL
)
1799 nextstop_offset
= stop_offset
;
1801 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1803 if (nextstop_offset
> stop_offset
)
1804 nextstop_offset
= stop_offset
;
1806 /* If a symbol is explicitly marked as being an object
1807 rather than a function, just dump the bytes without
1808 disassembling them. */
1811 || bfd_asymbol_value (sym
) > addr
1812 || ((sym
->flags
& BSF_OBJECT
) == 0
1813 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1815 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1817 || (sym
->flags
& BSF_FUNCTION
) != 0)
1822 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1823 addr_offset
, nextstop_offset
,
1824 rel_offset
, &rel_pp
, rel_ppend
);
1826 addr_offset
= nextstop_offset
;
1832 if (rel_ppstart
!= NULL
)
1836 /* Disassemble the contents of an object file. */
1839 disassemble_data (bfd
*abfd
)
1841 struct disassemble_info disasm_info
;
1842 struct objdump_disasm_info aux
;
1846 prev_functionname
= NULL
;
1849 /* We make a copy of syms to sort. We don't want to sort syms
1850 because that will screw up the relocs. */
1851 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1852 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1853 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1854 sorted_symcount
* sizeof (asymbol
*));
1856 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1858 for (i
= 0; i
< synthcount
; ++i
)
1860 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1864 /* Sort the symbols into section and symbol order. */
1865 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1867 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1869 disasm_info
.application_data
= (void *) &aux
;
1871 aux
.require_sec
= FALSE
;
1872 aux
.dynrelbuf
= NULL
;
1873 aux
.dynrelcount
= 0;
1876 disasm_info
.print_address_func
= objdump_print_address
;
1877 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1879 if (machine
!= NULL
)
1881 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1884 fatal (_("Can't use supplied machine %s"), machine
);
1886 abfd
->arch_info
= info
;
1889 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1891 struct bfd_target
*xvec
;
1893 xvec
= xmalloc (sizeof (struct bfd_target
));
1894 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1895 xvec
->byteorder
= endian
;
1899 /* Use libopcodes to locate a suitable disassembler. */
1900 aux
.disassemble_fn
= disassembler (abfd
);
1901 if (!aux
.disassemble_fn
)
1903 non_fatal (_("Can't disassemble for architecture %s\n"),
1904 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1909 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1910 disasm_info
.arch
= bfd_get_arch (abfd
);
1911 disasm_info
.mach
= bfd_get_mach (abfd
);
1912 disasm_info
.disassembler_options
= disassembler_options
;
1913 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1914 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1915 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1916 disasm_info
.disassembler_needs_relocs
= FALSE
;
1918 if (bfd_big_endian (abfd
))
1919 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1920 else if (bfd_little_endian (abfd
))
1921 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1923 /* ??? Aborting here seems too drastic. We could default to big or little
1925 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1927 /* Allow the target to customize the info structure. */
1928 disassemble_init_for_target (& disasm_info
);
1930 /* Pre-load the dynamic relocs if we are going
1931 to be dumping them along with the disassembly. */
1932 if (dump_dynamic_reloc_info
)
1934 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1937 bfd_fatal (bfd_get_filename (abfd
));
1941 aux
.dynrelbuf
= xmalloc (relsize
);
1942 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1945 if (aux
.dynrelcount
< 0)
1946 bfd_fatal (bfd_get_filename (abfd
));
1948 /* Sort the relocs by address. */
1949 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1954 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1956 if (aux
.dynrelbuf
!= NULL
)
1957 free (aux
.dynrelbuf
);
1962 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
1964 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
1969 /* If it is already loaded, do nothing. */
1970 if (section
->start
!= NULL
)
1973 /* Locate the debug section. */
1974 sec
= bfd_get_section_by_name (abfd
, section
->name
);
1978 section
->address
= bfd_get_section_vma (abfd
, sec
);
1979 section
->size
= bfd_get_section_size (sec
);
1980 section
->start
= xmalloc (section
->size
);
1982 if (is_relocatable
&& debug_displays
[debug
].relocate
)
1983 ret
= bfd_simple_get_relocated_section_contents (abfd
,
1988 ret
= bfd_get_section_contents (abfd
, sec
, section
->start
, 0,
1993 free_debug_section (debug
);
1994 printf (_("\nCan't get contents for section '%s'.\n"),
2002 free_debug_section (enum dwarf_section_display_enum debug
)
2004 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2006 if (section
->start
== NULL
)
2009 free ((char *) section
->start
);
2010 section
->start
= NULL
;
2011 section
->address
= 0;
2016 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2017 void *arg ATTRIBUTE_UNUSED
)
2019 const char *name
= bfd_get_section_name (abfd
, section
);
2021 enum dwarf_section_display_enum i
;
2023 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
2024 match
= ".debug_info";
2028 for (i
= 0; i
< max
; i
++)
2029 if (strcmp (debug_displays
[i
].section
.name
, match
) == 0)
2031 if (!debug_displays
[i
].eh_frame
)
2033 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2035 if (load_debug_section (i
, abfd
))
2037 debug_displays
[i
].display (sec
, abfd
);
2039 if (i
!= info
&& i
!= abbrev
)
2040 free_debug_section (i
);
2047 static const char *mach_o_dwarf_sections
[] = {
2048 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2049 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2050 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2051 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2052 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2053 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2054 ".eh_frame", /* .eh_frame */
2055 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2056 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2057 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2058 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2059 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2060 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2061 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2062 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2063 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2066 static const char *generic_dwarf_sections
[max
];
2069 check_mach_o_dwarf (bfd
*abfd
)
2071 static enum bfd_flavour old_flavour
= bfd_target_unknown_flavour
;
2072 enum bfd_flavour current_flavour
= bfd_get_flavour (abfd
);
2073 enum dwarf_section_display_enum i
;
2075 if (generic_dwarf_sections
[0] == NULL
)
2076 for (i
= 0; i
< max
; i
++)
2077 generic_dwarf_sections
[i
] = debug_displays
[i
].section
.name
;
2079 if (old_flavour
!= current_flavour
)
2081 if (current_flavour
== bfd_target_mach_o_flavour
)
2082 for (i
= 0; i
< max
; i
++)
2083 debug_displays
[i
].section
.name
= mach_o_dwarf_sections
[i
];
2084 else if (old_flavour
== bfd_target_mach_o_flavour
)
2085 for (i
= 0; i
< max
; i
++)
2086 debug_displays
[i
].section
.name
= generic_dwarf_sections
[i
];
2088 old_flavour
= current_flavour
;
2092 /* Dump the dwarf debugging information. */
2095 dump_dwarf (bfd
*abfd
)
2097 is_relocatable
= ((abfd
->flags
& (HAS_RELOC
| EXEC_P
| DYNAMIC
))
2100 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2101 targets will return 64. */
2102 eh_addr_size
= bfd_get_arch_size (abfd
) == 64 ? 8 : 4;
2104 if (bfd_big_endian (abfd
))
2105 byte_get
= byte_get_big_endian
;
2106 else if (bfd_little_endian (abfd
))
2107 byte_get
= byte_get_little_endian
;
2111 check_mach_o_dwarf (abfd
);
2113 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2115 free_debug_memory ();
2118 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2119 it. Return NULL on failure. */
2122 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
2128 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
2129 if (stabsect
== NULL
)
2131 printf (_("No %s section present\n\n"), sect_name
);
2135 size
= bfd_section_size (abfd
, stabsect
);
2136 contents
= xmalloc (size
);
2138 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
2140 non_fatal (_("Reading %s section of %s failed: %s"),
2141 sect_name
, bfd_get_filename (abfd
),
2142 bfd_errmsg (bfd_get_error ()));
2153 /* Stabs entries use a 12 byte format:
2154 4 byte string table index
2156 1 byte stab other field
2157 2 byte stab desc field
2159 FIXME: This will have to change for a 64 bit object format. */
2161 #define STRDXOFF (0)
2163 #define OTHEROFF (5)
2166 #define STABSIZE (12)
2168 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2169 using string table section STRSECT_NAME (in `strtab'). */
2172 print_section_stabs (bfd
*abfd
,
2173 const char *stabsect_name
,
2174 unsigned *string_offset_ptr
)
2177 unsigned file_string_table_offset
= 0;
2178 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2179 bfd_byte
*stabp
, *stabs_end
;
2182 stabs_end
= stabp
+ stab_size
;
2184 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2185 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2187 /* Loop through all symbols and print them.
2189 We start the index at -1 because there is a dummy symbol on
2190 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2191 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2195 unsigned char type
, other
;
2196 unsigned short desc
;
2199 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2200 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2201 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2202 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2203 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2205 printf ("\n%-6d ", i
);
2206 /* Either print the stab name, or, if unnamed, print its number
2207 again (makes consistent formatting for tools like awk). */
2208 name
= bfd_get_stab_name (type
);
2210 printf ("%-6s", name
);
2211 else if (type
== N_UNDF
)
2214 printf ("%-6d", type
);
2215 printf (" %-6d %-6d ", other
, desc
);
2216 bfd_printf_vma (abfd
, value
);
2217 printf (" %-6lu", strx
);
2219 /* Symbols with type == 0 (N_UNDF) specify the length of the
2220 string table associated with this file. We use that info
2221 to know how to relocate the *next* file's string table indices. */
2224 file_string_table_offset
= next_file_string_table_offset
;
2225 next_file_string_table_offset
+= value
;
2229 /* Using the (possibly updated) string table offset, print the
2230 string (if any) associated with this symbol. */
2231 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2232 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2238 *string_offset_ptr
= next_file_string_table_offset
;
2243 const char * section_name
;
2244 const char * string_section_name
;
2245 unsigned string_offset
;
2250 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2253 stab_section_names
* sought
= (stab_section_names
*) names
;
2255 /* Check for section names for which stabsect_name is a prefix, to
2256 handle .stab.N, etc. */
2257 len
= strlen (sought
->section_name
);
2259 /* If the prefix matches, and the files section name ends with a
2260 nul or a digit, then we match. I.e., we want either an exact
2261 match or a section followed by a number. */
2262 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2263 && (section
->name
[len
] == 0
2264 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2267 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2272 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2275 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2281 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2283 stab_section_names s
;
2285 s
.section_name
= stabsect_name
;
2286 s
.string_section_name
= strsect_name
;
2287 s
.string_offset
= 0;
2289 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2295 /* Dump the any sections containing stabs debugging information. */
2298 dump_stabs (bfd
*abfd
)
2300 dump_stabs_section (abfd
, ".stab", ".stabstr");
2301 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2302 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2303 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2307 dump_bfd_header (bfd
*abfd
)
2311 printf (_("architecture: %s, "),
2312 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2313 bfd_get_mach (abfd
)));
2314 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2316 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2317 PF (HAS_RELOC
, "HAS_RELOC");
2318 PF (EXEC_P
, "EXEC_P");
2319 PF (HAS_LINENO
, "HAS_LINENO");
2320 PF (HAS_DEBUG
, "HAS_DEBUG");
2321 PF (HAS_SYMS
, "HAS_SYMS");
2322 PF (HAS_LOCALS
, "HAS_LOCALS");
2323 PF (DYNAMIC
, "DYNAMIC");
2324 PF (WP_TEXT
, "WP_TEXT");
2325 PF (D_PAGED
, "D_PAGED");
2326 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2327 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2328 printf (_("\nstart address 0x"));
2329 bfd_printf_vma (abfd
, abfd
->start_address
);
2335 dump_bfd_private_header (bfd
*abfd
)
2337 bfd_print_private_bfd_data (abfd
, stdout
);
2341 /* Display a section in hexadecimal format with associated characters.
2342 Each line prefixed by the zero padded address. */
2345 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2348 bfd_size_type datasize
;
2349 bfd_size_type addr_offset
;
2350 bfd_size_type start_offset
;
2351 bfd_size_type stop_offset
;
2352 unsigned int opb
= bfd_octets_per_byte (abfd
);
2353 /* Bytes per line. */
2354 const int onaline
= 16;
2359 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2362 if (! process_section_p (section
))
2365 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2368 printf (_("Contents of section %s:\n"), section
->name
);
2370 data
= xmalloc (datasize
);
2372 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2374 /* Compute the address range to display. */
2375 if (start_address
== (bfd_vma
) -1
2376 || start_address
< section
->vma
)
2379 start_offset
= start_address
- section
->vma
;
2381 if (stop_address
== (bfd_vma
) -1)
2382 stop_offset
= datasize
/ opb
;
2385 if (stop_address
< section
->vma
)
2388 stop_offset
= stop_address
- section
->vma
;
2390 if (stop_offset
> datasize
/ opb
)
2391 stop_offset
= datasize
/ opb
;
2396 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2397 if (strlen (buf
) >= sizeof (buf
))
2401 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2403 count
= strlen (buf
) - count
;
2407 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2408 if (strlen (buf
) >= sizeof (buf
))
2412 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2414 count
= strlen (buf
) - count
;
2418 for (addr_offset
= start_offset
;
2419 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2423 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2424 count
= strlen (buf
);
2425 if ((size_t) count
>= sizeof (buf
))
2429 while (count
< width
)
2434 fputs (buf
+ count
- width
, stdout
);
2437 for (j
= addr_offset
* opb
;
2438 j
< addr_offset
* opb
+ onaline
; j
++)
2440 if (j
< stop_offset
* opb
)
2441 printf ("%02x", (unsigned) (data
[j
]));
2449 for (j
= addr_offset
* opb
;
2450 j
< addr_offset
* opb
+ onaline
; j
++)
2452 if (j
>= stop_offset
* opb
)
2455 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2462 /* Actually display the various requested regions. */
2465 dump_data (bfd
*abfd
)
2467 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2470 /* Should perhaps share code and display with nm? */
2473 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2483 printf ("DYNAMIC SYMBOL TABLE:\n");
2489 printf ("SYMBOL TABLE:\n");
2493 printf (_("no symbols\n"));
2495 for (count
= 0; count
< max
; count
++)
2499 if (*current
== NULL
)
2500 printf (_("no information for symbol number %ld\n"), count
);
2502 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2503 printf (_("could not determine the type of symbol number %ld\n"),
2506 else if (process_section_p ((* current
)->section
)
2507 && (dump_special_syms
2508 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2510 const char *name
= (*current
)->name
;
2512 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2516 /* If we want to demangle the name, we demangle it
2517 here, and temporarily clobber it while calling
2518 bfd_print_symbol. FIXME: This is a gross hack. */
2519 alloc
= demangle (cur_bfd
, name
);
2520 (*current
)->name
= alloc
;
2521 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2522 bfd_print_symbol_all
);
2523 (*current
)->name
= name
;
2527 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2528 bfd_print_symbol_all
);
2538 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2541 char *last_filename
, *last_functionname
;
2542 unsigned int last_line
;
2544 /* Get column headers lined up reasonably. */
2552 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2553 width
= strlen (buf
) - 7;
2555 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2558 last_filename
= NULL
;
2559 last_functionname
= NULL
;
2562 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2565 const char *filename
, *functionname
;
2567 const char *sym_name
;
2568 const char *section_name
;
2570 if (start_address
!= (bfd_vma
) -1
2571 && q
->address
< start_address
)
2573 if (stop_address
!= (bfd_vma
) -1
2574 && q
->address
> stop_address
)
2577 if (with_line_numbers
2579 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2580 &filename
, &functionname
, &line
))
2582 if (functionname
!= NULL
2583 && (last_functionname
== NULL
2584 || strcmp (functionname
, last_functionname
) != 0))
2586 printf ("%s():\n", functionname
);
2587 if (last_functionname
!= NULL
)
2588 free (last_functionname
);
2589 last_functionname
= xstrdup (functionname
);
2593 && (line
!= last_line
2594 || (filename
!= NULL
2595 && last_filename
!= NULL
2596 && strcmp (filename
, last_filename
) != 0)))
2598 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2600 if (last_filename
!= NULL
)
2601 free (last_filename
);
2602 if (filename
== NULL
)
2603 last_filename
= NULL
;
2605 last_filename
= xstrdup (filename
);
2609 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2611 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2612 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2617 section_name
= NULL
;
2620 bfd_printf_vma (abfd
, q
->address
);
2621 if (q
->howto
== NULL
)
2622 printf (" *unknown* ");
2623 else if (q
->howto
->name
)
2624 printf (" %-16s ", q
->howto
->name
);
2626 printf (" %-16d ", q
->howto
->type
);
2628 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2631 if (section_name
== NULL
)
2632 section_name
= "*unknown*";
2633 printf ("[%s]", section_name
);
2639 bfd_printf_vma (abfd
, q
->addend
);
2647 dump_relocs_in_section (bfd
*abfd
,
2649 void *dummy ATTRIBUTE_UNUSED
)
2655 if ( bfd_is_abs_section (section
)
2656 || bfd_is_und_section (section
)
2657 || bfd_is_com_section (section
)
2658 || (! process_section_p (section
))
2659 || ((section
->flags
& SEC_RELOC
) == 0))
2662 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2664 bfd_fatal (bfd_get_filename (abfd
));
2666 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2670 printf (" (none)\n\n");
2674 relpp
= xmalloc (relsize
);
2675 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2678 bfd_fatal (bfd_get_filename (abfd
));
2679 else if (relcount
== 0)
2680 printf (" (none)\n\n");
2684 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2691 dump_relocs (bfd
*abfd
)
2693 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2697 dump_dynamic_relocs (bfd
*abfd
)
2703 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2705 bfd_fatal (bfd_get_filename (abfd
));
2707 printf ("DYNAMIC RELOCATION RECORDS");
2710 printf (" (none)\n\n");
2713 relpp
= xmalloc (relsize
);
2714 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2717 bfd_fatal (bfd_get_filename (abfd
));
2718 else if (relcount
== 0)
2719 printf (" (none)\n\n");
2723 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2730 /* Creates a table of paths, to search for source files. */
2733 add_include_path (const char *path
)
2737 include_path_count
++;
2738 include_paths
= xrealloc (include_paths
,
2739 include_path_count
* sizeof (*include_paths
));
2740 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2741 if (path
[1] == ':' && path
[2] == 0)
2742 path
= concat (path
, ".", (const char *) 0);
2744 include_paths
[include_path_count
- 1] = path
;
2748 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2752 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2754 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2755 section
->vma
+= adjust_section_vma
;
2757 section
->lma
+= adjust_section_vma
;
2761 /* Dump selected contents of ABFD. */
2764 dump_bfd (bfd
*abfd
)
2766 /* If we are adjusting section VMA's, change them all now. Changing
2767 the BFD information is a hack. However, we must do it, or
2768 bfd_find_nearest_line will not do the right thing. */
2769 if (adjust_section_vma
!= 0)
2771 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2772 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2775 if (! dump_debugging_tags
)
2776 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2779 print_arelt_descr (stdout
, abfd
, TRUE
);
2780 if (dump_file_header
)
2781 dump_bfd_header (abfd
);
2782 if (dump_private_headers
)
2783 dump_bfd_private_header (abfd
);
2784 if (! dump_debugging_tags
)
2786 if (dump_section_headers
)
2787 dump_headers (abfd
);
2793 || dump_dwarf_section_info
)
2794 syms
= slurp_symtab (abfd
);
2795 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2796 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2797 dynsyms
= slurp_dynamic_symtab (abfd
);
2800 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2801 dynsymcount
, dynsyms
, &synthsyms
);
2807 dump_symbols (abfd
, FALSE
);
2808 if (dump_dynamic_symtab
)
2809 dump_symbols (abfd
, TRUE
);
2810 if (dump_dwarf_section_info
)
2812 if (dump_stab_section_info
)
2814 if (dump_reloc_info
&& ! disassemble
)
2816 if (dump_dynamic_reloc_info
&& ! disassemble
)
2817 dump_dynamic_relocs (abfd
);
2818 if (dump_section_contents
)
2821 disassemble_data (abfd
);
2827 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2828 if (dhandle
!= NULL
)
2830 if (! print_debugging_info (stdout
, dhandle
, abfd
, syms
, demangle
,
2831 dump_debugging_tags
? TRUE
: FALSE
))
2833 non_fatal (_("%s: printing debugging information failed"),
2834 bfd_get_filename (abfd
));
2864 display_bfd (bfd
*abfd
)
2868 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2874 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2876 nonfatal (bfd_get_filename (abfd
));
2877 list_matching_formats (matching
);
2882 if (bfd_get_error () != bfd_error_file_not_recognized
)
2884 nonfatal (bfd_get_filename (abfd
));
2888 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2894 nonfatal (bfd_get_filename (abfd
));
2896 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2898 list_matching_formats (matching
);
2904 display_file (char *filename
, char *target
)
2909 if (get_file_size (filename
) < 1)
2912 file
= bfd_openr (filename
, target
);
2915 nonfatal (filename
);
2919 /* If the file is an archive, process all of its elements. */
2920 if (bfd_check_format (file
, bfd_archive
))
2922 bfd
*last_arfile
= NULL
;
2924 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2927 bfd_set_error (bfd_error_no_error
);
2929 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2932 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2933 nonfatal (bfd_get_filename (file
));
2937 display_bfd (arfile
);
2939 if (last_arfile
!= NULL
)
2940 bfd_close (last_arfile
);
2941 last_arfile
= arfile
;
2944 if (last_arfile
!= NULL
)
2945 bfd_close (last_arfile
);
2954 main (int argc
, char **argv
)
2957 char *target
= default_target
;
2958 bfd_boolean seenflag
= FALSE
;
2960 #if defined (HAVE_SETLOCALE)
2961 #if defined (HAVE_LC_MESSAGES)
2962 setlocale (LC_MESSAGES
, "");
2964 setlocale (LC_CTYPE
, "");
2967 bindtextdomain (PACKAGE
, LOCALEDIR
);
2968 textdomain (PACKAGE
);
2970 program_name
= *argv
;
2971 xmalloc_set_program_name (program_name
);
2973 START_PROGRESS (program_name
, 0);
2975 expandargv (&argc
, &argv
);
2978 set_default_bfd_target ();
2980 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2981 long_options
, (int *) 0))
2987 break; /* We've been given a long option. */
2992 if (disassembler_options
)
2993 /* Ignore potential memory leak for now. */
2994 disassembler_options
= concat (disassembler_options
, ",",
2997 disassembler_options
= optarg
;
3000 if (only_used
== only_size
)
3003 only
= xrealloc (only
, only_size
* sizeof (char *));
3005 only
[only_used
++] = optarg
;
3008 with_line_numbers
= TRUE
;
3017 enum demangling_styles style
;
3019 style
= cplus_demangle_name_to_style (optarg
);
3020 if (style
== unknown_demangling
)
3021 fatal (_("unknown demangling style `%s'"),
3024 cplus_demangle_set_style (style
);
3030 case OPTION_ADJUST_VMA
:
3031 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
3033 case OPTION_START_ADDRESS
:
3034 start_address
= parse_vma (optarg
, "--start-address");
3036 case OPTION_STOP_ADDRESS
:
3037 stop_address
= parse_vma (optarg
, "--stop-address");
3040 if (strcmp (optarg
, "B") == 0)
3041 endian
= BFD_ENDIAN_BIG
;
3042 else if (strcmp (optarg
, "L") == 0)
3043 endian
= BFD_ENDIAN_LITTLE
;
3046 non_fatal (_("unrecognized -E option"));
3051 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
3052 endian
= BFD_ENDIAN_BIG
;
3053 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
3054 endian
= BFD_ENDIAN_LITTLE
;
3057 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
3063 dump_file_header
= TRUE
;
3067 formats_info
= TRUE
;
3071 add_include_path (optarg
);
3074 dump_private_headers
= TRUE
;
3078 dump_private_headers
= TRUE
;
3080 dump_reloc_info
= TRUE
;
3081 dump_file_header
= TRUE
;
3082 dump_ar_hdrs
= TRUE
;
3083 dump_section_headers
= TRUE
;
3091 dump_dynamic_symtab
= TRUE
;
3099 disassemble_zeroes
= TRUE
;
3103 disassemble_all
= TRUE
;
3108 with_source_code
= TRUE
;
3117 dump_debugging_tags
= 1;
3122 dump_dwarf_section_info
= TRUE
;
3125 do_debug_abbrevs
= 1;
3127 do_debug_pubnames
= 1;
3128 do_debug_aranges
= 1;
3129 do_debug_ranges
= 1;
3130 do_debug_frames
= 1;
3131 do_debug_macinfo
= 1;
3136 dump_stab_section_info
= TRUE
;
3140 dump_section_contents
= TRUE
;
3144 dump_reloc_info
= TRUE
;
3148 dump_dynamic_reloc_info
= TRUE
;
3152 dump_ar_hdrs
= TRUE
;
3156 dump_section_headers
= TRUE
;
3164 show_version
= TRUE
;
3174 print_version ("objdump");
3180 exit_status
= display_info ();
3184 display_file ("a.out", target
);
3186 for (; optind
< argc
;)
3187 display_file (argv
[optind
++], target
);
3190 END_PROGRESS (program_name
);