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 "libiberty.h"
33 /* Internal headers for the ELF .stab-dump code - sorry. */
34 #define BYTES_IN_WORD 32
35 #include "aout/aout64.h"
37 #ifdef NEED_DECLARATION_FPRINTF
38 /* This is needed by INIT_DISASSEMBLE_INFO. */
39 extern int fprintf
PARAMS ((FILE *, const char *, ...));
43 static int exit_status
= 0;
45 static char *default_target
= NULL
; /* default at runtime */
47 static int show_version
= 0; /* show the version number */
48 static int dump_section_contents
; /* -s */
49 static int dump_section_headers
; /* -h */
50 static boolean dump_file_header
; /* -f */
51 static int dump_symtab
; /* -t */
52 static int dump_dynamic_symtab
; /* -T */
53 static int dump_reloc_info
; /* -r */
54 static int dump_dynamic_reloc_info
; /* -R */
55 static int dump_ar_hdrs
; /* -a */
56 static int dump_private_headers
; /* -p */
57 static int prefix_addresses
; /* --prefix-addresses */
58 static int with_line_numbers
; /* -l */
59 static boolean with_source_code
; /* -S */
60 static int show_raw_insn
; /* --show-raw-insn */
61 static int dump_stab_section_info
; /* --stabs */
62 static int do_demangle
; /* -C, --demangle */
63 static boolean disassemble
; /* -d */
64 static boolean disassemble_all
; /* -D */
65 static int disassemble_zeroes
; /* --disassemble-zeroes */
66 static boolean formats_info
; /* -i */
67 static char *only
; /* -j secname */
68 static int wide_output
; /* -w */
69 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
70 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
71 static int dump_debugging
; /* --debugging */
72 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
73 static int file_start_context
= 0; /* --file-start-context */
75 /* Extra info to pass to the disassembler address printing function. */
76 struct objdump_disasm_info
{
82 /* Architecture to disassemble for, or default if NULL. */
83 static char *machine
= (char *) NULL
;
85 /* Target specific options to the disassembler. */
86 static char *disassembler_options
= (char *) NULL
;
88 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
89 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
91 /* The symbol table. */
92 static asymbol
**syms
;
94 /* Number of symbols in `syms'. */
95 static long symcount
= 0;
97 /* The sorted symbol table. */
98 static asymbol
**sorted_syms
;
100 /* Number of symbols in `sorted_syms'. */
101 static long sorted_symcount
= 0;
103 /* The dynamic symbol table. */
104 static asymbol
**dynsyms
;
106 /* Number of symbols in `dynsyms'. */
107 static long dynsymcount
= 0;
109 /* Static declarations. */
111 static void usage
PARAMS ((FILE *, int));
112 static void nonfatal
PARAMS ((const char *));
113 static void display_file
PARAMS ((char *filename
, char *target
));
114 static void dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
115 static void dump_headers
PARAMS ((bfd
*));
116 static void dump_data
PARAMS ((bfd
*abfd
));
117 static void dump_relocs
PARAMS ((bfd
*abfd
));
118 static void dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
119 static void dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
120 static void dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
121 static void dump_bfd_header
PARAMS ((bfd
*));
122 static void dump_bfd_private_header
PARAMS ((bfd
*));
123 static void dump_bfd
PARAMS ((bfd
*));
124 static void display_bfd
PARAMS ((bfd
*abfd
));
125 static void display_target_list
PARAMS ((void));
126 static void display_info_table
PARAMS ((int, int));
127 static void display_target_tables
PARAMS ((void));
128 static void display_info
PARAMS ((void));
129 static void objdump_print_value
130 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
131 static void objdump_print_symname
132 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
133 static asymbol
*find_symbol_for_address
134 PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
135 static void objdump_print_addr_with_sym
136 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
137 struct disassemble_info
*, boolean
));
138 static void objdump_print_addr
139 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
140 static void objdump_print_address
141 PARAMS ((bfd_vma
, struct disassemble_info
*));
142 static int objdump_symbol_at_address
143 PARAMS ((bfd_vma
, struct disassemble_info
*));
144 static void show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
145 static void disassemble_bytes
146 PARAMS ((struct disassemble_info
*, disassembler_ftype
, boolean
,
147 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
148 static void disassemble_data
PARAMS ((bfd
*));
149 static const char *endian_string
PARAMS ((enum bfd_endian
));
150 static asymbol
** slurp_symtab
PARAMS ((bfd
*));
151 static asymbol
** slurp_dynamic_symtab
PARAMS ((bfd
*));
152 static long remove_useless_symbols
PARAMS ((asymbol
**, long));
153 static int compare_symbols
PARAMS ((const PTR
, const PTR
));
154 static int compare_relocs
PARAMS ((const PTR
, const PTR
));
155 static void dump_stabs
PARAMS ((bfd
*));
156 static boolean read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
157 static void print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
160 usage (stream
, status
)
164 fprintf (stream
, _("Usage: %s OPTION... FILE...\n"), program_name
);
165 fprintf (stream
, _("Display information from object FILE.\n"));
166 fprintf (stream
, _("\n At least one of the following switches must be given:\n"));
167 fprintf (stream
, _("\
168 -a, --archive-headers Display archive header information\n\
169 -f, --file-headers Display the contents of the overall file header\n\
170 -p, --private-headers Display object format specific file header contents\n\
171 -h, --[section-]headers Display the contents of the section headers\n\
172 -x, --all-headers Display the contents of all headers\n\
173 -d, --disassemble Display assembler contents of executable sections\n\
174 -D, --disassemble-all Display assembler contents of all sections\n\
175 -S, --source Intermix source code with disassembly\n\
176 -s, --full-contents Display the full contents of all sections requested\n\
177 -g, --debugging Display debug information in object file\n\
178 -G, --stabs Display (in raw form) any STABS info in the file\n\
179 -t, --syms Display the contents of the symbol table(s)\n\
180 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
181 -r, --reloc Display the relocation entries in the file\n\
182 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
183 -V, --version Display this program's version number\n\
184 -i, --info List object formats and architectures supported\n\
185 -H, --help Display this information\n\
189 fprintf (stream
, _("\n The following switches are optional:\n"));
190 fprintf (stream
, _("\
191 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
192 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
193 -j, --section=NAME Only display information for section NAME\n\
194 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
195 -EB --endian=big Assume big endian format when disassembling\n\
196 -EL --endian=little Assume little endian format when disassembling\n\
197 --file-start-context Include context from start of file (with -S)\n\
198 -l, --line-numbers Include line numbers and filenames in output\n\
199 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
200 The STYLE, if specified, can be `auto', 'gnu',\n\
201 'lucid', 'arm', 'hp', 'edg', or 'gnu-new-abi'\n\
202 -w, --wide Format output for more than 80 columns\n\
203 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
204 --start-address=ADDR Only process data whoes address is >= ADDR\n\
205 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
206 --prefix-addresses Print complete address alongside disassembly\n\
207 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
208 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
210 list_supported_targets (program_name
, stream
);
211 list_supported_architectures (program_name
, stream
);
213 disassembler_usage (stream
);
216 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
220 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
222 #define OPTION_ENDIAN (150)
223 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
224 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
225 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
227 static struct option long_options
[]=
229 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
230 {"all-headers", no_argument
, NULL
, 'x'},
231 {"private-headers", no_argument
, NULL
, 'p'},
232 {"architecture", required_argument
, NULL
, 'm'},
233 {"archive-headers", no_argument
, NULL
, 'a'},
234 {"debugging", no_argument
, NULL
, 'g'},
235 {"demangle", optional_argument
, NULL
, 'C'},
236 {"disassemble", no_argument
, NULL
, 'd'},
237 {"disassemble-all", no_argument
, NULL
, 'D'},
238 {"disassembler-options", required_argument
, NULL
, 'M'},
239 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
240 {"dynamic-reloc", no_argument
, NULL
, 'R'},
241 {"dynamic-syms", no_argument
, NULL
, 'T'},
242 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
243 {"file-headers", no_argument
, NULL
, 'f'},
244 {"file-start-context", no_argument
, &file_start_context
, 1},
245 {"full-contents", no_argument
, NULL
, 's'},
246 {"headers", no_argument
, NULL
, 'h'},
247 {"help", no_argument
, NULL
, 'H'},
248 {"info", no_argument
, NULL
, 'i'},
249 {"line-numbers", no_argument
, NULL
, 'l'},
250 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
251 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
252 {"reloc", no_argument
, NULL
, 'r'},
253 {"section", required_argument
, NULL
, 'j'},
254 {"section-headers", no_argument
, NULL
, 'h'},
255 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
256 {"source", no_argument
, NULL
, 'S'},
257 {"stabs", no_argument
, NULL
, 'G'},
258 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
259 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
260 {"syms", no_argument
, NULL
, 't'},
261 {"target", required_argument
, NULL
, 'b'},
262 {"version", no_argument
, NULL
, 'V'},
263 {"wide", no_argument
, NULL
, 'w'},
264 {0, no_argument
, 0, 0}
276 dump_section_header (abfd
, section
, ignored
)
277 bfd
*abfd ATTRIBUTE_UNUSED
;
279 PTR ignored ATTRIBUTE_UNUSED
;
282 unsigned int opb
= bfd_octets_per_byte (abfd
);
284 printf ("%3d %-13s %08lx ", section
->index
,
285 bfd_get_section_name (abfd
, section
),
286 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
287 printf_vma (bfd_get_section_vma (abfd
, section
));
289 printf_vma (section
->lma
);
290 printf (" %08lx 2**%u", section
->filepos
,
291 bfd_get_section_alignment (abfd
, section
));
297 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
299 PF (SEC_HAS_CONTENTS
, "CONTENTS");
300 PF (SEC_ALLOC
, "ALLOC");
301 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
302 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
303 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
304 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
305 PF (SEC_LOAD
, "LOAD");
306 PF (SEC_RELOC
, "RELOC");
308 PF (SEC_BALIGN
, "BALIGN");
310 PF (SEC_READONLY
, "READONLY");
311 PF (SEC_CODE
, "CODE");
312 PF (SEC_DATA
, "DATA");
314 PF (SEC_DEBUGGING
, "DEBUGGING");
315 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
316 PF (SEC_EXCLUDE
, "EXCLUDE");
317 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
318 PF (SEC_BLOCK
, "BLOCK");
319 PF (SEC_CLINK
, "CLINK");
320 PF (SEC_SMALL_DATA
, "SMALL_DATA");
321 PF (SEC_SHARED
, "SHARED");
323 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
327 switch (section
->flags
& SEC_LINK_DUPLICATES
)
331 case SEC_LINK_DUPLICATES_DISCARD
:
332 ls
= "LINK_ONCE_DISCARD";
334 case SEC_LINK_DUPLICATES_ONE_ONLY
:
335 ls
= "LINK_ONCE_ONE_ONLY";
337 case SEC_LINK_DUPLICATES_SAME_SIZE
:
338 ls
= "LINK_ONCE_SAME_SIZE";
340 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
341 ls
= "LINK_ONCE_SAME_CONTENTS";
344 printf ("%s%s", comma
, ls
);
346 if (section
->comdat
!= NULL
)
347 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
348 section
->comdat
->symbol
);
361 printf (_("Sections:\n"));
364 printf (_("Idx Name Size VMA LMA File off Algn"));
366 printf (_("Idx Name Size VMA LMA File off Algn"));
370 printf (_(" Flags"));
373 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
380 asymbol
**sy
= (asymbol
**) NULL
;
383 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
385 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
390 storage
= bfd_get_symtab_upper_bound (abfd
);
392 bfd_fatal (bfd_get_filename (abfd
));
396 sy
= (asymbol
**) xmalloc (storage
);
398 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
400 bfd_fatal (bfd_get_filename (abfd
));
402 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
406 /* Read in the dynamic symbols. */
409 slurp_dynamic_symtab (abfd
)
412 asymbol
**sy
= (asymbol
**) NULL
;
415 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
418 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
420 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
425 bfd_fatal (bfd_get_filename (abfd
));
430 sy
= (asymbol
**) xmalloc (storage
);
432 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
434 bfd_fatal (bfd_get_filename (abfd
));
435 if (dynsymcount
== 0)
436 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
440 /* Filter out (in place) symbols that are useless for disassembly.
441 COUNT is the number of elements in SYMBOLS.
442 Return the number of useful symbols. */
445 remove_useless_symbols (symbols
, count
)
449 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
453 asymbol
*sym
= *in_ptr
++;
455 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
457 if (sym
->flags
& (BSF_DEBUGGING
))
459 if (bfd_is_und_section (sym
->section
)
460 || bfd_is_com_section (sym
->section
))
465 return out_ptr
- symbols
;
468 /* Sort symbols into value order. */
471 compare_symbols (ap
, bp
)
475 const asymbol
*a
= *(const asymbol
**)ap
;
476 const asymbol
*b
= *(const asymbol
**)bp
;
480 flagword aflags
, bflags
;
482 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
484 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
487 if (a
->section
> b
->section
)
489 else if (a
->section
< b
->section
)
492 an
= bfd_asymbol_name (a
);
493 bn
= bfd_asymbol_name (b
);
497 /* The symbols gnu_compiled and gcc2_compiled convey no real
498 information, so put them after other symbols with the same value. */
500 af
= (strstr (an
, "gnu_compiled") != NULL
501 || strstr (an
, "gcc2_compiled") != NULL
);
502 bf
= (strstr (bn
, "gnu_compiled") != NULL
503 || strstr (bn
, "gcc2_compiled") != NULL
);
510 /* We use a heuristic for the file name, to try to sort it after
511 more useful symbols. It may not work on non Unix systems, but it
512 doesn't really matter; the only difference is precisely which
513 symbol names get printed. */
515 #define file_symbol(s, sn, snl) \
516 (((s)->flags & BSF_FILE) != 0 \
517 || ((sn)[(snl) - 2] == '.' \
518 && ((sn)[(snl) - 1] == 'o' \
519 || (sn)[(snl) - 1] == 'a')))
521 af
= file_symbol (a
, an
, anl
);
522 bf
= file_symbol (b
, bn
, bnl
);
529 /* Try to sort global symbols before local symbols before function
530 symbols before debugging symbols. */
535 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
537 if ((aflags
& BSF_DEBUGGING
) != 0)
542 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
544 if ((aflags
& BSF_FUNCTION
) != 0)
549 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
551 if ((aflags
& BSF_LOCAL
) != 0)
556 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
558 if ((aflags
& BSF_GLOBAL
) != 0)
564 /* Symbols that start with '.' might be section names, so sort them
565 after symbols that don't start with '.'. */
566 if (an
[0] == '.' && bn
[0] != '.')
568 if (an
[0] != '.' && bn
[0] == '.')
571 /* Finally, if we can't distinguish them in any other way, try to
572 get consistent results by sorting the symbols by name. */
573 return strcmp (an
, bn
);
576 /* Sort relocs into address order. */
579 compare_relocs (ap
, bp
)
583 const arelent
*a
= *(const arelent
**)ap
;
584 const arelent
*b
= *(const arelent
**)bp
;
586 if (a
->address
> b
->address
)
588 else if (a
->address
< b
->address
)
591 /* So that associated relocations tied to the same address show up
592 in the correct order, we don't do any further sorting. */
601 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
604 objdump_print_value (vma
, info
, skip_zeroes
)
606 struct disassemble_info
*info
;
612 sprintf_vma (buf
, vma
);
617 for (p
= buf
; *p
== '0'; ++p
)
622 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
625 /* Print the name of a symbol. */
628 objdump_print_symname (abfd
, info
, sym
)
630 struct disassemble_info
*info
;
638 name
= bfd_asymbol_name (sym
);
639 if (! do_demangle
|| name
[0] == '\0')
643 /* Demangle the name. */
644 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
647 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
655 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
657 printf ("%s", print
);
663 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
664 is true, then always require the symbol to be in the section. This
665 returns NULL if there is no suitable symbol. If PLACE is not NULL,
666 then *PLACE is set to the index of the symbol in sorted_syms. */
669 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
676 /* @@ Would it speed things up to cache the last two symbols returned,
677 and maybe their address ranges? For many processors, only one memory
678 operand can be present at a time, so the 2-entry cache wouldn't be
679 constantly churned by code doing heavy memory accesses. */
681 /* Indices in `sorted_syms'. */
683 long max
= sorted_symcount
;
685 unsigned int opb
= bfd_octets_per_byte (abfd
);
687 if (sorted_symcount
< 1)
690 /* Perform a binary search looking for the closest symbol to the
691 required value. We are searching the range (min, max]. */
692 while (min
+ 1 < max
)
696 thisplace
= (max
+ min
) / 2;
697 sym
= sorted_syms
[thisplace
];
699 if (bfd_asymbol_value (sym
) > vma
)
701 else if (bfd_asymbol_value (sym
) < vma
)
710 /* The symbol we want is now in min, the low end of the range we
711 were searching. If there are several symbols with the same
712 value, we want the first one. */
715 && (bfd_asymbol_value (sorted_syms
[thisplace
])
716 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
719 /* If the file is relocateable, and the symbol could be from this
720 section, prefer a symbol from this section over symbols from
721 others, even if the other symbol's value might be closer.
723 Note that this may be wrong for some symbol references if the
724 sections have overlapping memory ranges, but in that case there's
725 no way to tell what's desired without looking at the relocation
728 if (sorted_syms
[thisplace
]->section
!= sec
730 || ((abfd
->flags
& HAS_RELOC
) != 0
731 && vma
>= bfd_get_section_vma (abfd
, sec
)
732 && vma
< (bfd_get_section_vma (abfd
, sec
)
733 + bfd_section_size (abfd
, sec
) / opb
))))
737 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
739 if (bfd_asymbol_value (sorted_syms
[i
])
740 != bfd_asymbol_value (sorted_syms
[thisplace
]))
746 if (sorted_syms
[i
]->section
== sec
748 || sorted_syms
[i
- 1]->section
!= sec
749 || (bfd_asymbol_value (sorted_syms
[i
])
750 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
757 if (sorted_syms
[thisplace
]->section
!= sec
)
759 /* We didn't find a good symbol with a smaller value.
760 Look for one with a larger value. */
761 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
763 if (sorted_syms
[i
]->section
== sec
)
771 if (sorted_syms
[thisplace
]->section
!= sec
773 || ((abfd
->flags
& HAS_RELOC
) != 0
774 && vma
>= bfd_get_section_vma (abfd
, sec
)
775 && vma
< (bfd_get_section_vma (abfd
, sec
)
776 + bfd_section_size (abfd
, sec
)))))
778 /* There is no suitable symbol. */
786 return sorted_syms
[thisplace
];
789 /* Print an address to INFO symbolically. */
792 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
797 struct disassemble_info
*info
;
800 objdump_print_value (vma
, info
, skip_zeroes
);
806 (*info
->fprintf_func
) (info
->stream
, " <%s",
807 bfd_get_section_name (abfd
, sec
));
808 secaddr
= bfd_get_section_vma (abfd
, sec
);
811 (*info
->fprintf_func
) (info
->stream
, "-0x");
812 objdump_print_value (secaddr
- vma
, info
, true);
814 else if (vma
> secaddr
)
816 (*info
->fprintf_func
) (info
->stream
, "+0x");
817 objdump_print_value (vma
- secaddr
, info
, true);
819 (*info
->fprintf_func
) (info
->stream
, ">");
823 (*info
->fprintf_func
) (info
->stream
, " <");
824 objdump_print_symname (abfd
, info
, sym
);
825 if (bfd_asymbol_value (sym
) > vma
)
827 (*info
->fprintf_func
) (info
->stream
, "-0x");
828 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
830 else if (vma
> bfd_asymbol_value (sym
))
832 (*info
->fprintf_func
) (info
->stream
, "+0x");
833 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
835 (*info
->fprintf_func
) (info
->stream
, ">");
839 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
840 true, don't output leading zeroes. */
843 objdump_print_addr (vma
, info
, skip_zeroes
)
845 struct disassemble_info
*info
;
848 struct objdump_disasm_info
*aux
;
851 if (sorted_symcount
< 1)
853 (*info
->fprintf_func
) (info
->stream
, "0x");
854 objdump_print_value (vma
, info
, skip_zeroes
);
858 aux
= (struct objdump_disasm_info
*) info
->application_data
;
859 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
861 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
865 /* Print VMA to INFO. This function is passed to the disassembler
869 objdump_print_address (vma
, info
)
871 struct disassemble_info
*info
;
873 objdump_print_addr (vma
, info
, ! prefix_addresses
);
876 /* Determine of the given address has a symbol associated with it. */
879 objdump_symbol_at_address (vma
, info
)
881 struct disassemble_info
* info
;
883 struct objdump_disasm_info
* aux
;
886 /* No symbols - do not bother checking. */
887 if (sorted_symcount
< 1)
890 aux
= (struct objdump_disasm_info
*) info
->application_data
;
891 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
894 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
897 /* Hold the last function name and the last line number we displayed
900 static char *prev_functionname
;
901 static unsigned int prev_line
;
903 /* We keep a list of all files that we have seen when doing a
904 dissassembly with source, so that we know how much of the file to
905 display. This can be important for inlined functions. */
907 struct print_file_list
909 struct print_file_list
*next
;
915 static struct print_file_list
*print_files
;
917 /* The number of preceding context lines to show when we start
918 displaying a file for the first time. */
920 #define SHOW_PRECEDING_CONTEXT_LINES (5)
922 /* Skip ahead to a given line in a file, optionally printing each
926 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
929 skip_to_line (p
, line
, show
)
930 struct print_file_list
*p
;
934 while (p
->line
< line
)
938 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
948 if (strchr (buf
, '\n') != NULL
)
953 /* Show the line number, or the source line, in a dissassembly
957 show_line (abfd
, section
, addr_offset
)
962 CONST
char *filename
;
963 CONST
char *functionname
;
966 if (! with_line_numbers
&& ! with_source_code
)
969 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
970 &functionname
, &line
))
973 if (filename
!= NULL
&& *filename
== '\0')
975 if (functionname
!= NULL
&& *functionname
== '\0')
978 if (with_line_numbers
)
980 if (functionname
!= NULL
981 && (prev_functionname
== NULL
982 || strcmp (functionname
, prev_functionname
) != 0))
983 printf ("%s():\n", functionname
);
984 if (line
> 0 && line
!= prev_line
)
985 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
992 struct print_file_list
**pp
, *p
;
994 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
995 if (strcmp ((*pp
)->filename
, filename
) == 0)
1001 if (p
!= print_files
)
1005 /* We have reencountered a file name which we saw
1006 earlier. This implies that either we are dumping out
1007 code from an included file, or the same file was
1008 linked in more than once. There are two common cases
1009 of an included file: inline functions in a header
1010 file, and a bison or flex skeleton file. In the
1011 former case we want to just start printing (but we
1012 back up a few lines to give context); in the latter
1013 case we want to continue from where we left off. I
1014 can't think of a good way to distinguish the cases,
1015 so I used a heuristic based on the file name. */
1016 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1020 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1027 p
->f
= fopen (p
->filename
, "r");
1031 skip_to_line (p
, l
, false);
1033 if (print_files
->f
!= NULL
)
1035 fclose (print_files
->f
);
1036 print_files
->f
= NULL
;
1042 skip_to_line (p
, line
, true);
1044 p
->next
= print_files
;
1052 f
= fopen (filename
, "r");
1057 p
= ((struct print_file_list
*)
1058 xmalloc (sizeof (struct print_file_list
)));
1059 p
->filename
= xmalloc (strlen (filename
) + 1);
1060 strcpy (p
->filename
, filename
);
1064 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1066 fclose (print_files
->f
);
1067 print_files
->f
= NULL
;
1069 p
->next
= print_files
;
1072 if (file_start_context
)
1075 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1078 skip_to_line (p
, l
, false);
1080 skip_to_line (p
, line
, true);
1085 if (functionname
!= NULL
1086 && (prev_functionname
== NULL
1087 || strcmp (functionname
, prev_functionname
) != 0))
1089 if (prev_functionname
!= NULL
)
1090 free (prev_functionname
);
1091 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1092 strcpy (prev_functionname
, functionname
);
1095 if (line
> 0 && line
!= prev_line
)
1099 /* Pseudo FILE object for strings. */
1107 /* sprintf to a "stream" */
1110 #ifdef ANSI_PROTOTYPES
1111 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1113 objdump_sprintf (va_alist
)
1117 #ifndef ANSI_PROTOTYPES
1125 #ifdef ANSI_PROTOTYPES
1126 va_start (args
, format
);
1129 f
= va_arg (args
, SFILE
*);
1130 format
= va_arg (args
, const char *);
1133 vasprintf (&buf
, format
, args
);
1139 fatal (_("Out of virtual memory"));
1144 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1148 curroff
= f
->current
- f
->buffer
;
1150 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1151 f
->current
= f
->buffer
+ curroff
;
1154 memcpy (f
->current
, buf
, n
);
1156 f
->current
[0] = '\0';
1163 /* The number of zeroes we want to see before we start skipping them.
1164 The number is arbitrarily chosen. */
1167 #define SKIP_ZEROES (8)
1170 /* The number of zeroes to skip at the end of a section. If the
1171 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1172 SKIP_ZEROES, they will be disassembled. If there are fewer than
1173 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1174 attempt to avoid disassembling zeroes inserted by section
1177 #ifndef SKIP_ZEROES_AT_END
1178 #define SKIP_ZEROES_AT_END (3)
1181 /* Disassemble some data in memory between given values. */
1184 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1185 start_offset
, stop_offset
, relppp
,
1187 struct disassemble_info
*info
;
1188 disassembler_ftype disassemble_fn
;
1191 bfd_vma start_offset
;
1192 bfd_vma stop_offset
;
1196 struct objdump_disasm_info
*aux
;
1198 int octets_per_line
;
1200 int skip_addr_chars
;
1201 bfd_vma addr_offset
;
1202 int opb
= info
->octets_per_byte
;
1204 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1208 octets_per_line
= 4;
1210 octets_per_line
= 16;
1212 /* Figure out how many characters to skip at the start of an
1213 address, to make the disassembly look nicer. We discard leading
1214 zeroes in chunks of 4, ensuring that there is always a leading
1216 skip_addr_chars
= 0;
1217 if (! prefix_addresses
)
1222 sprintf_vma (buf
, section
->vma
+
1223 bfd_section_size (section
->owner
, section
) / opb
);
1225 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1228 skip_addr_chars
+= 4;
1233 info
->insn_info_valid
= 0;
1236 addr_offset
= start_offset
;
1237 while (addr_offset
< stop_offset
)
1241 boolean need_nl
= false;
1243 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1245 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1248 if (! disassemble_zeroes
1249 && (info
->insn_info_valid
== 0
1250 || info
->branch_delay_insns
== 0)
1251 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1252 || (z
== stop_offset
* opb
&&
1253 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1257 /* If there are more nonzero octets to follow, we only skip
1258 zeroes in multiples of 4, to try to avoid running over
1259 the start of an instruction which happens to start with
1261 if (z
!= stop_offset
* opb
)
1262 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1264 octets
= z
- addr_offset
* opb
;
1275 if (with_line_numbers
|| with_source_code
)
1276 /* The line number tables will refer to unadjusted
1277 section VMAs, so we must undo any VMA modifications
1278 when calling show_line. */
1279 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1281 if (! prefix_addresses
)
1285 sprintf_vma (buf
, section
->vma
+ addr_offset
);
1286 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1290 printf ("%s:\t", buf
+ skip_addr_chars
);
1294 aux
->require_sec
= true;
1295 objdump_print_address (section
->vma
+ addr_offset
, info
);
1296 aux
->require_sec
= false;
1303 sfile
.buffer
= xmalloc (sfile
.size
);
1304 sfile
.current
= sfile
.buffer
;
1305 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1306 info
->stream
= (FILE *) &sfile
;
1307 info
->bytes_per_line
= 0;
1308 info
->bytes_per_chunk
= 0;
1310 #ifdef DISASSEMBLER_NEEDS_RELOCS
1311 /* FIXME: This is wrong. It tests the number of octets
1312 in the last instruction, not the current one. */
1313 if (*relppp
< relppend
1314 && (**relppp
)->address
>= addr_offset
1315 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1316 info
->flags
= INSN_HAS_RELOC
;
1321 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1322 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1323 info
->stream
= stdout
;
1324 if (info
->bytes_per_line
!= 0)
1325 octets_per_line
= info
->bytes_per_line
;
1328 if (sfile
.current
!= sfile
.buffer
)
1329 printf ("%s\n", sfile
.buffer
);
1330 free (sfile
.buffer
);
1338 octets
= octets_per_line
;
1339 if (addr_offset
+ octets
/ opb
> stop_offset
)
1340 octets
= (stop_offset
- addr_offset
) * opb
;
1342 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1344 if (isprint (data
[j
]))
1345 buf
[j
- addr_offset
* opb
] = data
[j
];
1347 buf
[j
- addr_offset
* opb
] = '.';
1349 buf
[j
- addr_offset
* opb
] = '\0';
1352 if (prefix_addresses
1354 : show_raw_insn
>= 0)
1358 /* If ! prefix_addresses and ! wide_output, we print
1359 octets_per_line octets per line. */
1361 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1362 pb
= octets_per_line
;
1364 if (info
->bytes_per_chunk
)
1365 bpc
= info
->bytes_per_chunk
;
1369 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1372 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1374 for (k
= bpc
- 1; k
>= 0; k
--)
1375 printf ("%02x", (unsigned) data
[j
+ k
]);
1380 for (k
= 0; k
< bpc
; k
++)
1381 printf ("%02x", (unsigned) data
[j
+ k
]);
1386 for (; pb
< octets_per_line
; pb
+= bpc
)
1390 for (k
= 0; k
< bpc
; k
++)
1395 /* Separate raw data from instruction by extra space. */
1406 printf ("%s", sfile
.buffer
);
1407 free (sfile
.buffer
);
1410 if (prefix_addresses
1412 : show_raw_insn
>= 0)
1420 j
= addr_offset
* opb
+ pb
;
1422 sprintf_vma (buf
, section
->vma
+ j
/ opb
);
1423 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1427 printf ("%s:\t", buf
+ skip_addr_chars
);
1429 pb
+= octets_per_line
;
1432 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1436 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1438 for (k
= bpc
- 1; k
>= 0; k
--)
1439 printf ("%02x", (unsigned) data
[j
+ k
]);
1444 for (k
= 0; k
< bpc
; k
++)
1445 printf ("%02x", (unsigned) data
[j
+ k
]);
1458 if ((section
->flags
& SEC_RELOC
) != 0
1459 #ifndef DISASSEMBLER_NEEDS_RELOCS
1464 while ((*relppp
) < relppend
1465 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1466 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1467 #ifdef DISASSEMBLER_NEEDS_RELOCS
1468 if (! dump_reloc_info
)
1482 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1484 printf (": %s\t", q
->howto
->name
);
1486 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1487 printf ("*unknown*");
1490 const char *sym_name
;
1492 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1493 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1494 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1499 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1500 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1501 if (sym_name
== NULL
|| *sym_name
== '\0')
1502 sym_name
= "*unknown*";
1503 printf ("%s", sym_name
);
1510 objdump_print_value (q
->addend
, info
, true);
1522 addr_offset
+= octets
/ opb
;
1526 /* Disassemble the contents of an object file. */
1529 disassemble_data (abfd
)
1532 unsigned long addr_offset
;
1533 disassembler_ftype disassemble_fn
;
1534 struct disassemble_info disasm_info
;
1535 struct objdump_disasm_info aux
;
1540 prev_functionname
= NULL
;
1543 /* We make a copy of syms to sort. We don't want to sort syms
1544 because that will screw up the relocs. */
1545 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1546 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1548 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1550 /* Sort the symbols into section and symbol order */
1551 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1553 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1554 disasm_info
.application_data
= (PTR
) &aux
;
1556 aux
.require_sec
= false;
1557 disasm_info
.print_address_func
= objdump_print_address
;
1558 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1560 if (machine
!= (char *) NULL
)
1562 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1565 fatal (_("Can't use supplied machine %s"), machine
);
1567 abfd
->arch_info
= info
;
1570 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1572 struct bfd_target
*xvec
;
1574 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1575 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1576 xvec
->byteorder
= endian
;
1580 disassemble_fn
= disassembler (abfd
);
1581 if (!disassemble_fn
)
1583 non_fatal (_("Can't disassemble for architecture %s\n"),
1584 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1589 opb
= bfd_octets_per_byte (abfd
);
1591 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1592 disasm_info
.arch
= bfd_get_arch (abfd
);
1593 disasm_info
.mach
= bfd_get_mach (abfd
);
1594 disasm_info
.disassembler_options
= disassembler_options
;
1595 disasm_info
.octets_per_byte
= opb
;
1597 if (bfd_big_endian (abfd
))
1598 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1599 else if (bfd_little_endian (abfd
))
1600 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1602 /* ??? Aborting here seems too drastic. We could default to big or little
1604 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1606 for (section
= abfd
->sections
;
1607 section
!= (asection
*) NULL
;
1608 section
= section
->next
)
1610 bfd_byte
*data
= NULL
;
1611 bfd_size_type datasize
= 0;
1612 arelent
**relbuf
= NULL
;
1613 arelent
**relpp
= NULL
;
1614 arelent
**relppend
= NULL
;
1615 unsigned long stop_offset
;
1616 asymbol
*sym
= NULL
;
1619 if ((section
->flags
& SEC_LOAD
) == 0
1620 || (! disassemble_all
1622 && (section
->flags
& SEC_CODE
) == 0))
1624 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1627 if ((section
->flags
& SEC_RELOC
) != 0
1628 #ifndef DISASSEMBLER_NEEDS_RELOCS
1635 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1637 bfd_fatal (bfd_get_filename (abfd
));
1643 relbuf
= (arelent
**) xmalloc (relsize
);
1644 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1646 bfd_fatal (bfd_get_filename (abfd
));
1648 /* Sort the relocs by address. */
1649 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1652 relppend
= relpp
+ relcount
;
1654 /* Skip over the relocs belonging to addresses below the
1656 if (start_address
!= (bfd_vma
) -1)
1658 while (relpp
< relppend
1659 && (*relpp
)->address
< start_address
)
1665 printf (_("Disassembly of section %s:\n"), section
->name
);
1667 datasize
= bfd_get_section_size_before_reloc (section
);
1671 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1673 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1676 disasm_info
.buffer
= data
;
1677 disasm_info
.buffer_vma
= section
->vma
;
1678 disasm_info
.buffer_length
= datasize
;
1679 disasm_info
.section
= section
;
1680 if (start_address
== (bfd_vma
) -1
1681 || start_address
< disasm_info
.buffer_vma
)
1684 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1685 if (stop_address
== (bfd_vma
) -1)
1686 stop_offset
= datasize
/ opb
;
1689 if (stop_address
< disasm_info
.buffer_vma
)
1692 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1693 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1694 stop_offset
= disasm_info
.buffer_length
/ opb
;
1697 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1700 while (addr_offset
< stop_offset
)
1703 unsigned long nextstop_offset
;
1706 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1711 (x
< sorted_symcount
1712 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1715 disasm_info
.symbols
= & sorted_syms
[place
];
1716 disasm_info
.num_symbols
= x
- place
;
1719 disasm_info
.symbols
= NULL
;
1721 if (! prefix_addresses
)
1724 objdump_print_addr_with_sym (abfd
, section
, sym
,
1725 section
->vma
+ addr_offset
,
1731 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1733 else if (sym
== NULL
)
1737 /* Search forward for the next appropriate symbol in
1738 SECTION. Note that all the symbols are sorted
1739 together into one big array, and that some sections
1740 may have overlapping addresses. */
1741 while (place
< sorted_symcount
1742 && (sorted_syms
[place
]->section
!= section
1743 || (bfd_asymbol_value (sorted_syms
[place
])
1744 <= bfd_asymbol_value (sym
))))
1746 if (place
>= sorted_symcount
)
1749 nextsym
= sorted_syms
[place
];
1752 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1754 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1755 if (nextstop_offset
> stop_offset
)
1756 nextstop_offset
= stop_offset
;
1758 else if (nextsym
== NULL
)
1759 nextstop_offset
= stop_offset
;
1762 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1763 if (nextstop_offset
> stop_offset
)
1764 nextstop_offset
= stop_offset
;
1767 /* If a symbol is explicitly marked as being an object
1768 rather than a function, just dump the bytes without
1769 disassembling them. */
1772 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1773 || ((sym
->flags
& BSF_OBJECT
) == 0
1774 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1776 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1778 || (sym
->flags
& BSF_FUNCTION
) != 0)
1783 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1784 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1786 addr_offset
= nextstop_offset
;
1798 /* Define a table of stab values and print-strings. We wish the initializer
1799 could be a direct-mapped table, but instead we build one the first
1802 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1803 char *strsect_name
));
1805 /* Dump the stabs sections from an object file that has a section that
1806 uses Sun stabs encoding. */
1812 dump_section_stabs (abfd
, ".stab", ".stabstr");
1813 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1814 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1815 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1818 static bfd_byte
*stabs
;
1819 static bfd_size_type stab_size
;
1821 static char *strtab
;
1822 static bfd_size_type stabstr_size
;
1824 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1825 and string table section STRSECT_NAME into `strtab'.
1826 If the section exists and was read, allocate the space and return true.
1827 Otherwise return false. */
1830 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1832 const char *stabsect_name
;
1833 const char *strsect_name
;
1835 asection
*stabsect
, *stabstrsect
;
1837 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1840 printf (_("No %s section present\n\n"), stabsect_name
);
1844 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1845 if (0 == stabstrsect
)
1847 non_fatal (_("%s has no %s section"),
1848 bfd_get_filename (abfd
), strsect_name
);
1853 stab_size
= bfd_section_size (abfd
, stabsect
);
1854 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1856 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1857 strtab
= (char *) xmalloc (stabstr_size
);
1859 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1861 non_fatal (_("Reading %s section of %s failed: %s"),
1862 stabsect_name
, bfd_get_filename (abfd
),
1863 bfd_errmsg (bfd_get_error ()));
1870 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1873 non_fatal (_("Reading %s section of %s failed: %s\n"),
1874 strsect_name
, bfd_get_filename (abfd
),
1875 bfd_errmsg (bfd_get_error ()));
1885 /* Stabs entries use a 12 byte format:
1886 4 byte string table index
1888 1 byte stab other field
1889 2 byte stab desc field
1891 FIXME: This will have to change for a 64 bit object format. */
1893 #define STRDXOFF (0)
1895 #define OTHEROFF (5)
1898 #define STABSIZE (12)
1900 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1901 using string table section STRSECT_NAME (in `strtab'). */
1904 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1906 const char *stabsect_name
;
1907 const char *strsect_name ATTRIBUTE_UNUSED
;
1910 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1911 bfd_byte
*stabp
, *stabs_end
;
1914 stabs_end
= stabp
+ stab_size
;
1916 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1917 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1919 /* Loop through all symbols and print them.
1921 We start the index at -1 because there is a dummy symbol on
1922 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1924 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1928 unsigned char type
, other
;
1929 unsigned short desc
;
1932 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1933 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1934 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1935 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1936 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1938 printf ("\n%-6d ", i
);
1939 /* Either print the stab name, or, if unnamed, print its number
1940 again (makes consistent formatting for tools like awk). */
1941 name
= bfd_get_stab_name (type
);
1943 printf ("%-6s", name
);
1944 else if (type
== N_UNDF
)
1947 printf ("%-6d", type
);
1948 printf (" %-6d %-6d ", other
, desc
);
1950 printf (" %-6lu", strx
);
1952 /* Symbols with type == 0 (N_UNDF) specify the length of the
1953 string table associated with this file. We use that info
1954 to know how to relocate the *next* file's string table indices. */
1958 file_string_table_offset
= next_file_string_table_offset
;
1959 next_file_string_table_offset
+= value
;
1963 /* Using the (possibly updated) string table offset, print the
1964 string (if any) associated with this symbol. */
1966 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1967 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1976 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1978 char *stabsect_name
;
1983 /* Check for section names for which stabsect_name is a prefix, to
1984 handle .stab0, etc. */
1985 for (s
= abfd
->sections
;
1991 len
= strlen (stabsect_name
);
1993 /* If the prefix matches, and the files section name ends with a
1994 nul or a digit, then we match. I.e., we want either an exact
1995 match or a section followed by a number. */
1996 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1997 && (s
->name
[len
] == '\000'
1998 || isdigit ((unsigned char) s
->name
[len
])))
2000 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2002 print_section_stabs (abfd
, s
->name
, strsect_name
);
2011 dump_bfd_header (abfd
)
2016 printf (_("architecture: %s, "),
2017 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2018 bfd_get_mach (abfd
)));
2019 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2021 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2022 PF (HAS_RELOC
, "HAS_RELOC");
2023 PF (EXEC_P
, "EXEC_P");
2024 PF (HAS_LINENO
, "HAS_LINENO");
2025 PF (HAS_DEBUG
, "HAS_DEBUG");
2026 PF (HAS_SYMS
, "HAS_SYMS");
2027 PF (HAS_LOCALS
, "HAS_LOCALS");
2028 PF (DYNAMIC
, "DYNAMIC");
2029 PF (WP_TEXT
, "WP_TEXT");
2030 PF (D_PAGED
, "D_PAGED");
2031 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2032 printf (_("\nstart address 0x"));
2033 printf_vma (abfd
->start_address
);
2038 dump_bfd_private_header (abfd
)
2041 bfd_print_private_bfd_data (abfd
, stdout
);
2044 /* Dump selected contents of ABFD */
2050 /* If we are adjusting section VMA's, change them all now. Changing
2051 the BFD information is a hack. However, we must do it, or
2052 bfd_find_nearest_line will not do the right thing. */
2053 if (adjust_section_vma
!= 0)
2057 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2059 s
->vma
+= adjust_section_vma
;
2060 s
->lma
+= adjust_section_vma
;
2064 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2067 print_arelt_descr (stdout
, abfd
, true);
2068 if (dump_file_header
)
2069 dump_bfd_header (abfd
);
2070 if (dump_private_headers
)
2071 dump_bfd_private_header (abfd
);
2073 if (dump_section_headers
)
2074 dump_headers (abfd
);
2075 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2077 syms
= slurp_symtab (abfd
);
2079 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2081 dynsyms
= slurp_dynamic_symtab (abfd
);
2084 dump_symbols (abfd
, false);
2085 if (dump_dynamic_symtab
)
2086 dump_symbols (abfd
, true);
2087 if (dump_stab_section_info
)
2089 if (dump_reloc_info
&& ! disassemble
)
2091 if (dump_dynamic_reloc_info
)
2092 dump_dynamic_relocs (abfd
);
2093 if (dump_section_contents
)
2096 disassemble_data (abfd
);
2101 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2102 if (dhandle
!= NULL
)
2104 if (! print_debugging_info (stdout
, dhandle
))
2106 non_fatal (_("%s: printing debugging information failed"),
2107 bfd_get_filename (abfd
));
2130 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2136 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2138 nonfatal (bfd_get_filename (abfd
));
2139 list_matching_formats (matching
);
2144 if (bfd_get_error () != bfd_error_file_not_recognized
)
2146 nonfatal (bfd_get_filename (abfd
));
2150 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2156 nonfatal (bfd_get_filename (abfd
));
2158 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2160 list_matching_formats (matching
);
2166 display_file (filename
, target
)
2170 bfd
*file
, *arfile
= (bfd
*) NULL
;
2172 file
= bfd_openr (filename
, target
);
2175 nonfatal (filename
);
2179 if (bfd_check_format (file
, bfd_archive
) == true)
2181 bfd
*last_arfile
= NULL
;
2183 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2186 bfd_set_error (bfd_error_no_error
);
2188 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2191 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2192 nonfatal (bfd_get_filename (file
));
2196 display_bfd (arfile
);
2198 if (last_arfile
!= NULL
)
2199 bfd_close (last_arfile
);
2200 last_arfile
= arfile
;
2203 if (last_arfile
!= NULL
)
2204 bfd_close (last_arfile
);
2212 /* Actually display the various requested regions */
2220 bfd_size_type datasize
= 0;
2221 bfd_size_type addr_offset
;
2222 bfd_size_type start_offset
, stop_offset
;
2223 unsigned int opb
= bfd_octets_per_byte (abfd
);
2225 for (section
= abfd
->sections
; section
!= NULL
; section
=
2230 if (only
== (char *) NULL
||
2231 strcmp (only
, section
->name
) == 0)
2233 if (section
->flags
& SEC_HAS_CONTENTS
)
2235 printf (_("Contents of section %s:\n"), section
->name
);
2237 if (bfd_section_size (abfd
, section
) == 0)
2239 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2240 datasize
= bfd_section_size (abfd
, section
);
2243 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2245 if (start_address
== (bfd_vma
) -1
2246 || start_address
< section
->vma
)
2249 start_offset
= start_address
- section
->vma
;
2250 if (stop_address
== (bfd_vma
) -1)
2251 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2254 if (stop_address
< section
->vma
)
2257 stop_offset
= stop_address
- section
->vma
;
2258 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2259 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2261 for (addr_offset
= start_offset
;
2262 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2266 printf (" %04lx ", (unsigned long int)
2267 (addr_offset
+ section
->vma
));
2268 for (j
= addr_offset
* opb
;
2269 j
< addr_offset
* opb
+ onaline
; j
++)
2271 if (j
< stop_offset
* opb
)
2272 printf ("%02x", (unsigned) (data
[j
]));
2280 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2282 if (j
>= stop_offset
* opb
)
2285 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2295 /* Should perhaps share code and display with nm? */
2297 dump_symbols (abfd
, dynamic
)
2298 bfd
*abfd ATTRIBUTE_UNUSED
;
2311 printf ("DYNAMIC SYMBOL TABLE:\n");
2319 printf ("SYMBOL TABLE:\n");
2322 for (count
= 0; count
< max
; count
++)
2326 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2328 if (cur_bfd
!= NULL
)
2333 name
= bfd_asymbol_name (*current
);
2335 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2339 /* If we want to demangle the name, we demangle it
2340 here, and temporarily clobber it while calling
2341 bfd_print_symbol. FIXME: This is a gross hack. */
2344 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2346 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2348 (*current
)->name
= alloc
;
2350 (*current
)->name
= n
;
2353 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2354 bfd_print_symbol_all
);
2356 (*current
)->name
= name
;
2377 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2381 if (bfd_is_abs_section (a
))
2383 if (bfd_is_und_section (a
))
2385 if (bfd_is_com_section (a
))
2390 if (strcmp (only
, a
->name
))
2393 else if ((a
->flags
& SEC_RELOC
) == 0)
2396 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2398 bfd_fatal (bfd_get_filename (abfd
));
2400 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2404 printf (" (none)\n\n");
2408 relpp
= (arelent
**) xmalloc (relsize
);
2409 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2411 bfd_fatal (bfd_get_filename (abfd
));
2412 else if (relcount
== 0)
2414 printf (" (none)\n\n");
2419 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2428 dump_dynamic_relocs (abfd
)
2435 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2437 bfd_fatal (bfd_get_filename (abfd
));
2439 printf ("DYNAMIC RELOCATION RECORDS");
2443 printf (" (none)\n\n");
2447 relpp
= (arelent
**) xmalloc (relsize
);
2448 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2450 bfd_fatal (bfd_get_filename (abfd
));
2451 else if (relcount
== 0)
2453 printf (" (none)\n\n");
2458 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2466 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2473 char *last_filename
, *last_functionname
;
2474 unsigned int last_line
;
2476 /* Get column headers lined up reasonably. */
2482 sprintf_vma (buf
, (bfd_vma
) -1);
2483 width
= strlen (buf
) - 7;
2485 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2488 last_filename
= NULL
;
2489 last_functionname
= NULL
;
2492 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2495 const char *filename
, *functionname
;
2497 const char *sym_name
;
2498 const char *section_name
;
2500 if (start_address
!= (bfd_vma
) -1
2501 && q
->address
< start_address
)
2503 if (stop_address
!= (bfd_vma
) -1
2504 && q
->address
> stop_address
)
2507 if (with_line_numbers
2509 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2510 &filename
, &functionname
, &line
))
2512 if (functionname
!= NULL
2513 && (last_functionname
== NULL
2514 || strcmp (functionname
, last_functionname
) != 0))
2516 printf ("%s():\n", functionname
);
2517 if (last_functionname
!= NULL
)
2518 free (last_functionname
);
2519 last_functionname
= xstrdup (functionname
);
2522 && (line
!= last_line
2523 || (filename
!= NULL
2524 && last_filename
!= NULL
2525 && strcmp (filename
, last_filename
) != 0)))
2527 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2529 if (last_filename
!= NULL
)
2530 free (last_filename
);
2531 if (filename
== NULL
)
2532 last_filename
= NULL
;
2534 last_filename
= xstrdup (filename
);
2538 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2540 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2541 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2546 section_name
= NULL
;
2550 printf_vma (q
->address
);
2552 printf (" %-16s ", q
->howto
->name
);
2554 printf (" %-16d ", q
->howto
->type
);
2555 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2560 if (section_name
== (CONST
char *) NULL
)
2561 section_name
= "*unknown*";
2562 printf_vma (q
->address
);
2563 printf (" %-16s [%s]",
2570 printf_vma (q
->addend
);
2576 /* The length of the longest architecture name + 1. */
2577 #define LONGEST_ARCH sizeof("powerpc:common")
2580 endian_string (endian
)
2581 enum bfd_endian endian
;
2583 if (endian
== BFD_ENDIAN_BIG
)
2584 return "big endian";
2585 else if (endian
== BFD_ENDIAN_LITTLE
)
2586 return "little endian";
2588 return "endianness unknown";
2591 /* List the targets that BFD is configured to support, each followed
2592 by its endianness and the architectures it supports. */
2595 display_target_list ()
2597 extern const bfd_target
*const *bfd_target_vector
;
2601 dummy_name
= make_temp_file (NULL
);
2602 for (t
= 0; bfd_target_vector
[t
]; t
++)
2604 const bfd_target
*p
= bfd_target_vector
[t
];
2605 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2608 printf ("%s\n (header %s, data %s)\n", p
->name
,
2609 endian_string (p
->header_byteorder
),
2610 endian_string (p
->byteorder
));
2614 nonfatal (dummy_name
);
2618 if (! bfd_set_format (abfd
, bfd_object
))
2620 if (bfd_get_error () != bfd_error_invalid_operation
)
2622 bfd_close_all_done (abfd
);
2626 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2627 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2629 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2630 bfd_close_all_done (abfd
);
2632 unlink (dummy_name
);
2636 /* Print a table showing which architectures are supported for entries
2637 FIRST through LAST-1 of bfd_target_vector (targets across,
2638 architectures down). */
2641 display_info_table (first
, last
)
2645 extern const bfd_target
*const *bfd_target_vector
;
2649 /* Print heading of target names. */
2650 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2651 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2652 printf ("%s ", bfd_target_vector
[t
]->name
);
2655 dummy_name
= make_temp_file (NULL
);
2656 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2657 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2659 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2660 bfd_printable_arch_mach (a
, 0));
2661 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2663 const bfd_target
*p
= bfd_target_vector
[t
];
2665 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2675 if (! bfd_set_format (abfd
, bfd_object
))
2677 if (bfd_get_error () != bfd_error_invalid_operation
)
2685 if (! bfd_set_arch_mach (abfd
, a
, 0))
2690 printf ("%s ", p
->name
);
2693 int l
= strlen (p
->name
);
2699 bfd_close_all_done (abfd
);
2703 unlink (dummy_name
);
2707 /* Print tables of all the target-architecture combinations that
2708 BFD has been configured to support. */
2711 display_target_tables ()
2714 extern const bfd_target
*const *bfd_target_vector
;
2718 colum
= getenv ("COLUMNS");
2720 columns
= atoi (colum
);
2725 while (bfd_target_vector
[t
] != NULL
)
2729 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2731 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2735 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2736 if (newwid
>= columns
)
2741 display_info_table (oldt
, t
);
2748 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2749 display_target_list ();
2750 display_target_tables ();
2759 char *target
= default_target
;
2760 boolean seenflag
= false;
2762 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2763 setlocale (LC_MESSAGES
, "");
2765 bindtextdomain (PACKAGE
, LOCALEDIR
);
2766 textdomain (PACKAGE
);
2768 program_name
= *argv
;
2769 xmalloc_set_program_name (program_name
);
2771 START_PROGRESS (program_name
, 0);
2774 set_default_bfd_target ();
2776 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2777 long_options
, (int *) 0))
2783 break; /* we've been given a long option */
2788 disassembler_options
= optarg
;
2794 with_line_numbers
= true;
2803 enum demangling_styles style
;
2805 style
= cplus_demangle_name_to_style (optarg
);
2806 if (style
== unknown_demangling
)
2807 fatal (_("unknown demangling style `%s'"),
2810 cplus_demangle_set_style (style
);
2816 case OPTION_ADJUST_VMA
:
2817 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2819 case OPTION_START_ADDRESS
:
2820 start_address
= parse_vma (optarg
, "--start-address");
2822 case OPTION_STOP_ADDRESS
:
2823 stop_address
= parse_vma (optarg
, "--stop-address");
2826 if (strcmp (optarg
, "B") == 0)
2827 endian
= BFD_ENDIAN_BIG
;
2828 else if (strcmp (optarg
, "L") == 0)
2829 endian
= BFD_ENDIAN_LITTLE
;
2832 non_fatal (_("unrecognized -E option"));
2837 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2838 endian
= BFD_ENDIAN_BIG
;
2839 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2840 endian
= BFD_ENDIAN_LITTLE
;
2843 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2849 dump_file_header
= true;
2853 formats_info
= true;
2857 dump_private_headers
= true;
2861 dump_private_headers
= true;
2863 dump_reloc_info
= true;
2864 dump_file_header
= true;
2865 dump_ar_hdrs
= true;
2866 dump_section_headers
= true;
2874 dump_dynamic_symtab
= true;
2882 disassemble_zeroes
= true;
2886 disassemble_all
= true;
2891 with_source_code
= true;
2899 dump_stab_section_info
= true;
2903 dump_section_contents
= true;
2907 dump_reloc_info
= true;
2911 dump_dynamic_reloc_info
= true;
2915 dump_ar_hdrs
= true;
2919 dump_section_headers
= true;
2926 show_version
= true;
2936 print_version ("objdump");
2938 if (seenflag
== false)
2946 display_file ("a.out", target
);
2948 for (; optind
< argc
;)
2949 display_file (argv
[optind
++], target
);
2952 END_PROGRESS (program_name
);