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
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"
68 #if !HAVE_DECL_FPRINTF
69 /* This is needed by init_disassemble_info(). */
70 extern int fprintf (FILE *, const char *, ...);
74 static int exit_status
= 0;
76 static char *default_target
= NULL
; /* Default at runtime. */
78 /* The following variables are set based on arguments passed on the
80 static int show_version
= 0; /* Show the version number. */
81 static int dump_section_contents
; /* -s */
82 static int dump_section_headers
; /* -h */
83 static bfd_boolean dump_file_header
; /* -f */
84 static int dump_symtab
; /* -t */
85 static int dump_dynamic_symtab
; /* -T */
86 static int dump_reloc_info
; /* -r */
87 static int dump_dynamic_reloc_info
; /* -R */
88 static int dump_ar_hdrs
; /* -a */
89 static int dump_private_headers
; /* -p */
90 static int prefix_addresses
; /* --prefix-addresses */
91 static int with_line_numbers
; /* -l */
92 static bfd_boolean with_source_code
; /* -S */
93 static int show_raw_insn
; /* --show-raw-insn */
94 static int dump_stab_section_info
; /* --stabs */
95 static int do_demangle
; /* -C, --demangle */
96 static bfd_boolean disassemble
; /* -d */
97 static bfd_boolean disassemble_all
; /* -D */
98 static int disassemble_zeroes
; /* --disassemble-zeroes */
99 static bfd_boolean formats_info
; /* -i */
100 static int wide_output
; /* -w */
101 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
102 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
103 static int dump_debugging
; /* --debugging */
104 static int dump_debugging_tags
; /* --debugging-tags */
105 static int dump_special_syms
= 0; /* --special-syms */
106 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
107 static int file_start_context
= 0; /* --file-start-context */
109 /* Pointer to an array of section names provided by
110 one or more "-j secname" command line options. */
112 /* The total number of slots in the only[] array. */
113 static size_t only_size
= 0;
114 /* The number of occupied slots in the only[] array. */
115 static size_t only_used
= 0;
117 /* Variables for handling include file path table. */
118 static const char **include_paths
;
119 static int include_path_count
;
121 /* Extra info to pass to the section disassembler and address printing
123 struct objdump_disasm_info
127 bfd_boolean require_sec
;
128 arelent
** dynrelbuf
;
130 disassembler_ftype disassemble_fn
;
131 #ifdef DISASSEMBLER_NEEDS_RELOCS
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 -t, --syms Display the contents of the symbol table(s)\n\
193 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
194 -r, --reloc Display the relocation entries in the file\n\
195 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
196 -v, --version Display this program's version number\n\
197 -i, --info List object formats and architectures supported\n\
198 -H, --help Display this information\n\
202 fprintf (stream
, _("\n The following switches are optional:\n"));
203 fprintf (stream
, _("\
204 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
205 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
206 -j, --section=NAME Only display information for section NAME\n\
207 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
208 -EB --endian=big Assume big endian format when disassembling\n\
209 -EL --endian=little Assume little endian format when disassembling\n\
210 --file-start-context Include context from start of file (with -S)\n\
211 -I, --include=DIR Add DIR to search list for source files\n\
212 -l, --line-numbers Include line numbers and filenames in output\n\
213 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
214 The STYLE, if specified, can be `auto', `gnu',\n\
215 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
217 -w, --wide Format output for more than 80 columns\n\
218 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
219 --start-address=ADDR Only process data whose address is >= ADDR\n\
220 --stop-address=ADDR Only process data whose address is <= ADDR\n\
221 --prefix-addresses Print complete address alongside disassembly\n\
222 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
223 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
224 --special-syms Include special symbols in symbol dumps\n\
226 list_supported_targets (program_name
, stream
);
227 list_supported_architectures (program_name
, stream
);
229 disassembler_usage (stream
);
232 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
236 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
240 OPTION_START_ADDRESS
,
245 static struct option long_options
[]=
247 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
248 {"all-headers", no_argument
, NULL
, 'x'},
249 {"private-headers", no_argument
, NULL
, 'p'},
250 {"architecture", required_argument
, NULL
, 'm'},
251 {"archive-headers", no_argument
, NULL
, 'a'},
252 {"debugging", no_argument
, NULL
, 'g'},
253 {"debugging-tags", no_argument
, NULL
, 'e'},
254 {"demangle", optional_argument
, NULL
, 'C'},
255 {"disassemble", no_argument
, NULL
, 'd'},
256 {"disassemble-all", no_argument
, NULL
, 'D'},
257 {"disassembler-options", required_argument
, NULL
, 'M'},
258 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
259 {"dynamic-reloc", no_argument
, NULL
, 'R'},
260 {"dynamic-syms", no_argument
, NULL
, 'T'},
261 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
262 {"file-headers", no_argument
, NULL
, 'f'},
263 {"file-start-context", no_argument
, &file_start_context
, 1},
264 {"full-contents", no_argument
, NULL
, 's'},
265 {"headers", no_argument
, NULL
, 'h'},
266 {"help", no_argument
, NULL
, 'H'},
267 {"info", no_argument
, NULL
, 'i'},
268 {"line-numbers", no_argument
, NULL
, 'l'},
269 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
270 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
271 {"reloc", no_argument
, NULL
, 'r'},
272 {"section", required_argument
, NULL
, 'j'},
273 {"section-headers", no_argument
, NULL
, 'h'},
274 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
275 {"source", no_argument
, NULL
, 'S'},
276 {"special-syms", no_argument
, &dump_special_syms
, 1},
277 {"include", required_argument
, NULL
, 'I'},
278 {"stabs", no_argument
, NULL
, 'G'},
279 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
280 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
281 {"syms", no_argument
, NULL
, 't'},
282 {"target", required_argument
, NULL
, 'b'},
283 {"version", no_argument
, NULL
, 'V'},
284 {"wide", no_argument
, NULL
, 'w'},
285 {0, no_argument
, 0, 0}
289 nonfatal (const char *msg
)
296 dump_section_header (bfd
*abfd
, asection
*section
,
297 void *ignored ATTRIBUTE_UNUSED
)
300 unsigned int opb
= bfd_octets_per_byte (abfd
);
302 /* Ignore linker created section. See elfNN_ia64_object_p in
304 if (section
->flags
& SEC_LINKER_CREATED
)
307 printf ("%3d %-13s %08lx ", section
->index
,
308 bfd_get_section_name (abfd
, section
),
309 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
310 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
312 bfd_printf_vma (abfd
, section
->lma
);
313 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
314 bfd_get_section_alignment (abfd
, section
));
320 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
322 PF (SEC_HAS_CONTENTS
, "CONTENTS");
323 PF (SEC_ALLOC
, "ALLOC");
324 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
325 PF (SEC_LOAD
, "LOAD");
326 PF (SEC_RELOC
, "RELOC");
327 PF (SEC_READONLY
, "READONLY");
328 PF (SEC_CODE
, "CODE");
329 PF (SEC_DATA
, "DATA");
331 PF (SEC_DEBUGGING
, "DEBUGGING");
332 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
333 PF (SEC_EXCLUDE
, "EXCLUDE");
334 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
335 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
337 PF (SEC_TIC54X_BLOCK
, "BLOCK");
338 PF (SEC_TIC54X_CLINK
, "CLINK");
340 PF (SEC_SMALL_DATA
, "SMALL_DATA");
341 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
342 PF (SEC_COFF_SHARED
, "SHARED");
343 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
344 PF (SEC_GROUP
, "GROUP");
346 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
349 struct coff_comdat_info
*comdat
;
351 switch (section
->flags
& SEC_LINK_DUPLICATES
)
355 case SEC_LINK_DUPLICATES_DISCARD
:
356 ls
= "LINK_ONCE_DISCARD";
358 case SEC_LINK_DUPLICATES_ONE_ONLY
:
359 ls
= "LINK_ONCE_ONE_ONLY";
361 case SEC_LINK_DUPLICATES_SAME_SIZE
:
362 ls
= "LINK_ONCE_SAME_SIZE";
364 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
365 ls
= "LINK_ONCE_SAME_CONTENTS";
368 printf ("%s%s", comma
, ls
);
370 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
372 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
382 dump_headers (bfd
*abfd
)
384 printf (_("Sections:\n"));
387 printf (_("Idx Name Size VMA LMA File off Algn"));
389 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
390 if (bfd_get_arch_size (abfd
) == 32)
391 printf (_("Idx Name Size VMA LMA File off Algn"));
393 printf (_("Idx Name Size VMA LMA File off Algn"));
397 printf (_(" Flags"));
398 if (abfd
->flags
& HAS_LOAD_PAGE
)
402 bfd_map_over_sections (abfd
, dump_section_header
, NULL
);
406 slurp_symtab (bfd
*abfd
)
411 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
417 storage
= bfd_get_symtab_upper_bound (abfd
);
419 bfd_fatal (bfd_get_filename (abfd
));
421 sy
= xmalloc (storage
);
423 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
425 bfd_fatal (bfd_get_filename (abfd
));
429 /* Read in the dynamic symbols. */
432 slurp_dynamic_symtab (bfd
*abfd
)
437 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
440 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
442 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
447 bfd_fatal (bfd_get_filename (abfd
));
450 sy
= xmalloc (storage
);
452 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
454 bfd_fatal (bfd_get_filename (abfd
));
458 /* Filter out (in place) symbols that are useless for disassembly.
459 COUNT is the number of elements in SYMBOLS.
460 Return the number of useful symbols. */
463 remove_useless_symbols (asymbol
**symbols
, long count
)
465 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
469 asymbol
*sym
= *in_ptr
++;
471 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
473 if (sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
475 if (bfd_is_und_section (sym
->section
)
476 || bfd_is_com_section (sym
->section
))
481 return out_ptr
- symbols
;
484 /* Sort symbols into value order. */
487 compare_symbols (const void *ap
, const void *bp
)
489 const asymbol
*a
= * (const asymbol
**) ap
;
490 const asymbol
*b
= * (const asymbol
**) bp
;
500 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
502 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
505 if (a
->section
> b
->section
)
507 else if (a
->section
< b
->section
)
510 an
= bfd_asymbol_name (a
);
511 bn
= bfd_asymbol_name (b
);
515 /* The symbols gnu_compiled and gcc2_compiled convey no real
516 information, so put them after other symbols with the same value. */
517 af
= (strstr (an
, "gnu_compiled") != NULL
518 || strstr (an
, "gcc2_compiled") != NULL
);
519 bf
= (strstr (bn
, "gnu_compiled") != NULL
520 || strstr (bn
, "gcc2_compiled") != NULL
);
527 /* We use a heuristic for the file name, to try to sort it after
528 more useful symbols. It may not work on non Unix systems, but it
529 doesn't really matter; the only difference is precisely which
530 symbol names get printed. */
532 #define file_symbol(s, sn, snl) \
533 (((s)->flags & BSF_FILE) != 0 \
534 || ((sn)[(snl) - 2] == '.' \
535 && ((sn)[(snl) - 1] == 'o' \
536 || (sn)[(snl) - 1] == 'a')))
538 af
= file_symbol (a
, an
, anl
);
539 bf
= file_symbol (b
, bn
, bnl
);
546 /* Try to sort global symbols before local symbols before function
547 symbols before debugging symbols. */
552 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
554 if ((aflags
& BSF_DEBUGGING
) != 0)
559 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
561 if ((aflags
& BSF_FUNCTION
) != 0)
566 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
568 if ((aflags
& BSF_LOCAL
) != 0)
573 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
575 if ((aflags
& BSF_GLOBAL
) != 0)
581 /* Symbols that start with '.' might be section names, so sort them
582 after symbols that don't start with '.'. */
583 if (an
[0] == '.' && bn
[0] != '.')
585 if (an
[0] != '.' && bn
[0] == '.')
588 /* Finally, if we can't distinguish them in any other way, try to
589 get consistent results by sorting the symbols by name. */
590 return strcmp (an
, bn
);
593 /* Sort relocs into address order. */
596 compare_relocs (const void *ap
, const void *bp
)
598 const arelent
*a
= * (const arelent
**) ap
;
599 const arelent
*b
= * (const arelent
**) bp
;
601 if (a
->address
> b
->address
)
603 else if (a
->address
< b
->address
)
606 /* So that associated relocations tied to the same address show up
607 in the correct order, we don't do any further sorting. */
616 /* Print an address (VMA) to the output stream in INFO.
617 If SKIP_ZEROES is TRUE, omit leading zeroes. */
620 objdump_print_value (bfd_vma vma
, struct disassemble_info
*info
,
621 bfd_boolean skip_zeroes
)
625 struct objdump_disasm_info
*aux
;
627 aux
= (struct objdump_disasm_info
*) info
->application_data
;
628 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
633 for (p
= buf
; *p
== '0'; ++p
)
638 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
641 /* Print the name of a symbol. */
644 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*info
,
651 name
= bfd_asymbol_name (sym
);
652 if (do_demangle
&& name
[0] != '\0')
654 /* Demangle the name. */
655 alloc
= demangle (abfd
, name
);
660 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
668 /* Locate a symbol given a bfd and a section (from INFO->application_data),
669 and a VMA. If INFO->application_data->require_sec is TRUE, then always
670 require the symbol to be in the section. Returns NULL if there is no
671 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
672 of the symbol in sorted_syms. */
675 find_symbol_for_address (bfd_vma vma
,
676 struct disassemble_info
*info
,
679 /* @@ Would it speed things up to cache the last two symbols returned,
680 and maybe their address ranges? For many processors, only one memory
681 operand can be present at a time, so the 2-entry cache wouldn't be
682 constantly churned by code doing heavy memory accesses. */
684 /* Indices in `sorted_syms'. */
686 long max
= sorted_symcount
;
688 struct objdump_disasm_info
*aux
;
693 if (sorted_symcount
< 1)
696 aux
= (struct objdump_disasm_info
*) info
->application_data
;
699 opb
= bfd_octets_per_byte (abfd
);
701 /* Perform a binary search looking for the closest symbol to the
702 required value. We are searching the range (min, max]. */
703 while (min
+ 1 < max
)
707 thisplace
= (max
+ min
) / 2;
708 sym
= sorted_syms
[thisplace
];
710 if (bfd_asymbol_value (sym
) > vma
)
712 else if (bfd_asymbol_value (sym
) < vma
)
721 /* The symbol we want is now in min, the low end of the range we
722 were searching. If there are several symbols with the same
723 value, we want the first one. */
726 && (bfd_asymbol_value (sorted_syms
[thisplace
])
727 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
730 /* If the file is relocatable, and the symbol could be from this
731 section, prefer a symbol from this section over symbols from
732 others, even if the other symbol's value might be closer.
734 Note that this may be wrong for some symbol references if the
735 sections have overlapping memory ranges, but in that case there's
736 no way to tell what's desired without looking at the relocation
738 if (sorted_syms
[thisplace
]->section
!= sec
740 || ((abfd
->flags
& HAS_RELOC
) != 0
741 && vma
>= bfd_get_section_vma (abfd
, sec
)
742 && vma
< (bfd_get_section_vma (abfd
, sec
)
743 + bfd_section_size (abfd
, sec
) / opb
))))
747 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
749 if (bfd_asymbol_value (sorted_syms
[i
])
750 != bfd_asymbol_value (sorted_syms
[thisplace
]))
758 if (sorted_syms
[i
]->section
== sec
760 || sorted_syms
[i
- 1]->section
!= sec
761 || (bfd_asymbol_value (sorted_syms
[i
])
762 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
769 if (sorted_syms
[thisplace
]->section
!= sec
)
771 /* We didn't find a good symbol with a smaller value.
772 Look for one with a larger value. */
773 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
775 if (sorted_syms
[i
]->section
== sec
)
783 if (sorted_syms
[thisplace
]->section
!= sec
785 || ((abfd
->flags
& HAS_RELOC
) != 0
786 && vma
>= bfd_get_section_vma (abfd
, sec
)
787 && vma
< (bfd_get_section_vma (abfd
, sec
)
788 + bfd_section_size (abfd
, sec
)))))
789 /* There is no suitable symbol. */
793 /* Give the target a chance to reject the symbol. */
794 while (! info
->symbol_is_valid (sorted_syms
[thisplace
], info
))
797 if (thisplace
>= sorted_symcount
798 || bfd_asymbol_value (sorted_syms
[thisplace
]) > vma
)
805 return sorted_syms
[thisplace
];
808 /* Print an address and the offset to the nearest symbol. */
811 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
812 bfd_vma vma
, struct disassemble_info
*info
,
813 bfd_boolean skip_zeroes
)
815 objdump_print_value (vma
, info
, skip_zeroes
);
821 (*info
->fprintf_func
) (info
->stream
, " <%s",
822 bfd_get_section_name (abfd
, sec
));
823 secaddr
= bfd_get_section_vma (abfd
, sec
);
826 (*info
->fprintf_func
) (info
->stream
, "-0x");
827 objdump_print_value (secaddr
- vma
, info
, TRUE
);
829 else if (vma
> secaddr
)
831 (*info
->fprintf_func
) (info
->stream
, "+0x");
832 objdump_print_value (vma
- secaddr
, info
, TRUE
);
834 (*info
->fprintf_func
) (info
->stream
, ">");
838 (*info
->fprintf_func
) (info
->stream
, " <");
839 objdump_print_symname (abfd
, info
, sym
);
840 if (bfd_asymbol_value (sym
) > vma
)
842 (*info
->fprintf_func
) (info
->stream
, "-0x");
843 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
845 else if (vma
> bfd_asymbol_value (sym
))
847 (*info
->fprintf_func
) (info
->stream
, "+0x");
848 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
850 (*info
->fprintf_func
) (info
->stream
, ">");
854 /* Print an address (VMA), symbolically if possible.
855 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
858 objdump_print_addr (bfd_vma vma
,
859 struct disassemble_info
*info
,
860 bfd_boolean skip_zeroes
)
862 struct objdump_disasm_info
*aux
;
863 asymbol
*sym
= NULL
; /* Initialize to avoid compiler warning. */
864 #ifdef DISASSEMBLER_NEEDS_RELOCS
865 bfd_boolean skip_find
= FALSE
;
868 if (sorted_symcount
< 1)
870 (*info
->fprintf_func
) (info
->stream
, "0x");
871 objdump_print_value (vma
, info
, skip_zeroes
);
875 aux
= (struct objdump_disasm_info
*) info
->application_data
;
877 #ifdef DISASSEMBLER_NEEDS_RELOCS
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
)))
893 sym
= find_symbol_for_address (vma
, info
, NULL
);
895 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
899 /* Print VMA to INFO. This function is passed to the disassembler
903 objdump_print_address (bfd_vma vma
, struct disassemble_info
*info
)
905 objdump_print_addr (vma
, info
, ! prefix_addresses
);
908 /* Determine of the given address has a symbol associated with it. */
911 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* info
)
915 sym
= find_symbol_for_address (vma
, info
, NULL
);
917 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
920 /* Hold the last function name and the last line number we displayed
923 static char *prev_functionname
;
924 static unsigned int prev_line
;
926 /* We keep a list of all files that we have seen when doing a
927 disassembly with source, so that we know how much of the file to
928 display. This can be important for inlined functions. */
930 struct print_file_list
932 struct print_file_list
*next
;
933 const char *filename
;
939 static struct print_file_list
*print_files
;
941 /* The number of preceding context lines to show when we start
942 displaying a file for the first time. */
944 #define SHOW_PRECEDING_CONTEXT_LINES (5)
946 /* Tries to open MODNAME, and if successful adds a node to print_files
947 linked list and returns that node. Returns NULL on failure. */
949 static struct print_file_list
*
950 try_print_file_open (const char *origname
, const char *modname
)
952 struct print_file_list
*p
;
955 f
= fopen (modname
, "r");
959 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
961 fclose (print_files
->f
);
962 print_files
->f
= NULL
;
965 p
= xmalloc (sizeof (struct print_file_list
));
966 p
->filename
= origname
;
967 p
->modname
= modname
;
970 p
->next
= print_files
;
975 /* If the the source file, as described in the symtab, is not found
976 try to locate it in one of the paths specified with -I
977 If found, add location to print_files linked list. */
979 static struct print_file_list
*
980 update_source_path (const char *filename
)
982 struct print_file_list
*p
;
986 if (filename
== NULL
)
989 p
= try_print_file_open (filename
, filename
);
993 if (include_path_count
== 0)
996 /* Get the name of the file. */
997 fname
= strrchr (filename
, '/');
998 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1000 /* We could have a mixed forward/back slash case. */
1001 char *backslash
= strrchr (filename
, '\\');
1002 if (fname
== NULL
|| (backslash
!= NULL
&& backslash
> fname
))
1004 if (fname
== NULL
&& filename
[0] != '\0' && filename
[1] == ':')
1005 fname
= filename
+ 1;
1013 /* If file exists under a new path, we need to add it to the list
1014 so that show_line knows about it. */
1015 for (i
= 0; i
< include_path_count
; i
++)
1017 char *modname
= concat (include_paths
[i
], "/", fname
, (const char *) 0);
1019 p
= try_print_file_open (filename
, modname
);
1029 /* Skip ahead to a given line in a file, optionally printing each
1033 skip_to_line (struct print_file_list
*p
, unsigned int line
,
1036 while (p
->line
< line
)
1040 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1050 if (strchr (buf
, '\n') != NULL
)
1055 /* Show the line number, or the source line, in a disassembly
1059 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1061 const char *filename
;
1062 const char *functionname
;
1065 if (! with_line_numbers
&& ! with_source_code
)
1068 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1069 &functionname
, &line
))
1072 if (filename
!= NULL
&& *filename
== '\0')
1074 if (functionname
!= NULL
&& *functionname
== '\0')
1075 functionname
= NULL
;
1077 if (with_line_numbers
)
1079 if (functionname
!= NULL
1080 && (prev_functionname
== NULL
1081 || strcmp (functionname
, prev_functionname
) != 0))
1082 printf ("%s():\n", functionname
);
1083 if (line
> 0 && line
!= prev_line
)
1084 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1087 if (with_source_code
1091 struct print_file_list
**pp
, *p
;
1093 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1094 if (strcmp ((*pp
)->filename
, filename
) == 0)
1100 if (p
!= print_files
)
1104 /* We have reencountered a file name which we saw
1105 earlier. This implies that either we are dumping out
1106 code from an included file, or the same file was
1107 linked in more than once. There are two common cases
1108 of an included file: inline functions in a header
1109 file, and a bison or flex skeleton file. In the
1110 former case we want to just start printing (but we
1111 back up a few lines to give context); in the latter
1112 case we want to continue from where we left off. I
1113 can't think of a good way to distinguish the cases,
1114 so I used a heuristic based on the file name. */
1115 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1119 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1126 p
->f
= fopen (p
->modname
, "r");
1130 skip_to_line (p
, l
, FALSE
);
1132 if (print_files
->f
!= NULL
)
1134 fclose (print_files
->f
);
1135 print_files
->f
= NULL
;
1141 skip_to_line (p
, line
, TRUE
);
1143 p
->next
= print_files
;
1149 p
= update_source_path (filename
);
1155 if (file_start_context
)
1158 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1161 skip_to_line (p
, l
, FALSE
);
1163 skip_to_line (p
, line
, TRUE
);
1168 if (functionname
!= NULL
1169 && (prev_functionname
== NULL
1170 || strcmp (functionname
, prev_functionname
) != 0))
1172 if (prev_functionname
!= NULL
)
1173 free (prev_functionname
);
1174 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1175 strcpy (prev_functionname
, functionname
);
1178 if (line
> 0 && line
!= prev_line
)
1182 /* Pseudo FILE object for strings. */
1190 /* sprintf to a "stream". */
1192 static int ATTRIBUTE_PRINTF_2
1193 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1200 size_t space
= f
->alloc
- f
->pos
;
1202 va_start (args
, format
);
1203 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1209 f
->alloc
= (f
->alloc
+ n
) * 2;
1210 f
->buffer
= xrealloc (f
->buffer
, f
->alloc
);
1217 /* Returns TRUE if the specified section should be dumped. */
1220 process_section_p (asection
* section
)
1227 for (i
= 0; i
< only_used
; i
++)
1228 if (strcmp (only
[i
], section
->name
) == 0)
1235 /* The number of zeroes we want to see before we start skipping them.
1236 The number is arbitrarily chosen. */
1238 #define DEFAULT_SKIP_ZEROES 8
1240 /* The number of zeroes to skip at the end of a section. If the
1241 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1242 SKIP_ZEROES, they will be disassembled. If there are fewer than
1243 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1244 attempt to avoid disassembling zeroes inserted by section
1247 #define DEFAULT_SKIP_ZEROES_AT_END 3
1249 /* Disassemble some data in memory between given values. */
1252 disassemble_bytes (struct disassemble_info
* info
,
1253 disassembler_ftype disassemble_fn
,
1256 bfd_vma start_offset
,
1257 bfd_vma stop_offset
,
1260 arelent
** relppend
)
1262 struct objdump_disasm_info
*aux
;
1264 int octets_per_line
;
1265 bfd_boolean done_dot
;
1266 int skip_addr_chars
;
1267 bfd_vma addr_offset
;
1268 unsigned int opb
= info
->octets_per_byte
;
1269 unsigned int skip_zeroes
= info
->skip_zeroes
;
1270 unsigned int skip_zeroes_at_end
= info
->skip_zeroes_at_end
;
1274 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1278 sfile
.buffer
= xmalloc (sfile
.alloc
);
1282 octets_per_line
= 4;
1284 octets_per_line
= 16;
1286 /* Figure out how many characters to skip at the start of an
1287 address, to make the disassembly look nicer. We discard leading
1288 zeroes in chunks of 4, ensuring that there is always a leading
1290 skip_addr_chars
= 0;
1291 if (! prefix_addresses
)
1299 + bfd_section_size (section
->owner
, section
) / opb
));
1301 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1304 skip_addr_chars
+= 4;
1309 info
->insn_info_valid
= 0;
1312 addr_offset
= start_offset
;
1313 while (addr_offset
< stop_offset
)
1316 bfd_boolean need_nl
= FALSE
;
1317 #ifdef DISASSEMBLER_NEEDS_RELOCS
1318 int previous_octets
;
1320 /* Remember the length of the previous instruction. */
1321 previous_octets
= octets
;
1325 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1327 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1330 if (! disassemble_zeroes
1331 && (info
->insn_info_valid
== 0
1332 || info
->branch_delay_insns
== 0)
1333 && (z
- addr_offset
* opb
>= skip_zeroes
1334 || (z
== stop_offset
* opb
&&
1335 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1339 /* If there are more nonzero octets to follow, we only skip
1340 zeroes in multiples of 4, to try to avoid running over
1341 the start of an instruction which happens to start with
1343 if (z
!= stop_offset
* opb
)
1344 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1346 octets
= z
- addr_offset
* opb
;
1356 if (with_line_numbers
|| with_source_code
)
1357 show_line (aux
->abfd
, section
, addr_offset
);
1359 if (! prefix_addresses
)
1363 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1364 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1368 printf ("%s:\t", buf
+ skip_addr_chars
);
1372 aux
->require_sec
= TRUE
;
1373 objdump_print_address (section
->vma
+ addr_offset
, info
);
1374 aux
->require_sec
= FALSE
;
1381 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1382 info
->stream
= &sfile
;
1383 info
->bytes_per_line
= 0;
1384 info
->bytes_per_chunk
= 0;
1387 #ifdef DISASSEMBLER_NEEDS_RELOCS
1388 if (*relppp
< relppend
)
1390 bfd_signed_vma distance_to_rel
;
1392 distance_to_rel
= (**relppp
)->address
1393 - (rel_offset
+ addr_offset
);
1395 /* Check to see if the current reloc is associated with
1396 the instruction that we are about to disassemble. */
1397 if (distance_to_rel
== 0
1398 /* FIXME: This is wrong. We are trying to catch
1399 relocs that are addressed part way through the
1400 current instruction, as might happen with a packed
1401 VLIW instruction. Unfortunately we do not know the
1402 length of the current instruction since we have not
1403 disassembled it yet. Instead we take a guess based
1404 upon the length of the previous instruction. The
1405 proper solution is to have a new target-specific
1406 disassembler function which just returns the length
1407 of an instruction at a given address without trying
1408 to display its disassembly. */
1409 || (distance_to_rel
> 0
1410 && distance_to_rel
< (bfd_signed_vma
) (previous_octets
/ opb
)))
1412 info
->flags
= INSN_HAS_RELOC
;
1413 aux
->reloc
= **relppp
;
1419 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1420 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1421 info
->stream
= stdout
;
1422 if (info
->bytes_per_line
!= 0)
1423 octets_per_line
= info
->bytes_per_line
;
1427 printf ("%s\n", sfile
.buffer
);
1435 octets
= octets_per_line
;
1436 if (addr_offset
+ octets
/ opb
> stop_offset
)
1437 octets
= (stop_offset
- addr_offset
) * opb
;
1439 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1441 if (ISPRINT (data
[j
]))
1442 buf
[j
- addr_offset
* opb
] = data
[j
];
1444 buf
[j
- addr_offset
* opb
] = '.';
1446 buf
[j
- addr_offset
* opb
] = '\0';
1449 if (prefix_addresses
1451 : show_raw_insn
>= 0)
1455 /* If ! prefix_addresses and ! wide_output, we print
1456 octets_per_line octets per line. */
1458 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1459 pb
= octets_per_line
;
1461 if (info
->bytes_per_chunk
)
1462 bpc
= info
->bytes_per_chunk
;
1466 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1470 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1472 for (k
= bpc
- 1; k
>= 0; k
--)
1473 printf ("%02x", (unsigned) data
[j
+ k
]);
1478 for (k
= 0; k
< bpc
; k
++)
1479 printf ("%02x", (unsigned) data
[j
+ k
]);
1484 for (; pb
< octets_per_line
; pb
+= bpc
)
1488 for (k
= 0; k
< bpc
; k
++)
1493 /* Separate raw data from instruction by extra space. */
1503 printf ("%s", sfile
.buffer
);
1505 if (prefix_addresses
1507 : show_raw_insn
>= 0)
1515 j
= addr_offset
* opb
+ pb
;
1517 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1518 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1522 printf ("%s:\t", buf
+ skip_addr_chars
);
1524 pb
+= octets_per_line
;
1527 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1531 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1533 for (k
= bpc
- 1; k
>= 0; k
--)
1534 printf ("%02x", (unsigned) data
[j
+ k
]);
1539 for (k
= 0; k
< bpc
; k
++)
1540 printf ("%02x", (unsigned) data
[j
+ k
]);
1553 while ((*relppp
) < relppend
1554 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
1556 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
1567 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
1570 if (q
->howto
== NULL
)
1571 printf (": *unknown*\t");
1572 else if (q
->howto
->name
)
1573 printf (": %s\t", q
->howto
->name
);
1575 printf (": %d\t", q
->howto
->type
);
1577 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1578 printf ("*unknown*");
1581 const char *sym_name
;
1583 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1584 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1585 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1590 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1591 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1592 if (sym_name
== NULL
|| *sym_name
== '\0')
1593 sym_name
= "*unknown*";
1594 printf ("%s", sym_name
);
1601 objdump_print_value (q
->addend
, info
, TRUE
);
1613 addr_offset
+= octets
/ opb
;
1616 free (sfile
.buffer
);
1620 disassemble_section (bfd
*abfd
, asection
*section
, void *info
)
1622 struct disassemble_info
* pinfo
= (struct disassemble_info
*) info
;
1623 struct objdump_disasm_info
* paux
;
1624 unsigned int opb
= pinfo
->octets_per_byte
;
1625 bfd_byte
* data
= NULL
;
1626 bfd_size_type datasize
= 0;
1627 arelent
** rel_pp
= NULL
;
1628 arelent
** rel_ppstart
= NULL
;
1629 arelent
** rel_ppend
;
1630 unsigned long stop_offset
;
1631 asymbol
* sym
= NULL
;
1635 unsigned long addr_offset
;
1637 /* Sections that do not contain machine
1638 code are not normally disassembled. */
1639 if (! disassemble_all
1641 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
1642 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
1645 if (! process_section_p (section
))
1648 datasize
= bfd_get_section_size (section
);
1652 /* Decide which set of relocs to use. Load them if necessary. */
1653 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
1654 if (paux
->dynrelbuf
)
1656 rel_pp
= paux
->dynrelbuf
;
1657 rel_count
= paux
->dynrelcount
;
1658 /* Dynamic reloc addresses are absolute, non-dynamic are section
1659 relative. REL_OFFSET specifies the reloc address corresponding
1660 to the start of this section. */
1661 rel_offset
= section
->vma
;
1669 if ((section
->flags
& SEC_RELOC
) != 0
1670 #ifndef DISASSEMBLER_NEEDS_RELOCS
1677 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1679 bfd_fatal (bfd_get_filename (abfd
));
1683 rel_ppstart
= rel_pp
= xmalloc (relsize
);
1684 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
1686 bfd_fatal (bfd_get_filename (abfd
));
1688 /* Sort the relocs by address. */
1689 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
1694 rel_ppend
= rel_pp
+ rel_count
;
1696 data
= xmalloc (datasize
);
1698 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1700 paux
->sec
= section
;
1701 pinfo
->buffer
= data
;
1702 pinfo
->buffer_vma
= section
->vma
;
1703 pinfo
->buffer_length
= datasize
;
1704 pinfo
->section
= section
;
1706 if (start_address
== (bfd_vma
) -1
1707 || start_address
< pinfo
->buffer_vma
)
1710 addr_offset
= start_address
- pinfo
->buffer_vma
;
1712 if (stop_address
== (bfd_vma
) -1)
1713 stop_offset
= datasize
/ opb
;
1716 if (stop_address
< pinfo
->buffer_vma
)
1719 stop_offset
= stop_address
- pinfo
->buffer_vma
;
1720 if (stop_offset
> pinfo
->buffer_length
/ opb
)
1721 stop_offset
= pinfo
->buffer_length
/ opb
;
1724 /* Skip over the relocs belonging to addresses below the
1726 while (rel_pp
< rel_ppend
1727 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
1730 printf (_("Disassembly of section %s:\n"), section
->name
);
1732 /* Find the nearest symbol forwards from our current position. */
1733 paux
->require_sec
= TRUE
;
1734 sym
= find_symbol_for_address (section
->vma
+ addr_offset
, info
, &place
);
1735 paux
->require_sec
= FALSE
;
1737 /* Disassemble a block of instructions up to the address associated with
1738 the symbol we have just found. Then print the symbol and find the
1739 next symbol on. Repeat until we have disassembled the entire section
1740 or we have reached the end of the address range we are interested in. */
1741 while (addr_offset
< stop_offset
)
1745 unsigned long nextstop_offset
;
1748 addr
= section
->vma
+ addr_offset
;
1750 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
1755 (x
< sorted_symcount
1756 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
1760 pinfo
->symbols
= sorted_syms
+ place
;
1761 pinfo
->num_symbols
= x
- place
;
1765 pinfo
->symbols
= NULL
;
1766 pinfo
->num_symbols
= 0;
1769 if (! prefix_addresses
)
1771 pinfo
->fprintf_func (pinfo
->stream
, "\n");
1772 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
1774 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
1777 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1779 else if (sym
== NULL
)
1783 #define is_valid_next_sym(SYM) \
1784 ((SYM)->section == section \
1785 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1786 && pinfo->symbol_is_valid (SYM, pinfo))
1788 /* Search forward for the next appropriate symbol in
1789 SECTION. Note that all the symbols are sorted
1790 together into one big array, and that some sections
1791 may have overlapping addresses. */
1792 while (place
< sorted_symcount
1793 && ! is_valid_next_sym (sorted_syms
[place
]))
1796 if (place
>= sorted_symcount
)
1799 nextsym
= sorted_syms
[place
];
1802 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
1803 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1804 else if (nextsym
== NULL
)
1805 nextstop_offset
= stop_offset
;
1807 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1809 if (nextstop_offset
> stop_offset
)
1810 nextstop_offset
= stop_offset
;
1812 /* If a symbol is explicitly marked as being an object
1813 rather than a function, just dump the bytes without
1814 disassembling them. */
1817 || bfd_asymbol_value (sym
) > addr
1818 || ((sym
->flags
& BSF_OBJECT
) == 0
1819 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1821 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1823 || (sym
->flags
& BSF_FUNCTION
) != 0)
1828 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
1829 addr_offset
, nextstop_offset
,
1830 rel_offset
, &rel_pp
, rel_ppend
);
1832 addr_offset
= nextstop_offset
;
1838 if (rel_ppstart
!= NULL
)
1842 /* Disassemble the contents of an object file. */
1845 disassemble_data (bfd
*abfd
)
1847 struct disassemble_info disasm_info
;
1848 struct objdump_disasm_info aux
;
1852 prev_functionname
= NULL
;
1855 /* We make a copy of syms to sort. We don't want to sort syms
1856 because that will screw up the relocs. */
1857 sorted_symcount
= symcount
? symcount
: dynsymcount
;
1858 sorted_syms
= xmalloc ((sorted_symcount
+ synthcount
) * sizeof (asymbol
*));
1859 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
1860 sorted_symcount
* sizeof (asymbol
*));
1862 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
1864 for (i
= 0; i
< synthcount
; ++i
)
1866 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
1870 /* Sort the symbols into section and symbol order. */
1871 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1873 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
1875 disasm_info
.application_data
= (void *) &aux
;
1877 aux
.require_sec
= FALSE
;
1878 aux
.dynrelbuf
= NULL
;
1879 aux
.dynrelcount
= 0;
1880 #ifdef DISASSEMBLER_NEEDS_RELOCS
1884 disasm_info
.print_address_func
= objdump_print_address
;
1885 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1887 if (machine
!= NULL
)
1889 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1892 fatal (_("Can't use supplied machine %s"), machine
);
1894 abfd
->arch_info
= info
;
1897 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1899 struct bfd_target
*xvec
;
1901 xvec
= xmalloc (sizeof (struct bfd_target
));
1902 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1903 xvec
->byteorder
= endian
;
1907 /* Use libopcodes to locate a suitable disassembler. */
1908 aux
.disassemble_fn
= disassembler (abfd
);
1909 if (!aux
.disassemble_fn
)
1911 non_fatal (_("Can't disassemble for architecture %s\n"),
1912 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1917 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1918 disasm_info
.arch
= bfd_get_arch (abfd
);
1919 disasm_info
.mach
= bfd_get_mach (abfd
);
1920 disasm_info
.disassembler_options
= disassembler_options
;
1921 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
1922 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
1923 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
1925 if (bfd_big_endian (abfd
))
1926 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1927 else if (bfd_little_endian (abfd
))
1928 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1930 /* ??? Aborting here seems too drastic. We could default to big or little
1932 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1934 /* Allow the target to customize the info structure. */
1935 disassemble_init_for_target (& disasm_info
);
1937 /* Pre-load the dynamic relocs if we are going
1938 to be dumping them along with the disassembly. */
1939 if (dump_dynamic_reloc_info
)
1941 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1944 bfd_fatal (bfd_get_filename (abfd
));
1948 aux
.dynrelbuf
= xmalloc (relsize
);
1949 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
1952 if (aux
.dynrelcount
< 0)
1953 bfd_fatal (bfd_get_filename (abfd
));
1955 /* Sort the relocs by address. */
1956 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
1961 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
1963 if (aux
.dynrelbuf
!= NULL
)
1964 free (aux
.dynrelbuf
);
1968 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1969 it. Return NULL on failure. */
1972 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
)
1978 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
1979 if (stabsect
== NULL
)
1981 printf (_("No %s section present\n\n"), sect_name
);
1985 size
= bfd_section_size (abfd
, stabsect
);
1986 contents
= xmalloc (size
);
1988 if (! bfd_get_section_contents (abfd
, stabsect
, contents
, 0, size
))
1990 non_fatal (_("Reading %s section of %s failed: %s"),
1991 sect_name
, bfd_get_filename (abfd
),
1992 bfd_errmsg (bfd_get_error ()));
2003 /* Stabs entries use a 12 byte format:
2004 4 byte string table index
2006 1 byte stab other field
2007 2 byte stab desc field
2009 FIXME: This will have to change for a 64 bit object format. */
2011 #define STRDXOFF (0)
2013 #define OTHEROFF (5)
2016 #define STABSIZE (12)
2018 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2019 using string table section STRSECT_NAME (in `strtab'). */
2022 print_section_stabs (bfd
*abfd
,
2023 const char *stabsect_name
,
2024 unsigned *string_offset_ptr
)
2027 unsigned file_string_table_offset
= 0;
2028 unsigned next_file_string_table_offset
= *string_offset_ptr
;
2029 bfd_byte
*stabp
, *stabs_end
;
2032 stabs_end
= stabp
+ stab_size
;
2034 printf (_("Contents of %s section:\n\n"), stabsect_name
);
2035 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2037 /* Loop through all symbols and print them.
2039 We start the index at -1 because there is a dummy symbol on
2040 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2041 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
2045 unsigned char type
, other
;
2046 unsigned short desc
;
2049 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
2050 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
2051 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
2052 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
2053 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
2055 printf ("\n%-6d ", i
);
2056 /* Either print the stab name, or, if unnamed, print its number
2057 again (makes consistent formatting for tools like awk). */
2058 name
= bfd_get_stab_name (type
);
2060 printf ("%-6s", name
);
2061 else if (type
== N_UNDF
)
2064 printf ("%-6d", type
);
2065 printf (" %-6d %-6d ", other
, desc
);
2066 bfd_printf_vma (abfd
, value
);
2067 printf (" %-6lu", strx
);
2069 /* Symbols with type == 0 (N_UNDF) specify the length of the
2070 string table associated with this file. We use that info
2071 to know how to relocate the *next* file's string table indices. */
2074 file_string_table_offset
= next_file_string_table_offset
;
2075 next_file_string_table_offset
+= value
;
2079 /* Using the (possibly updated) string table offset, print the
2080 string (if any) associated with this symbol. */
2081 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2082 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2088 *string_offset_ptr
= next_file_string_table_offset
;
2093 const char * section_name
;
2094 const char * string_section_name
;
2095 unsigned string_offset
;
2100 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
2103 stab_section_names
* sought
= (stab_section_names
*) names
;
2105 /* Check for section names for which stabsect_name is a prefix, to
2106 handle .stab.N, etc. */
2107 len
= strlen (sought
->section_name
);
2109 /* If the prefix matches, and the files section name ends with a
2110 nul or a digit, then we match. I.e., we want either an exact
2111 match or a section followed by a number. */
2112 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
2113 && (section
->name
[len
] == 0
2114 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
2117 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
2122 stabs
= (bfd_byte
*) read_section_stabs (abfd
, section
->name
,
2125 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
2131 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
2133 stab_section_names s
;
2135 s
.section_name
= stabsect_name
;
2136 s
.string_section_name
= strsect_name
;
2137 s
.string_offset
= 0;
2139 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
2145 /* Dump the any sections containing stabs debugging information. */
2148 dump_stabs (bfd
*abfd
)
2150 dump_stabs_section (abfd
, ".stab", ".stabstr");
2151 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
2152 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
2153 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2157 dump_bfd_header (bfd
*abfd
)
2161 printf (_("architecture: %s, "),
2162 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2163 bfd_get_mach (abfd
)));
2164 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2166 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2167 PF (HAS_RELOC
, "HAS_RELOC");
2168 PF (EXEC_P
, "EXEC_P");
2169 PF (HAS_LINENO
, "HAS_LINENO");
2170 PF (HAS_DEBUG
, "HAS_DEBUG");
2171 PF (HAS_SYMS
, "HAS_SYMS");
2172 PF (HAS_LOCALS
, "HAS_LOCALS");
2173 PF (DYNAMIC
, "DYNAMIC");
2174 PF (WP_TEXT
, "WP_TEXT");
2175 PF (D_PAGED
, "D_PAGED");
2176 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2177 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2178 printf (_("\nstart address 0x"));
2179 bfd_printf_vma (abfd
, abfd
->start_address
);
2185 dump_bfd_private_header (bfd
*abfd
)
2187 bfd_print_private_bfd_data (abfd
, stdout
);
2191 /* Display a section in hexadecimal format with associated characters.
2192 Each line prefixed by the zero padded address. */
2195 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
2198 bfd_size_type datasize
;
2199 bfd_size_type addr_offset
;
2200 bfd_size_type start_offset
;
2201 bfd_size_type stop_offset
;
2202 unsigned int opb
= bfd_octets_per_byte (abfd
);
2203 /* Bytes per line. */
2204 const int onaline
= 16;
2209 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
2212 if (! process_section_p (section
))
2215 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
2218 printf (_("Contents of section %s:\n"), section
->name
);
2220 data
= xmalloc (datasize
);
2222 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
2224 /* Compute the address range to display. */
2225 if (start_address
== (bfd_vma
) -1
2226 || start_address
< section
->vma
)
2229 start_offset
= start_address
- section
->vma
;
2231 if (stop_address
== (bfd_vma
) -1)
2232 stop_offset
= datasize
/ opb
;
2235 if (stop_address
< section
->vma
)
2238 stop_offset
= stop_address
- section
->vma
;
2240 if (stop_offset
> datasize
/ opb
)
2241 stop_offset
= datasize
/ opb
;
2246 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
2247 if (strlen (buf
) >= sizeof (buf
))
2251 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2253 count
= strlen (buf
) - count
;
2257 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
2258 if (strlen (buf
) >= sizeof (buf
))
2262 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
2264 count
= strlen (buf
) - count
;
2268 for (addr_offset
= start_offset
;
2269 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2273 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
2274 count
= strlen (buf
);
2275 if ((size_t) count
>= sizeof (buf
))
2279 while (count
< width
)
2284 fputs (buf
+ count
- width
, stdout
);
2287 for (j
= addr_offset
* opb
;
2288 j
< addr_offset
* opb
+ onaline
; j
++)
2290 if (j
< stop_offset
* opb
)
2291 printf ("%02x", (unsigned) (data
[j
]));
2299 for (j
= addr_offset
* opb
;
2300 j
< addr_offset
* opb
+ onaline
; j
++)
2302 if (j
>= stop_offset
* opb
)
2305 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2312 /* Actually display the various requested regions. */
2315 dump_data (bfd
*abfd
)
2317 bfd_map_over_sections (abfd
, dump_section
, NULL
);
2320 /* Should perhaps share code and display with nm? */
2323 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
2333 printf ("DYNAMIC SYMBOL TABLE:\n");
2339 printf ("SYMBOL TABLE:\n");
2343 printf (_("no symbols\n"));
2345 for (count
= 0; count
< max
; count
++)
2349 if (*current
== NULL
)
2350 printf (_("no information for symbol number %ld\n"), count
);
2352 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
2353 printf (_("could not determine the type of symbol number %ld\n"),
2356 else if (process_section_p ((* current
)->section
)
2357 && (dump_special_syms
2358 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
2360 const char *name
= (*current
)->name
;
2362 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2366 /* If we want to demangle the name, we demangle it
2367 here, and temporarily clobber it while calling
2368 bfd_print_symbol. FIXME: This is a gross hack. */
2369 alloc
= demangle (cur_bfd
, name
);
2370 (*current
)->name
= alloc
;
2371 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2372 bfd_print_symbol_all
);
2373 (*current
)->name
= name
;
2377 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2378 bfd_print_symbol_all
);
2388 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
2391 char *last_filename
, *last_functionname
;
2392 unsigned int last_line
;
2394 /* Get column headers lined up reasonably. */
2402 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2403 width
= strlen (buf
) - 7;
2405 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2408 last_filename
= NULL
;
2409 last_functionname
= NULL
;
2412 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
2415 const char *filename
, *functionname
;
2417 const char *sym_name
;
2418 const char *section_name
;
2420 if (start_address
!= (bfd_vma
) -1
2421 && q
->address
< start_address
)
2423 if (stop_address
!= (bfd_vma
) -1
2424 && q
->address
> stop_address
)
2427 if (with_line_numbers
2429 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2430 &filename
, &functionname
, &line
))
2432 if (functionname
!= NULL
2433 && (last_functionname
== NULL
2434 || strcmp (functionname
, last_functionname
) != 0))
2436 printf ("%s():\n", functionname
);
2437 if (last_functionname
!= NULL
)
2438 free (last_functionname
);
2439 last_functionname
= xstrdup (functionname
);
2443 && (line
!= last_line
2444 || (filename
!= NULL
2445 && last_filename
!= NULL
2446 && strcmp (filename
, last_filename
) != 0)))
2448 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2450 if (last_filename
!= NULL
)
2451 free (last_filename
);
2452 if (filename
== NULL
)
2453 last_filename
= NULL
;
2455 last_filename
= xstrdup (filename
);
2459 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2461 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2462 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2467 section_name
= NULL
;
2470 bfd_printf_vma (abfd
, q
->address
);
2471 if (q
->howto
== NULL
)
2472 printf (" *unknown* ");
2473 else if (q
->howto
->name
)
2474 printf (" %-16s ", q
->howto
->name
);
2476 printf (" %-16d ", q
->howto
->type
);
2478 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
2481 if (section_name
== NULL
)
2482 section_name
= "*unknown*";
2483 printf ("[%s]", section_name
);
2489 bfd_printf_vma (abfd
, q
->addend
);
2497 dump_relocs_in_section (bfd
*abfd
,
2499 void *dummy ATTRIBUTE_UNUSED
)
2505 if ( bfd_is_abs_section (section
)
2506 || bfd_is_und_section (section
)
2507 || bfd_is_com_section (section
)
2508 || (! process_section_p (section
))
2509 || ((section
->flags
& SEC_RELOC
) == 0))
2512 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2514 bfd_fatal (bfd_get_filename (abfd
));
2516 printf ("RELOCATION RECORDS FOR [%s]:", section
->name
);
2520 printf (" (none)\n\n");
2524 relpp
= xmalloc (relsize
);
2525 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
2528 bfd_fatal (bfd_get_filename (abfd
));
2529 else if (relcount
== 0)
2530 printf (" (none)\n\n");
2534 dump_reloc_set (abfd
, section
, relpp
, relcount
);
2541 dump_relocs (bfd
*abfd
)
2543 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
2547 dump_dynamic_relocs (bfd
*abfd
)
2553 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2555 bfd_fatal (bfd_get_filename (abfd
));
2557 printf ("DYNAMIC RELOCATION RECORDS");
2560 printf (" (none)\n\n");
2563 relpp
= xmalloc (relsize
);
2564 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2567 bfd_fatal (bfd_get_filename (abfd
));
2568 else if (relcount
== 0)
2569 printf (" (none)\n\n");
2573 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
2580 /* Creates a table of paths, to search for source files. */
2583 add_include_path (const char *path
)
2587 include_path_count
++;
2588 include_paths
= xrealloc (include_paths
,
2589 include_path_count
* sizeof (*include_paths
));
2590 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2591 if (path
[1] == ':' && path
[2] == 0)
2592 path
= concat (path
, ".", (const char *) 0);
2594 include_paths
[include_path_count
- 1] = path
;
2598 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
2602 if ((section
->flags
& SEC_DEBUGGING
) == 0)
2604 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
2605 section
->vma
+= adjust_section_vma
;
2607 section
->lma
+= adjust_section_vma
;
2611 /* Dump selected contents of ABFD. */
2614 dump_bfd (bfd
*abfd
)
2616 /* If we are adjusting section VMA's, change them all now. Changing
2617 the BFD information is a hack. However, we must do it, or
2618 bfd_find_nearest_line will not do the right thing. */
2619 if (adjust_section_vma
!= 0)
2621 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
2622 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
2625 if (! dump_debugging_tags
)
2626 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2629 print_arelt_descr (stdout
, abfd
, TRUE
);
2630 if (dump_file_header
)
2631 dump_bfd_header (abfd
);
2632 if (dump_private_headers
)
2633 dump_bfd_private_header (abfd
);
2634 if (! dump_debugging_tags
)
2636 if (dump_section_headers
)
2637 dump_headers (abfd
);
2639 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2640 syms
= slurp_symtab (abfd
);
2641 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
2642 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
2643 dynsyms
= slurp_dynamic_symtab (abfd
);
2646 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
2647 dynsymcount
, dynsyms
, &synthsyms
);
2653 dump_symbols (abfd
, FALSE
);
2654 if (dump_dynamic_symtab
)
2655 dump_symbols (abfd
, TRUE
);
2656 if (dump_stab_section_info
)
2658 if (dump_reloc_info
&& ! disassemble
)
2660 if (dump_dynamic_reloc_info
&& ! disassemble
)
2661 dump_dynamic_relocs (abfd
);
2662 if (dump_section_contents
)
2665 disassemble_data (abfd
);
2671 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2672 if (dhandle
!= NULL
)
2674 if (! print_debugging_info (stdout
, dhandle
, abfd
, syms
, demangle
,
2675 dump_debugging_tags
? TRUE
: FALSE
))
2677 non_fatal (_("%s: printing debugging information failed"),
2678 bfd_get_filename (abfd
));
2708 display_bfd (bfd
*abfd
)
2712 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2718 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2720 nonfatal (bfd_get_filename (abfd
));
2721 list_matching_formats (matching
);
2726 if (bfd_get_error () != bfd_error_file_not_recognized
)
2728 nonfatal (bfd_get_filename (abfd
));
2732 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2738 nonfatal (bfd_get_filename (abfd
));
2740 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2742 list_matching_formats (matching
);
2748 display_file (char *filename
, char *target
)
2753 if (get_file_size (filename
) < 1)
2756 file
= bfd_openr (filename
, target
);
2759 nonfatal (filename
);
2763 /* If the file is an archive, process all of its elements. */
2764 if (bfd_check_format (file
, bfd_archive
))
2766 bfd
*last_arfile
= NULL
;
2768 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2771 bfd_set_error (bfd_error_no_error
);
2773 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2776 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2777 nonfatal (bfd_get_filename (file
));
2781 display_bfd (arfile
);
2783 if (last_arfile
!= NULL
)
2784 bfd_close (last_arfile
);
2785 last_arfile
= arfile
;
2788 if (last_arfile
!= NULL
)
2789 bfd_close (last_arfile
);
2798 main (int argc
, char **argv
)
2801 char *target
= default_target
;
2802 bfd_boolean seenflag
= FALSE
;
2804 #if defined (HAVE_SETLOCALE)
2805 #if defined (HAVE_LC_MESSAGES)
2806 setlocale (LC_MESSAGES
, "");
2808 setlocale (LC_CTYPE
, "");
2811 bindtextdomain (PACKAGE
, LOCALEDIR
);
2812 textdomain (PACKAGE
);
2814 program_name
= *argv
;
2815 xmalloc_set_program_name (program_name
);
2817 START_PROGRESS (program_name
, 0);
2820 set_default_bfd_target ();
2822 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2823 long_options
, (int *) 0))
2829 break; /* We've been given a long option. */
2834 if (disassembler_options
)
2835 /* Ignore potential memory leak for now. */
2836 disassembler_options
= concat (disassembler_options
, ",",
2839 disassembler_options
= optarg
;
2842 if (only_used
== only_size
)
2845 only
= xrealloc (only
, only_size
* sizeof (char *));
2847 only
[only_used
++] = optarg
;
2850 with_line_numbers
= TRUE
;
2859 enum demangling_styles style
;
2861 style
= cplus_demangle_name_to_style (optarg
);
2862 if (style
== unknown_demangling
)
2863 fatal (_("unknown demangling style `%s'"),
2866 cplus_demangle_set_style (style
);
2872 case OPTION_ADJUST_VMA
:
2873 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2875 case OPTION_START_ADDRESS
:
2876 start_address
= parse_vma (optarg
, "--start-address");
2878 case OPTION_STOP_ADDRESS
:
2879 stop_address
= parse_vma (optarg
, "--stop-address");
2882 if (strcmp (optarg
, "B") == 0)
2883 endian
= BFD_ENDIAN_BIG
;
2884 else if (strcmp (optarg
, "L") == 0)
2885 endian
= BFD_ENDIAN_LITTLE
;
2888 non_fatal (_("unrecognized -E option"));
2893 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2894 endian
= BFD_ENDIAN_BIG
;
2895 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2896 endian
= BFD_ENDIAN_LITTLE
;
2899 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2905 dump_file_header
= TRUE
;
2909 formats_info
= TRUE
;
2913 add_include_path (optarg
);
2916 dump_private_headers
= TRUE
;
2920 dump_private_headers
= TRUE
;
2922 dump_reloc_info
= TRUE
;
2923 dump_file_header
= TRUE
;
2924 dump_ar_hdrs
= TRUE
;
2925 dump_section_headers
= TRUE
;
2933 dump_dynamic_symtab
= TRUE
;
2941 disassemble_zeroes
= TRUE
;
2945 disassemble_all
= TRUE
;
2950 with_source_code
= TRUE
;
2959 dump_debugging_tags
= 1;
2964 dump_stab_section_info
= TRUE
;
2968 dump_section_contents
= TRUE
;
2972 dump_reloc_info
= TRUE
;
2976 dump_dynamic_reloc_info
= TRUE
;
2980 dump_ar_hdrs
= TRUE
;
2984 dump_section_headers
= TRUE
;
2992 show_version
= TRUE
;
3002 print_version ("objdump");
3008 exit_status
= display_info ();
3012 display_file ("a.out", target
);
3014 for (; optind
< argc
;)
3015 display_file (argv
[optind
++], target
);
3018 END_PROGRESS (program_name
);