1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "safe-ctype.h"
30 #include "libiberty.h"
35 /* Internal headers for the ELF .stab-dump code - sorry. */
36 #define BYTES_IN_WORD 32
37 #include "aout/aout64.h"
39 #ifdef NEED_DECLARATION_FPRINTF
40 /* This is needed by INIT_DISASSEMBLE_INFO. */
42 PARAMS ((FILE *, const char *, ...));
46 static int exit_status
= 0;
48 static char *default_target
= NULL
; /* Default at runtime. */
50 static int show_version
= 0; /* Show the version number. */
51 static int dump_section_contents
; /* -s */
52 static int dump_section_headers
; /* -h */
53 static bfd_boolean dump_file_header
; /* -f */
54 static int dump_symtab
; /* -t */
55 static int dump_dynamic_symtab
; /* -T */
56 static int dump_reloc_info
; /* -r */
57 static int dump_dynamic_reloc_info
; /* -R */
58 static int dump_ar_hdrs
; /* -a */
59 static int dump_private_headers
; /* -p */
60 static int prefix_addresses
; /* --prefix-addresses */
61 static int with_line_numbers
; /* -l */
62 static bfd_boolean with_source_code
; /* -S */
63 static int show_raw_insn
; /* --show-raw-insn */
64 static int dump_stab_section_info
; /* --stabs */
65 static int do_demangle
; /* -C, --demangle */
66 static bfd_boolean disassemble
; /* -d */
67 static bfd_boolean disassemble_all
; /* -D */
68 static int disassemble_zeroes
; /* --disassemble-zeroes */
69 static bfd_boolean formats_info
; /* -i */
70 static char *only
; /* -j secname */
71 static int wide_output
; /* -w */
72 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
73 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
74 static int dump_debugging
; /* --debugging */
75 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
76 static int file_start_context
= 0; /* --file-start-context */
78 /* Extra info to pass to the disassembler address printing function. */
79 struct objdump_disasm_info
83 bfd_boolean require_sec
;
86 /* Architecture to disassemble for, or default if NULL. */
87 static char *machine
= (char *) NULL
;
89 /* Target specific options to the disassembler. */
90 static char *disassembler_options
= (char *) NULL
;
92 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
93 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
95 /* The symbol table. */
96 static asymbol
**syms
;
98 /* Number of symbols in `syms'. */
99 static long symcount
= 0;
101 /* The sorted symbol table. */
102 static asymbol
**sorted_syms
;
104 /* Number of symbols in `sorted_syms'. */
105 static long sorted_symcount
= 0;
107 /* The dynamic symbol table. */
108 static asymbol
**dynsyms
;
110 /* Number of symbols in `dynsyms'. */
111 static long dynsymcount
= 0;
113 static bfd_byte
*stabs
;
114 static bfd_size_type stab_size
;
117 static bfd_size_type stabstr_size
;
119 /* Static declarations. */
122 PARAMS ((FILE *, int));
124 PARAMS ((const char *));
125 static void display_file
126 PARAMS ((char *filename
, char *target
));
127 static void dump_section_header
128 PARAMS ((bfd
*, asection
*, PTR
));
129 static void dump_headers
131 static void dump_data
132 PARAMS ((bfd
*abfd
));
133 static void dump_relocs
134 PARAMS ((bfd
*abfd
));
135 static void dump_dynamic_relocs
136 PARAMS ((bfd
* abfd
));
137 static void dump_reloc_set
138 PARAMS ((bfd
*, asection
*, arelent
**, long));
139 static void dump_symbols
140 PARAMS ((bfd
*abfd
, bfd_boolean dynamic
));
141 static void dump_bfd_header
143 static void dump_bfd_private_header
147 static void display_bfd
148 PARAMS ((bfd
*abfd
));
149 static void display_target_list
151 static void display_info_table
153 static void display_target_tables
155 static void display_info
157 static void objdump_print_value
158 PARAMS ((bfd_vma
, struct disassemble_info
*, bfd_boolean
));
159 static void objdump_print_symname
160 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
161 static asymbol
*find_symbol_for_address
162 PARAMS ((bfd
*, asection
*, bfd_vma
, bfd_boolean
, long *));
163 static void objdump_print_addr_with_sym
164 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
165 struct disassemble_info
*, bfd_boolean
));
166 static void objdump_print_addr
167 PARAMS ((bfd_vma
, struct disassemble_info
*, bfd_boolean
));
168 static void objdump_print_address
169 PARAMS ((bfd_vma
, struct disassemble_info
*));
170 static int objdump_symbol_at_address
171 PARAMS ((bfd_vma
, struct disassemble_info
*));
172 static void show_line
173 PARAMS ((bfd
*, asection
*, bfd_vma
));
174 static void disassemble_bytes
175 PARAMS ((struct disassemble_info
*, disassembler_ftype
, bfd_boolean
,
176 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
177 static void disassemble_data
179 static const char *endian_string
180 PARAMS ((enum bfd_endian
));
181 static asymbol
** slurp_symtab
183 static asymbol
** slurp_dynamic_symtab
185 static long remove_useless_symbols
186 PARAMS ((asymbol
**, long));
187 static int compare_symbols
188 PARAMS ((const PTR
, const PTR
));
189 static int compare_relocs
190 PARAMS ((const PTR
, const PTR
));
191 static void dump_stabs
193 static bfd_boolean read_section_stabs
194 PARAMS ((bfd
*, const char *, const char *));
195 static void print_section_stabs
196 PARAMS ((bfd
*, const char *, const char *));
197 static void dump_section_stabs
198 PARAMS ((bfd
*, char *, char *));
201 usage (stream
, status
)
205 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
206 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
207 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
208 fprintf (stream
, _("\
209 -a, --archive-headers Display archive header information\n\
210 -f, --file-headers Display the contents of the overall file header\n\
211 -p, --private-headers Display object format specific file header contents\n\
212 -h, --[section-]headers Display the contents of the section headers\n\
213 -x, --all-headers Display the contents of all headers\n\
214 -d, --disassemble Display assembler contents of executable sections\n\
215 -D, --disassemble-all Display assembler contents of all sections\n\
216 -S, --source Intermix source code with disassembly\n\
217 -s, --full-contents Display the full contents of all sections requested\n\
218 -g, --debugging Display debug information in object file\n\
219 -G, --stabs Display (in raw form) any STABS info in the file\n\
220 -t, --syms Display the contents of the symbol table(s)\n\
221 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
222 -r, --reloc Display the relocation entries in the file\n\
223 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
224 -v, --version Display this program's version number\n\
225 -i, --info List object formats and architectures supported\n\
226 -H, --help Display this information\n\
230 fprintf (stream
, _("\n The following switches are optional:\n"));
231 fprintf (stream
, _("\
232 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
233 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
234 -j, --section=NAME Only display information for section NAME\n\
235 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
236 -EB --endian=big Assume big endian format when disassembling\n\
237 -EL --endian=little Assume little endian format when disassembling\n\
238 --file-start-context Include context from start of file (with -S)\n\
239 -l, --line-numbers Include line numbers and filenames in output\n\
240 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
241 The STYLE, if specified, can be `auto', `gnu',\n\
242 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
244 -w, --wide Format output for more than 80 columns\n\
245 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
246 --start-address=ADDR Only process data whose address is >= ADDR\n\
247 --stop-address=ADDR Only process data whose address is <= ADDR\n\
248 --prefix-addresses Print complete address alongside disassembly\n\
249 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
250 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
252 list_supported_targets (program_name
, stream
);
253 list_supported_architectures (program_name
, stream
);
255 disassembler_usage (stream
);
258 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
262 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
264 #define OPTION_ENDIAN (150)
265 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
266 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
267 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
269 static struct option long_options
[]=
271 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
272 {"all-headers", no_argument
, NULL
, 'x'},
273 {"private-headers", no_argument
, NULL
, 'p'},
274 {"architecture", required_argument
, NULL
, 'm'},
275 {"archive-headers", no_argument
, NULL
, 'a'},
276 {"debugging", no_argument
, NULL
, 'g'},
277 {"demangle", optional_argument
, NULL
, 'C'},
278 {"disassemble", no_argument
, NULL
, 'd'},
279 {"disassemble-all", no_argument
, NULL
, 'D'},
280 {"disassembler-options", required_argument
, NULL
, 'M'},
281 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
282 {"dynamic-reloc", no_argument
, NULL
, 'R'},
283 {"dynamic-syms", no_argument
, NULL
, 'T'},
284 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
285 {"file-headers", no_argument
, NULL
, 'f'},
286 {"file-start-context", no_argument
, &file_start_context
, 1},
287 {"full-contents", no_argument
, NULL
, 's'},
288 {"headers", no_argument
, NULL
, 'h'},
289 {"help", no_argument
, NULL
, 'H'},
290 {"info", no_argument
, NULL
, 'i'},
291 {"line-numbers", no_argument
, NULL
, 'l'},
292 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
293 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
294 {"reloc", no_argument
, NULL
, 'r'},
295 {"section", required_argument
, NULL
, 'j'},
296 {"section-headers", no_argument
, NULL
, 'h'},
297 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
298 {"source", no_argument
, NULL
, 'S'},
299 {"stabs", no_argument
, NULL
, 'G'},
300 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
301 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
302 {"syms", no_argument
, NULL
, 't'},
303 {"target", required_argument
, NULL
, 'b'},
304 {"version", no_argument
, NULL
, 'V'},
305 {"wide", no_argument
, NULL
, 'w'},
306 {0, no_argument
, 0, 0}
318 dump_section_header (abfd
, section
, ignored
)
319 bfd
*abfd ATTRIBUTE_UNUSED
;
321 PTR ignored ATTRIBUTE_UNUSED
;
324 unsigned int opb
= bfd_octets_per_byte (abfd
);
326 printf ("%3d %-13s %08lx ", section
->index
,
327 bfd_get_section_name (abfd
, section
),
328 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
329 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
331 bfd_printf_vma (abfd
, section
->lma
);
332 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
333 bfd_get_section_alignment (abfd
, section
));
339 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
341 PF (SEC_HAS_CONTENTS
, "CONTENTS");
342 PF (SEC_ALLOC
, "ALLOC");
343 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
344 PF (SEC_LOAD
, "LOAD");
345 PF (SEC_RELOC
, "RELOC");
346 PF (SEC_READONLY
, "READONLY");
347 PF (SEC_CODE
, "CODE");
348 PF (SEC_DATA
, "DATA");
350 PF (SEC_DEBUGGING
, "DEBUGGING");
351 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
352 PF (SEC_EXCLUDE
, "EXCLUDE");
353 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
354 PF (SEC_BLOCK
, "BLOCK");
355 PF (SEC_CLINK
, "CLINK");
356 PF (SEC_SMALL_DATA
, "SMALL_DATA");
357 PF (SEC_SHARED
, "SHARED");
358 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
359 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
361 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
365 switch (section
->flags
& SEC_LINK_DUPLICATES
)
369 case SEC_LINK_DUPLICATES_DISCARD
:
370 ls
= "LINK_ONCE_DISCARD";
372 case SEC_LINK_DUPLICATES_ONE_ONLY
:
373 ls
= "LINK_ONCE_ONE_ONLY";
375 case SEC_LINK_DUPLICATES_SAME_SIZE
:
376 ls
= "LINK_ONCE_SAME_SIZE";
378 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
379 ls
= "LINK_ONCE_SAME_CONTENTS";
382 printf ("%s%s", comma
, ls
);
384 if (section
->comdat
!= NULL
)
385 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
386 section
->comdat
->symbol
);
399 printf (_("Sections:\n"));
402 printf (_("Idx Name Size VMA LMA File off Algn"));
404 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
405 if (bfd_get_arch_size (abfd
) == 32)
406 printf (_("Idx Name Size VMA LMA File off Algn"));
408 printf (_("Idx Name Size VMA LMA File off Algn"));
412 printf (_(" Flags"));
413 if (abfd
->flags
& HAS_LOAD_PAGE
)
417 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
424 asymbol
**sy
= (asymbol
**) NULL
;
427 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
433 storage
= bfd_get_symtab_upper_bound (abfd
);
435 bfd_fatal (bfd_get_filename (abfd
));
437 sy
= (asymbol
**) xmalloc (storage
);
439 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
441 bfd_fatal (bfd_get_filename (abfd
));
445 /* Read in the dynamic symbols. */
448 slurp_dynamic_symtab (abfd
)
451 asymbol
**sy
= (asymbol
**) NULL
;
454 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
457 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
459 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
464 bfd_fatal (bfd_get_filename (abfd
));
467 sy
= (asymbol
**) xmalloc (storage
);
469 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
471 bfd_fatal (bfd_get_filename (abfd
));
475 /* Filter out (in place) symbols that are useless for disassembly.
476 COUNT is the number of elements in SYMBOLS.
477 Return the number of useful symbols. */
480 remove_useless_symbols (symbols
, count
)
484 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
488 asymbol
*sym
= *in_ptr
++;
490 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
492 if (sym
->flags
& (BSF_DEBUGGING
))
494 if (bfd_is_und_section (sym
->section
)
495 || bfd_is_com_section (sym
->section
))
500 return out_ptr
- symbols
;
503 /* Sort symbols into value order. */
506 compare_symbols (ap
, bp
)
510 const asymbol
*a
= *(const asymbol
**)ap
;
511 const asymbol
*b
= *(const asymbol
**)bp
;
515 flagword aflags
, bflags
;
517 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
519 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
522 if (a
->section
> b
->section
)
524 else if (a
->section
< b
->section
)
527 an
= bfd_asymbol_name (a
);
528 bn
= bfd_asymbol_name (b
);
532 /* The symbols gnu_compiled and gcc2_compiled convey no real
533 information, so put them after other symbols with the same value. */
534 af
= (strstr (an
, "gnu_compiled") != NULL
535 || strstr (an
, "gcc2_compiled") != NULL
);
536 bf
= (strstr (bn
, "gnu_compiled") != NULL
537 || strstr (bn
, "gcc2_compiled") != NULL
);
544 /* We use a heuristic for the file name, to try to sort it after
545 more useful symbols. It may not work on non Unix systems, but it
546 doesn't really matter; the only difference is precisely which
547 symbol names get printed. */
549 #define file_symbol(s, sn, snl) \
550 (((s)->flags & BSF_FILE) != 0 \
551 || ((sn)[(snl) - 2] == '.' \
552 && ((sn)[(snl) - 1] == 'o' \
553 || (sn)[(snl) - 1] == 'a')))
555 af
= file_symbol (a
, an
, anl
);
556 bf
= file_symbol (b
, bn
, bnl
);
563 /* Try to sort global symbols before local symbols before function
564 symbols before debugging symbols. */
569 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
571 if ((aflags
& BSF_DEBUGGING
) != 0)
576 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
578 if ((aflags
& BSF_FUNCTION
) != 0)
583 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
585 if ((aflags
& BSF_LOCAL
) != 0)
590 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
592 if ((aflags
& BSF_GLOBAL
) != 0)
598 /* Symbols that start with '.' might be section names, so sort them
599 after symbols that don't start with '.'. */
600 if (an
[0] == '.' && bn
[0] != '.')
602 if (an
[0] != '.' && bn
[0] == '.')
605 /* Finally, if we can't distinguish them in any other way, try to
606 get consistent results by sorting the symbols by name. */
607 return strcmp (an
, bn
);
610 /* Sort relocs into address order. */
613 compare_relocs (ap
, bp
)
617 const arelent
*a
= *(const arelent
**)ap
;
618 const arelent
*b
= *(const arelent
**)bp
;
620 if (a
->address
> b
->address
)
622 else if (a
->address
< b
->address
)
625 /* So that associated relocations tied to the same address show up
626 in the correct order, we don't do any further sorting. */
635 /* Print VMA to STREAM. If SKIP_ZEROES is TRUE, omit leading zeroes. */
638 objdump_print_value (vma
, info
, skip_zeroes
)
640 struct disassemble_info
*info
;
641 bfd_boolean skip_zeroes
;
645 struct objdump_disasm_info
*aux
646 = (struct objdump_disasm_info
*) info
->application_data
;
648 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
653 for (p
= buf
; *p
== '0'; ++p
)
658 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
661 /* Print the name of a symbol. */
664 objdump_print_symname (abfd
, info
, sym
)
666 struct disassemble_info
*info
;
673 name
= bfd_asymbol_name (sym
);
674 if (do_demangle
&& name
[0] != '\0')
676 /* Demangle the name. */
677 alloc
= demangle (abfd
, name
);
682 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
690 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
691 is TRUE, then always require the symbol to be in the section. This
692 returns NULL if there is no suitable symbol. If PLACE is not NULL,
693 then *PLACE is set to the index of the symbol in sorted_syms. */
696 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
700 bfd_boolean require_sec
;
703 /* @@ Would it speed things up to cache the last two symbols returned,
704 and maybe their address ranges? For many processors, only one memory
705 operand can be present at a time, so the 2-entry cache wouldn't be
706 constantly churned by code doing heavy memory accesses. */
708 /* Indices in `sorted_syms'. */
710 long max
= sorted_symcount
;
712 unsigned int opb
= bfd_octets_per_byte (abfd
);
714 if (sorted_symcount
< 1)
717 /* Perform a binary search looking for the closest symbol to the
718 required value. We are searching the range (min, max]. */
719 while (min
+ 1 < max
)
723 thisplace
= (max
+ min
) / 2;
724 sym
= sorted_syms
[thisplace
];
726 if (bfd_asymbol_value (sym
) > vma
)
728 else if (bfd_asymbol_value (sym
) < vma
)
737 /* The symbol we want is now in min, the low end of the range we
738 were searching. If there are several symbols with the same
739 value, we want the first one. */
742 && (bfd_asymbol_value (sorted_syms
[thisplace
])
743 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
746 /* If the file is relocateable, and the symbol could be from this
747 section, prefer a symbol from this section over symbols from
748 others, even if the other symbol's value might be closer.
750 Note that this may be wrong for some symbol references if the
751 sections have overlapping memory ranges, but in that case there's
752 no way to tell what's desired without looking at the relocation
754 if (sorted_syms
[thisplace
]->section
!= sec
756 || ((abfd
->flags
& HAS_RELOC
) != 0
757 && vma
>= bfd_get_section_vma (abfd
, sec
)
758 && vma
< (bfd_get_section_vma (abfd
, sec
)
759 + bfd_section_size (abfd
, sec
) / opb
))))
763 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
765 if (bfd_asymbol_value (sorted_syms
[i
])
766 != bfd_asymbol_value (sorted_syms
[thisplace
]))
774 if (sorted_syms
[i
]->section
== sec
776 || sorted_syms
[i
- 1]->section
!= sec
777 || (bfd_asymbol_value (sorted_syms
[i
])
778 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
785 if (sorted_syms
[thisplace
]->section
!= sec
)
787 /* We didn't find a good symbol with a smaller value.
788 Look for one with a larger value. */
789 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
791 if (sorted_syms
[i
]->section
== sec
)
799 if (sorted_syms
[thisplace
]->section
!= sec
801 || ((abfd
->flags
& HAS_RELOC
) != 0
802 && vma
>= bfd_get_section_vma (abfd
, sec
)
803 && vma
< (bfd_get_section_vma (abfd
, sec
)
804 + bfd_section_size (abfd
, sec
)))))
806 /* There is no suitable symbol. */
814 return sorted_syms
[thisplace
];
817 /* Print an address to INFO symbolically. */
820 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
825 struct disassemble_info
*info
;
826 bfd_boolean skip_zeroes
;
828 objdump_print_value (vma
, info
, skip_zeroes
);
834 (*info
->fprintf_func
) (info
->stream
, " <%s",
835 bfd_get_section_name (abfd
, sec
));
836 secaddr
= bfd_get_section_vma (abfd
, sec
);
839 (*info
->fprintf_func
) (info
->stream
, "-0x");
840 objdump_print_value (secaddr
- vma
, info
, TRUE
);
842 else if (vma
> secaddr
)
844 (*info
->fprintf_func
) (info
->stream
, "+0x");
845 objdump_print_value (vma
- secaddr
, info
, TRUE
);
847 (*info
->fprintf_func
) (info
->stream
, ">");
851 (*info
->fprintf_func
) (info
->stream
, " <");
852 objdump_print_symname (abfd
, info
, sym
);
853 if (bfd_asymbol_value (sym
) > vma
)
855 (*info
->fprintf_func
) (info
->stream
, "-0x");
856 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
858 else if (vma
> bfd_asymbol_value (sym
))
860 (*info
->fprintf_func
) (info
->stream
, "+0x");
861 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
863 (*info
->fprintf_func
) (info
->stream
, ">");
867 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
868 TRUE, don't output leading zeroes. */
871 objdump_print_addr (vma
, info
, skip_zeroes
)
873 struct disassemble_info
*info
;
874 bfd_boolean skip_zeroes
;
876 struct objdump_disasm_info
*aux
;
879 if (sorted_symcount
< 1)
881 (*info
->fprintf_func
) (info
->stream
, "0x");
882 objdump_print_value (vma
, info
, skip_zeroes
);
886 aux
= (struct objdump_disasm_info
*) info
->application_data
;
887 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
889 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
893 /* Print VMA to INFO. This function is passed to the disassembler
897 objdump_print_address (vma
, info
)
899 struct disassemble_info
*info
;
901 objdump_print_addr (vma
, info
, ! prefix_addresses
);
904 /* Determine of the given address has a symbol associated with it. */
907 objdump_symbol_at_address (vma
, info
)
909 struct disassemble_info
* info
;
911 struct objdump_disasm_info
* aux
;
914 /* No symbols - do not bother checking. */
915 if (sorted_symcount
< 1)
918 aux
= (struct objdump_disasm_info
*) info
->application_data
;
919 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
922 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
925 /* Hold the last function name and the last line number we displayed
928 static char *prev_functionname
;
929 static unsigned int prev_line
;
931 /* We keep a list of all files that we have seen when doing a
932 dissassembly with source, so that we know how much of the file to
933 display. This can be important for inlined functions. */
935 struct print_file_list
937 struct print_file_list
*next
;
943 static struct print_file_list
*print_files
;
945 /* The number of preceding context lines to show when we start
946 displaying a file for the first time. */
948 #define SHOW_PRECEDING_CONTEXT_LINES (5)
950 /* Skip ahead to a given line in a file, optionally printing each
953 static void skip_to_line
954 PARAMS ((struct print_file_list
*, unsigned int, bfd_boolean
));
957 skip_to_line (p
, line
, show
)
958 struct print_file_list
*p
;
962 while (p
->line
< line
)
966 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
976 if (strchr (buf
, '\n') != NULL
)
981 /* Show the line number, or the source line, in a dissassembly
985 show_line (abfd
, section
, addr_offset
)
990 const char *filename
;
991 const char *functionname
;
994 if (! with_line_numbers
&& ! with_source_code
)
997 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
998 &functionname
, &line
))
1001 if (filename
!= NULL
&& *filename
== '\0')
1003 if (functionname
!= NULL
&& *functionname
== '\0')
1004 functionname
= NULL
;
1006 if (with_line_numbers
)
1008 if (functionname
!= NULL
1009 && (prev_functionname
== NULL
1010 || strcmp (functionname
, prev_functionname
) != 0))
1011 printf ("%s():\n", functionname
);
1012 if (line
> 0 && line
!= prev_line
)
1013 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1016 if (with_source_code
1020 struct print_file_list
**pp
, *p
;
1022 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1023 if (strcmp ((*pp
)->filename
, filename
) == 0)
1029 if (p
!= print_files
)
1033 /* We have reencountered a file name which we saw
1034 earlier. This implies that either we are dumping out
1035 code from an included file, or the same file was
1036 linked in more than once. There are two common cases
1037 of an included file: inline functions in a header
1038 file, and a bison or flex skeleton file. In the
1039 former case we want to just start printing (but we
1040 back up a few lines to give context); in the latter
1041 case we want to continue from where we left off. I
1042 can't think of a good way to distinguish the cases,
1043 so I used a heuristic based on the file name. */
1044 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1048 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1055 p
->f
= fopen (p
->filename
, "r");
1059 skip_to_line (p
, l
, FALSE
);
1061 if (print_files
->f
!= NULL
)
1063 fclose (print_files
->f
);
1064 print_files
->f
= NULL
;
1070 skip_to_line (p
, line
, TRUE
);
1072 p
->next
= print_files
;
1080 f
= fopen (filename
, "r");
1085 p
= ((struct print_file_list
*)
1086 xmalloc (sizeof (struct print_file_list
)));
1087 p
->filename
= xmalloc (strlen (filename
) + 1);
1088 strcpy (p
->filename
, filename
);
1092 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1094 fclose (print_files
->f
);
1095 print_files
->f
= NULL
;
1097 p
->next
= print_files
;
1100 if (file_start_context
)
1103 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1106 skip_to_line (p
, l
, FALSE
);
1108 skip_to_line (p
, line
, TRUE
);
1113 if (functionname
!= NULL
1114 && (prev_functionname
== NULL
1115 || strcmp (functionname
, prev_functionname
) != 0))
1117 if (prev_functionname
!= NULL
)
1118 free (prev_functionname
);
1119 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1120 strcpy (prev_functionname
, functionname
);
1123 if (line
> 0 && line
!= prev_line
)
1127 /* Pseudo FILE object for strings. */
1135 /* sprintf to a "stream" */
1138 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1143 VA_OPEN (args
, format
);
1144 VA_FIXEDARG (args
, SFILE
*, f
);
1145 VA_FIXEDARG (args
, const char *, format
);
1147 vasprintf (&buf
, format
, args
);
1152 fatal (_("Out of virtual memory"));
1157 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1161 curroff
= f
->current
- f
->buffer
;
1163 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1164 f
->current
= f
->buffer
+ curroff
;
1167 memcpy (f
->current
, buf
, n
);
1169 f
->current
[0] = '\0';
1177 /* The number of zeroes we want to see before we start skipping them.
1178 The number is arbitrarily chosen. */
1181 #define SKIP_ZEROES (8)
1184 /* The number of zeroes to skip at the end of a section. If the
1185 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1186 SKIP_ZEROES, they will be disassembled. If there are fewer than
1187 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1188 attempt to avoid disassembling zeroes inserted by section
1191 #ifndef SKIP_ZEROES_AT_END
1192 #define SKIP_ZEROES_AT_END (3)
1195 /* Disassemble some data in memory between given values. */
1198 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1199 start_offset
, stop_offset
, relppp
,
1201 struct disassemble_info
*info
;
1202 disassembler_ftype disassemble_fn
;
1205 bfd_vma start_offset
;
1206 bfd_vma stop_offset
;
1210 struct objdump_disasm_info
*aux
;
1212 int octets_per_line
;
1213 bfd_boolean done_dot
;
1214 int skip_addr_chars
;
1215 bfd_vma addr_offset
;
1216 int opb
= info
->octets_per_byte
;
1218 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1222 octets_per_line
= 4;
1224 octets_per_line
= 16;
1226 /* Figure out how many characters to skip at the start of an
1227 address, to make the disassembly look nicer. We discard leading
1228 zeroes in chunks of 4, ensuring that there is always a leading
1230 skip_addr_chars
= 0;
1231 if (! prefix_addresses
)
1239 + bfd_section_size (section
->owner
, section
) / opb
));
1241 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1244 skip_addr_chars
+= 4;
1249 info
->insn_info_valid
= 0;
1252 addr_offset
= start_offset
;
1253 while (addr_offset
< stop_offset
)
1257 bfd_boolean need_nl
= FALSE
;
1259 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1261 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1264 if (! disassemble_zeroes
1265 && (info
->insn_info_valid
== 0
1266 || info
->branch_delay_insns
== 0)
1267 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1268 || (z
== stop_offset
* opb
&&
1269 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1273 /* If there are more nonzero octets to follow, we only skip
1274 zeroes in multiples of 4, to try to avoid running over
1275 the start of an instruction which happens to start with
1277 if (z
!= stop_offset
* opb
)
1278 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1280 octets
= z
- addr_offset
* opb
;
1291 if (with_line_numbers
|| with_source_code
)
1292 /* The line number tables will refer to unadjusted
1293 section VMAs, so we must undo any VMA modifications
1294 when calling show_line. */
1295 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1297 if (! prefix_addresses
)
1301 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1302 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1306 printf ("%s:\t", buf
+ skip_addr_chars
);
1310 aux
->require_sec
= TRUE
;
1311 objdump_print_address (section
->vma
+ addr_offset
, info
);
1312 aux
->require_sec
= FALSE
;
1319 sfile
.buffer
= xmalloc (sfile
.size
);
1320 sfile
.current
= sfile
.buffer
;
1321 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1322 info
->stream
= (FILE *) &sfile
;
1323 info
->bytes_per_line
= 0;
1324 info
->bytes_per_chunk
= 0;
1326 #ifdef DISASSEMBLER_NEEDS_RELOCS
1327 /* FIXME: This is wrong. It tests the number of octets
1328 in the last instruction, not the current one. */
1329 if (*relppp
< relppend
1330 && (**relppp
)->address
>= addr_offset
1331 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1332 info
->flags
= INSN_HAS_RELOC
;
1337 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1338 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1339 info
->stream
= stdout
;
1340 if (info
->bytes_per_line
!= 0)
1341 octets_per_line
= info
->bytes_per_line
;
1344 if (sfile
.current
!= sfile
.buffer
)
1345 printf ("%s\n", sfile
.buffer
);
1346 free (sfile
.buffer
);
1354 octets
= octets_per_line
;
1355 if (addr_offset
+ octets
/ opb
> stop_offset
)
1356 octets
= (stop_offset
- addr_offset
) * opb
;
1358 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1360 if (ISPRINT (data
[j
]))
1361 buf
[j
- addr_offset
* opb
] = data
[j
];
1363 buf
[j
- addr_offset
* opb
] = '.';
1365 buf
[j
- addr_offset
* opb
] = '\0';
1368 if (prefix_addresses
1370 : show_raw_insn
>= 0)
1374 /* If ! prefix_addresses and ! wide_output, we print
1375 octets_per_line octets per line. */
1377 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1378 pb
= octets_per_line
;
1380 if (info
->bytes_per_chunk
)
1381 bpc
= info
->bytes_per_chunk
;
1385 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1388 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1390 for (k
= bpc
- 1; k
>= 0; k
--)
1391 printf ("%02x", (unsigned) data
[j
+ k
]);
1396 for (k
= 0; k
< bpc
; k
++)
1397 printf ("%02x", (unsigned) data
[j
+ k
]);
1402 for (; pb
< octets_per_line
; pb
+= bpc
)
1406 for (k
= 0; k
< bpc
; k
++)
1411 /* Separate raw data from instruction by extra space. */
1422 printf ("%s", sfile
.buffer
);
1423 free (sfile
.buffer
);
1426 if (prefix_addresses
1428 : show_raw_insn
>= 0)
1436 j
= addr_offset
* opb
+ pb
;
1438 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1439 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1443 printf ("%s:\t", buf
+ skip_addr_chars
);
1445 pb
+= octets_per_line
;
1448 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1452 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1454 for (k
= bpc
- 1; k
>= 0; k
--)
1455 printf ("%02x", (unsigned) data
[j
+ k
]);
1460 for (k
= 0; k
< bpc
; k
++)
1461 printf ("%02x", (unsigned) data
[j
+ k
]);
1474 if ((section
->flags
& SEC_RELOC
) != 0
1475 #ifndef DISASSEMBLER_NEEDS_RELOCS
1480 while ((*relppp
) < relppend
1481 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1482 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1483 #ifdef DISASSEMBLER_NEEDS_RELOCS
1484 if (! dump_reloc_info
)
1498 objdump_print_value (section
->vma
+ q
->address
, info
, TRUE
);
1500 printf (": %s\t", q
->howto
->name
);
1502 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1503 printf ("*unknown*");
1506 const char *sym_name
;
1508 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1509 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1510 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1515 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1516 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1517 if (sym_name
== NULL
|| *sym_name
== '\0')
1518 sym_name
= "*unknown*";
1519 printf ("%s", sym_name
);
1526 objdump_print_value (q
->addend
, info
, TRUE
);
1538 addr_offset
+= octets
/ opb
;
1542 /* Disassemble the contents of an object file. */
1545 disassemble_data (abfd
)
1548 unsigned long addr_offset
;
1549 disassembler_ftype disassemble_fn
;
1550 struct disassemble_info disasm_info
;
1551 struct objdump_disasm_info aux
;
1556 prev_functionname
= NULL
;
1559 /* We make a copy of syms to sort. We don't want to sort syms
1560 because that will screw up the relocs. */
1561 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1562 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1564 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1566 /* Sort the symbols into section and symbol order. */
1567 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1569 INIT_DISASSEMBLE_INFO (disasm_info
, stdout
, fprintf
);
1571 disasm_info
.application_data
= (PTR
) &aux
;
1573 aux
.require_sec
= FALSE
;
1574 disasm_info
.print_address_func
= objdump_print_address
;
1575 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1577 if (machine
!= (char *) NULL
)
1579 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1582 fatal (_("Can't use supplied machine %s"), machine
);
1584 abfd
->arch_info
= info
;
1587 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1589 struct bfd_target
*xvec
;
1591 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1592 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1593 xvec
->byteorder
= endian
;
1597 disassemble_fn
= disassembler (abfd
);
1598 if (!disassemble_fn
)
1600 non_fatal (_("Can't disassemble for architecture %s\n"),
1601 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1606 opb
= bfd_octets_per_byte (abfd
);
1608 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1609 disasm_info
.arch
= bfd_get_arch (abfd
);
1610 disasm_info
.mach
= bfd_get_mach (abfd
);
1611 disasm_info
.disassembler_options
= disassembler_options
;
1612 disasm_info
.octets_per_byte
= opb
;
1614 if (bfd_big_endian (abfd
))
1615 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1616 else if (bfd_little_endian (abfd
))
1617 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1619 /* ??? Aborting here seems too drastic. We could default to big or little
1621 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1623 for (section
= abfd
->sections
;
1624 section
!= (asection
*) NULL
;
1625 section
= section
->next
)
1627 bfd_byte
*data
= NULL
;
1628 bfd_size_type datasize
= 0;
1629 arelent
**relbuf
= NULL
;
1630 arelent
**relpp
= NULL
;
1631 arelent
**relppend
= NULL
;
1632 unsigned long stop_offset
;
1633 asymbol
*sym
= NULL
;
1636 if ((section
->flags
& SEC_LOAD
) == 0
1637 || (! disassemble_all
1639 && (section
->flags
& SEC_CODE
) == 0))
1641 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1644 if ((section
->flags
& SEC_RELOC
) != 0
1645 #ifndef DISASSEMBLER_NEEDS_RELOCS
1652 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1654 bfd_fatal (bfd_get_filename (abfd
));
1660 relbuf
= (arelent
**) xmalloc (relsize
);
1661 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1663 bfd_fatal (bfd_get_filename (abfd
));
1665 /* Sort the relocs by address. */
1666 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1669 relppend
= relpp
+ relcount
;
1671 /* Skip over the relocs belonging to addresses below the
1673 if (start_address
!= (bfd_vma
) -1)
1674 while (relpp
< relppend
1675 && (*relpp
)->address
< start_address
)
1680 printf (_("Disassembly of section %s:\n"), section
->name
);
1682 datasize
= bfd_get_section_size_before_reloc (section
);
1686 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1688 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1691 disasm_info
.buffer
= data
;
1692 disasm_info
.buffer_vma
= section
->vma
;
1693 disasm_info
.buffer_length
= datasize
;
1694 disasm_info
.section
= section
;
1696 if (start_address
== (bfd_vma
) -1
1697 || start_address
< disasm_info
.buffer_vma
)
1700 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1702 if (stop_address
== (bfd_vma
) -1)
1703 stop_offset
= datasize
/ opb
;
1706 if (stop_address
< disasm_info
.buffer_vma
)
1709 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1710 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1711 stop_offset
= disasm_info
.buffer_length
/ opb
;
1714 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1717 while (addr_offset
< stop_offset
)
1720 unsigned long nextstop_offset
;
1723 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1728 (x
< sorted_symcount
1729 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1733 disasm_info
.symbols
= & sorted_syms
[place
];
1734 disasm_info
.num_symbols
= x
- place
;
1737 disasm_info
.symbols
= NULL
;
1739 if (! prefix_addresses
)
1741 (* disasm_info
.fprintf_func
) (disasm_info
.stream
, "\n");
1742 objdump_print_addr_with_sym (abfd
, section
, sym
,
1743 section
->vma
+ addr_offset
,
1746 (* disasm_info
.fprintf_func
) (disasm_info
.stream
, ":\n");
1749 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1751 else if (sym
== NULL
)
1755 /* Search forward for the next appropriate symbol in
1756 SECTION. Note that all the symbols are sorted
1757 together into one big array, and that some sections
1758 may have overlapping addresses. */
1759 while (place
< sorted_symcount
1760 && (sorted_syms
[place
]->section
!= section
1761 || (bfd_asymbol_value (sorted_syms
[place
])
1762 <= bfd_asymbol_value (sym
))))
1764 if (place
>= sorted_symcount
)
1767 nextsym
= sorted_syms
[place
];
1770 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1772 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1773 if (nextstop_offset
> stop_offset
)
1774 nextstop_offset
= stop_offset
;
1776 else if (nextsym
== NULL
)
1777 nextstop_offset
= stop_offset
;
1780 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1781 if (nextstop_offset
> stop_offset
)
1782 nextstop_offset
= stop_offset
;
1785 /* If a symbol is explicitly marked as being an object
1786 rather than a function, just dump the bytes without
1787 disassembling them. */
1790 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1791 || ((sym
->flags
& BSF_OBJECT
) == 0
1792 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1794 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1796 || (sym
->flags
& BSF_FUNCTION
) != 0)
1801 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1802 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1804 addr_offset
= nextstop_offset
;
1816 /* Dump the stabs sections from an object file that has a section that
1817 uses Sun stabs encoding. */
1823 dump_section_stabs (abfd
, ".stab", ".stabstr");
1824 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1825 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1826 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1829 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1830 and string table section STRSECT_NAME into `strtab'.
1831 If the section exists and was read, allocate the space and return TRUE.
1832 Otherwise return FALSE. */
1835 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1837 const char *stabsect_name
;
1838 const char *strsect_name
;
1840 asection
*stabsect
, *stabstrsect
;
1842 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1845 printf (_("No %s section present\n\n"), stabsect_name
);
1849 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1850 if (0 == stabstrsect
)
1852 non_fatal (_("%s has no %s section"),
1853 bfd_get_filename (abfd
), strsect_name
);
1858 stab_size
= bfd_section_size (abfd
, stabsect
);
1859 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1861 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1862 strtab
= (char *) xmalloc (stabstr_size
);
1864 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1866 non_fatal (_("Reading %s section of %s failed: %s"),
1867 stabsect_name
, bfd_get_filename (abfd
),
1868 bfd_errmsg (bfd_get_error ()));
1875 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1878 non_fatal (_("Reading %s section of %s failed: %s\n"),
1879 strsect_name
, bfd_get_filename (abfd
),
1880 bfd_errmsg (bfd_get_error ()));
1890 /* Stabs entries use a 12 byte format:
1891 4 byte string table index
1893 1 byte stab other field
1894 2 byte stab desc field
1896 FIXME: This will have to change for a 64 bit object format. */
1898 #define STRDXOFF (0)
1900 #define OTHEROFF (5)
1903 #define STABSIZE (12)
1905 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1906 using string table section STRSECT_NAME (in `strtab'). */
1909 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1911 const char *stabsect_name
;
1912 const char *strsect_name ATTRIBUTE_UNUSED
;
1915 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1916 bfd_byte
*stabp
, *stabs_end
;
1919 stabs_end
= stabp
+ stab_size
;
1921 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1922 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1924 /* Loop through all symbols and print them.
1926 We start the index at -1 because there is a dummy symbol on
1927 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1928 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1932 unsigned char type
, other
;
1933 unsigned short desc
;
1936 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1937 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1938 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1939 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1940 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1942 printf ("\n%-6d ", i
);
1943 /* Either print the stab name, or, if unnamed, print its number
1944 again (makes consistent formatting for tools like awk). */
1945 name
= bfd_get_stab_name (type
);
1947 printf ("%-6s", name
);
1948 else if (type
== N_UNDF
)
1951 printf ("%-6d", type
);
1952 printf (" %-6d %-6d ", other
, desc
);
1953 bfd_printf_vma (abfd
, value
);
1954 printf (" %-6lu", strx
);
1956 /* Symbols with type == 0 (N_UNDF) specify the length of the
1957 string table associated with this file. We use that info
1958 to know how to relocate the *next* file's string table indices. */
1961 file_string_table_offset
= next_file_string_table_offset
;
1962 next_file_string_table_offset
+= value
;
1966 /* Using the (possibly updated) string table offset, print the
1967 string (if any) associated with this symbol. */
1968 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1969 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1978 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1980 char *stabsect_name
;
1985 /* Check for section names for which stabsect_name is a prefix, to
1986 handle .stab0, etc. */
1987 for (s
= abfd
->sections
;
1993 len
= strlen (stabsect_name
);
1995 /* If the prefix matches, and the files section name ends with a
1996 nul or a digit, then we match. I.e., we want either an exact
1997 match or a section followed by a number. */
1998 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1999 && (s
->name
[len
] == '\000'
2000 || ISDIGIT (s
->name
[len
])))
2002 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2004 print_section_stabs (abfd
, s
->name
, strsect_name
);
2014 dump_bfd_header (abfd
)
2019 printf (_("architecture: %s, "),
2020 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2021 bfd_get_mach (abfd
)));
2022 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2024 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2025 PF (HAS_RELOC
, "HAS_RELOC");
2026 PF (EXEC_P
, "EXEC_P");
2027 PF (HAS_LINENO
, "HAS_LINENO");
2028 PF (HAS_DEBUG
, "HAS_DEBUG");
2029 PF (HAS_SYMS
, "HAS_SYMS");
2030 PF (HAS_LOCALS
, "HAS_LOCALS");
2031 PF (DYNAMIC
, "DYNAMIC");
2032 PF (WP_TEXT
, "WP_TEXT");
2033 PF (D_PAGED
, "D_PAGED");
2034 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2035 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2036 printf (_("\nstart address 0x"));
2037 bfd_printf_vma (abfd
, abfd
->start_address
);
2043 dump_bfd_private_header (abfd
)
2046 bfd_print_private_bfd_data (abfd
, stdout
);
2049 /* Dump selected contents of ABFD. */
2055 /* If we are adjusting section VMA's, change them all now. Changing
2056 the BFD information is a hack. However, we must do it, or
2057 bfd_find_nearest_line will not do the right thing. */
2058 if (adjust_section_vma
!= 0)
2062 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2064 s
->vma
+= adjust_section_vma
;
2065 s
->lma
+= adjust_section_vma
;
2069 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2072 print_arelt_descr (stdout
, abfd
, TRUE
);
2073 if (dump_file_header
)
2074 dump_bfd_header (abfd
);
2075 if (dump_private_headers
)
2076 dump_bfd_private_header (abfd
);
2078 if (dump_section_headers
)
2079 dump_headers (abfd
);
2081 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2082 syms
= slurp_symtab (abfd
);
2083 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2084 dynsyms
= slurp_dynamic_symtab (abfd
);
2087 dump_symbols (abfd
, FALSE
);
2088 if (dump_dynamic_symtab
)
2089 dump_symbols (abfd
, TRUE
);
2090 if (dump_stab_section_info
)
2092 if (dump_reloc_info
&& ! disassemble
)
2094 if (dump_dynamic_reloc_info
)
2095 dump_dynamic_relocs (abfd
);
2096 if (dump_section_contents
)
2099 disassemble_data (abfd
);
2104 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2105 if (dhandle
!= NULL
)
2107 if (! print_debugging_info (stdout
, dhandle
))
2109 non_fatal (_("%s: printing debugging information failed"),
2110 bfd_get_filename (abfd
));
2135 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2141 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2143 nonfatal (bfd_get_filename (abfd
));
2144 list_matching_formats (matching
);
2149 if (bfd_get_error () != bfd_error_file_not_recognized
)
2151 nonfatal (bfd_get_filename (abfd
));
2155 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2161 nonfatal (bfd_get_filename (abfd
));
2163 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2165 list_matching_formats (matching
);
2171 display_file (filename
, target
)
2175 bfd
*file
, *arfile
= (bfd
*) NULL
;
2177 file
= bfd_openr (filename
, target
);
2180 nonfatal (filename
);
2184 if (bfd_check_format (file
, bfd_archive
))
2186 bfd
*last_arfile
= NULL
;
2188 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2191 bfd_set_error (bfd_error_no_error
);
2193 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2196 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2197 nonfatal (bfd_get_filename (file
));
2201 display_bfd (arfile
);
2203 if (last_arfile
!= NULL
)
2204 bfd_close (last_arfile
);
2205 last_arfile
= arfile
;
2208 if (last_arfile
!= NULL
)
2209 bfd_close (last_arfile
);
2217 /* Actually display the various requested regions. */
2225 bfd_size_type datasize
= 0;
2226 bfd_size_type addr_offset
;
2227 bfd_size_type start_offset
, stop_offset
;
2228 unsigned int opb
= bfd_octets_per_byte (abfd
);
2230 for (section
= abfd
->sections
; section
!= NULL
; section
=
2235 if (only
== (char *) NULL
||
2236 strcmp (only
, section
->name
) == 0)
2238 if (section
->flags
& SEC_HAS_CONTENTS
)
2240 printf (_("Contents of section %s:\n"), section
->name
);
2242 if (bfd_section_size (abfd
, section
) == 0)
2244 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2245 datasize
= bfd_section_size (abfd
, section
);
2248 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2250 if (start_address
== (bfd_vma
) -1
2251 || start_address
< section
->vma
)
2254 start_offset
= start_address
- section
->vma
;
2255 if (stop_address
== (bfd_vma
) -1)
2256 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2259 if (stop_address
< section
->vma
)
2262 stop_offset
= stop_address
- section
->vma
;
2263 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2264 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2266 for (addr_offset
= start_offset
;
2267 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2271 printf (" %04lx ", (unsigned long int)
2272 (addr_offset
+ section
->vma
));
2273 for (j
= addr_offset
* opb
;
2274 j
< addr_offset
* opb
+ onaline
; j
++)
2276 if (j
< stop_offset
* opb
)
2277 printf ("%02x", (unsigned) (data
[j
]));
2285 for (j
= addr_offset
* opb
;
2286 j
< addr_offset
* opb
+ onaline
; j
++)
2288 if (j
>= stop_offset
* opb
)
2291 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2301 /* Should perhaps share code and display with nm? */
2304 dump_symbols (abfd
, dynamic
)
2305 bfd
*abfd ATTRIBUTE_UNUSED
;
2306 bfd_boolean dynamic
;
2316 printf ("DYNAMIC SYMBOL TABLE:\n");
2322 printf ("SYMBOL TABLE:\n");
2326 printf (_("no symbols\n"));
2328 for (count
= 0; count
< max
; count
++)
2332 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2334 if (cur_bfd
!= NULL
)
2339 name
= (*current
)->name
;
2341 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2343 /* If we want to demangle the name, we demangle it
2344 here, and temporarily clobber it while calling
2345 bfd_print_symbol. FIXME: This is a gross hack. */
2346 alloc
= demangle (cur_bfd
, name
);
2347 (*current
)->name
= alloc
;
2350 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2351 bfd_print_symbol_all
);
2353 (*current
)->name
= name
;
2374 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2378 if (bfd_is_abs_section (a
))
2380 if (bfd_is_und_section (a
))
2382 if (bfd_is_com_section (a
))
2387 if (strcmp (only
, a
->name
))
2390 else if ((a
->flags
& SEC_RELOC
) == 0)
2393 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2395 bfd_fatal (bfd_get_filename (abfd
));
2397 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2401 printf (" (none)\n\n");
2405 relpp
= (arelent
**) xmalloc (relsize
);
2406 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2409 bfd_fatal (bfd_get_filename (abfd
));
2410 else if (relcount
== 0)
2411 printf (" (none)\n\n");
2415 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2424 dump_dynamic_relocs (abfd
)
2431 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2433 bfd_fatal (bfd_get_filename (abfd
));
2435 printf ("DYNAMIC RELOCATION RECORDS");
2438 printf (" (none)\n\n");
2441 relpp
= (arelent
**) xmalloc (relsize
);
2442 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2445 bfd_fatal (bfd_get_filename (abfd
));
2446 else if (relcount
== 0)
2447 printf (" (none)\n\n");
2451 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2459 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2466 char *last_filename
, *last_functionname
;
2467 unsigned int last_line
;
2469 /* Get column headers lined up reasonably. */
2476 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2477 width
= strlen (buf
) - 7;
2479 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2482 last_filename
= NULL
;
2483 last_functionname
= NULL
;
2486 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2489 const char *filename
, *functionname
;
2491 const char *sym_name
;
2492 const char *section_name
;
2494 if (start_address
!= (bfd_vma
) -1
2495 && q
->address
< start_address
)
2497 if (stop_address
!= (bfd_vma
) -1
2498 && q
->address
> stop_address
)
2501 if (with_line_numbers
2503 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2504 &filename
, &functionname
, &line
))
2506 if (functionname
!= NULL
2507 && (last_functionname
== NULL
2508 || strcmp (functionname
, last_functionname
) != 0))
2510 printf ("%s():\n", functionname
);
2511 if (last_functionname
!= NULL
)
2512 free (last_functionname
);
2513 last_functionname
= xstrdup (functionname
);
2517 && (line
!= last_line
2518 || (filename
!= NULL
2519 && last_filename
!= NULL
2520 && strcmp (filename
, last_filename
) != 0)))
2522 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2524 if (last_filename
!= NULL
)
2525 free (last_filename
);
2526 if (filename
== NULL
)
2527 last_filename
= NULL
;
2529 last_filename
= xstrdup (filename
);
2533 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2535 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2536 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2541 section_name
= NULL
;
2546 bfd_printf_vma (abfd
, q
->address
);
2548 printf (" %-16s ", q
->howto
->name
);
2550 printf (" %-16d ", q
->howto
->type
);
2551 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2556 if (section_name
== (const char *) NULL
)
2557 section_name
= "*unknown*";
2558 bfd_printf_vma (abfd
, q
->address
);
2559 printf (" %-16s [%s]",
2567 bfd_printf_vma (abfd
, q
->addend
);
2574 /* The length of the longest architecture name + 1. */
2575 #define LONGEST_ARCH sizeof("powerpc:common")
2578 endian_string (endian
)
2579 enum bfd_endian endian
;
2581 if (endian
== BFD_ENDIAN_BIG
)
2582 return "big endian";
2583 else if (endian
== BFD_ENDIAN_LITTLE
)
2584 return "little endian";
2586 return "endianness unknown";
2589 /* List the targets that BFD is configured to support, each followed
2590 by its endianness and the architectures it supports. */
2593 display_target_list ()
2595 extern const bfd_target
*const *bfd_target_vector
;
2599 dummy_name
= make_temp_file (NULL
);
2600 for (t
= 0; bfd_target_vector
[t
]; t
++)
2602 const bfd_target
*p
= bfd_target_vector
[t
];
2603 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2606 printf ("%s\n (header %s, data %s)\n", p
->name
,
2607 endian_string (p
->header_byteorder
),
2608 endian_string (p
->byteorder
));
2612 nonfatal (dummy_name
);
2616 if (! bfd_set_format (abfd
, bfd_object
))
2618 if (bfd_get_error () != bfd_error_invalid_operation
)
2620 bfd_close_all_done (abfd
);
2624 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2625 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2627 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2628 bfd_close_all_done (abfd
);
2630 unlink (dummy_name
);
2634 /* Print a table showing which architectures are supported for entries
2635 FIRST through LAST-1 of bfd_target_vector (targets across,
2636 architectures down). */
2639 display_info_table (first
, last
)
2643 extern const bfd_target
*const *bfd_target_vector
;
2647 /* Print heading of target names. */
2648 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2649 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2650 printf ("%s ", bfd_target_vector
[t
]->name
);
2653 dummy_name
= make_temp_file (NULL
);
2654 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2655 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2657 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2658 bfd_printable_arch_mach (a
, 0));
2659 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2661 const bfd_target
*p
= bfd_target_vector
[t
];
2662 bfd_boolean ok
= TRUE
;
2663 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2673 if (! bfd_set_format (abfd
, bfd_object
))
2675 if (bfd_get_error () != bfd_error_invalid_operation
)
2683 if (! bfd_set_arch_mach (abfd
, a
, 0))
2688 printf ("%s ", p
->name
);
2691 int l
= strlen (p
->name
);
2697 bfd_close_all_done (abfd
);
2701 unlink (dummy_name
);
2705 /* Print tables of all the target-architecture combinations that
2706 BFD has been configured to support. */
2709 display_target_tables ()
2712 extern const bfd_target
*const *bfd_target_vector
;
2716 colum
= getenv ("COLUMNS");
2718 columns
= atoi (colum
);
2723 while (bfd_target_vector
[t
] != NULL
)
2727 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2729 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2733 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2734 if (newwid
>= columns
)
2739 display_info_table (oldt
, t
);
2746 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2747 display_target_list ();
2748 display_target_tables ();
2751 int main
PARAMS ((int, char **));
2759 char *target
= default_target
;
2760 bfd_boolean seenflag
= FALSE
;
2762 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2763 setlocale (LC_MESSAGES
, "");
2765 #if defined (HAVE_SETLOCALE)
2766 setlocale (LC_CTYPE
, "");
2768 bindtextdomain (PACKAGE
, LOCALEDIR
);
2769 textdomain (PACKAGE
);
2771 program_name
= *argv
;
2772 xmalloc_set_program_name (program_name
);
2774 START_PROGRESS (program_name
, 0);
2777 set_default_bfd_target ();
2779 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2780 long_options
, (int *) 0))
2786 break; /* We've been given a long option. */
2791 disassembler_options
= optarg
;
2797 with_line_numbers
= TRUE
;
2806 enum demangling_styles style
;
2808 style
= cplus_demangle_name_to_style (optarg
);
2809 if (style
== unknown_demangling
)
2810 fatal (_("unknown demangling style `%s'"),
2813 cplus_demangle_set_style (style
);
2819 case OPTION_ADJUST_VMA
:
2820 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2822 case OPTION_START_ADDRESS
:
2823 start_address
= parse_vma (optarg
, "--start-address");
2825 case OPTION_STOP_ADDRESS
:
2826 stop_address
= parse_vma (optarg
, "--stop-address");
2829 if (strcmp (optarg
, "B") == 0)
2830 endian
= BFD_ENDIAN_BIG
;
2831 else if (strcmp (optarg
, "L") == 0)
2832 endian
= BFD_ENDIAN_LITTLE
;
2835 non_fatal (_("unrecognized -E option"));
2840 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2841 endian
= BFD_ENDIAN_BIG
;
2842 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2843 endian
= BFD_ENDIAN_LITTLE
;
2846 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2852 dump_file_header
= TRUE
;
2856 formats_info
= TRUE
;
2860 dump_private_headers
= TRUE
;
2864 dump_private_headers
= TRUE
;
2866 dump_reloc_info
= TRUE
;
2867 dump_file_header
= TRUE
;
2868 dump_ar_hdrs
= TRUE
;
2869 dump_section_headers
= TRUE
;
2877 dump_dynamic_symtab
= TRUE
;
2885 disassemble_zeroes
= TRUE
;
2889 disassemble_all
= TRUE
;
2894 with_source_code
= TRUE
;
2902 dump_stab_section_info
= TRUE
;
2906 dump_section_contents
= TRUE
;
2910 dump_reloc_info
= TRUE
;
2914 dump_dynamic_reloc_info
= TRUE
;
2918 dump_ar_hdrs
= TRUE
;
2922 dump_section_headers
= TRUE
;
2930 show_version
= TRUE
;
2940 print_version ("objdump");
2950 display_file ("a.out", target
);
2952 for (; optind
< argc
;)
2953 display_file (argv
[optind
++], target
);
2956 END_PROGRESS (program_name
);