1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "libiberty.h"
32 #ifdef ANSI_PROTOTYPES
38 /* Internal headers for the ELF .stab-dump code - sorry. */
39 #define BYTES_IN_WORD 32
40 #include "aout/aout64.h"
42 #ifdef NEED_DECLARATION_FPRINTF
43 /* This is needed by INIT_DISASSEMBLE_INFO. */
44 extern int fprintf
PARAMS ((FILE *, const char *, ...));
48 static int exit_status
= 0;
50 static char *default_target
= NULL
; /* default at runtime */
52 static int show_version
= 0; /* show the version number */
53 static int dump_section_contents
; /* -s */
54 static int dump_section_headers
; /* -h */
55 static boolean dump_file_header
; /* -f */
56 static int dump_symtab
; /* -t */
57 static int dump_dynamic_symtab
; /* -T */
58 static int dump_reloc_info
; /* -r */
59 static int dump_dynamic_reloc_info
; /* -R */
60 static int dump_ar_hdrs
; /* -a */
61 static int dump_private_headers
; /* -p */
62 static int prefix_addresses
; /* --prefix-addresses */
63 static int with_line_numbers
; /* -l */
64 static boolean with_source_code
; /* -S */
65 static int show_raw_insn
; /* --show-raw-insn */
66 static int dump_stab_section_info
; /* --stabs */
67 static int do_demangle
; /* -C, --demangle */
68 static boolean disassemble
; /* -d */
69 static boolean disassemble_all
; /* -D */
70 static int disassemble_zeroes
; /* --disassemble-zeroes */
71 static boolean formats_info
; /* -i */
72 static char *only
; /* -j secname */
73 static int wide_output
; /* -w */
74 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
75 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
76 static int dump_debugging
; /* --debugging */
77 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
78 static int file_start_context
= 0; /* --file-start-context */
80 /* Extra info to pass to the disassembler address printing function. */
81 struct objdump_disasm_info
{
87 /* Architecture to disassemble for, or default if NULL. */
88 static char *machine
= (char *) NULL
;
90 /* Target specific options to the disassembler. */
91 static char *disassembler_options
= (char *) NULL
;
93 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
94 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
96 /* The symbol table. */
97 static asymbol
**syms
;
99 /* Number of symbols in `syms'. */
100 static long symcount
= 0;
102 /* The sorted symbol table. */
103 static asymbol
**sorted_syms
;
105 /* Number of symbols in `sorted_syms'. */
106 static long sorted_symcount
= 0;
108 /* The dynamic symbol table. */
109 static asymbol
**dynsyms
;
111 /* Number of symbols in `dynsyms'. */
112 static long dynsymcount
= 0;
114 /* Static declarations. */
117 usage
PARAMS ((FILE *, int));
120 nonfatal
PARAMS ((const char *));
123 display_file
PARAMS ((char *filename
, char *target
));
126 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
129 dump_headers
PARAMS ((bfd
*));
132 dump_data
PARAMS ((bfd
*abfd
));
135 dump_relocs
PARAMS ((bfd
*abfd
));
138 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
141 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
144 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
147 dump_bfd_header
PARAMS ((bfd
*));
150 dump_bfd_private_header
PARAMS ((bfd
*));
153 display_bfd
PARAMS ((bfd
*abfd
));
156 display_target_list
PARAMS ((void));
159 display_info_table
PARAMS ((int, int));
162 display_target_tables
PARAMS ((void));
165 display_info
PARAMS ((void));
168 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
171 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
174 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
177 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
178 struct disassemble_info
*, boolean
));
181 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
184 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
187 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
190 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
191 boolean
, bfd_byte
*, bfd_vma
, bfd_vma
,
192 arelent
***, arelent
**));
195 disassemble_data
PARAMS ((bfd
*));
198 endian_string
PARAMS ((enum bfd_endian
));
201 slurp_symtab
PARAMS ((bfd
*));
204 slurp_dynamic_symtab
PARAMS ((bfd
*));
207 remove_useless_symbols
PARAMS ((asymbol
**, long));
210 compare_symbols
PARAMS ((const PTR
, const PTR
));
213 compare_relocs
PARAMS ((const PTR
, const PTR
));
216 dump_stabs
PARAMS ((bfd
*));
219 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
222 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
225 usage (stream
, status
)
229 fprintf (stream
, _("Usage: %s <switches> file(s)\n"), program_name
);
230 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
231 fprintf (stream
, _("\
232 -a --archive-headers Display archive header information\n\
233 -f --file-headers Display the contents of the overall file header\n\
234 -p --private-headers Display object format specific file header contents\n\
235 -h --[section-]headers Display the contents of the section headers\n\
236 -x --all-headers Display the contents of all headers\n\
237 -d --disassemble Display assembler contents of executable sections\n\
238 -D --disassemble-all Display assembler contents of all sections\n\
239 -S --source Intermix source code with disassembly\n\
240 -s --full-contents Display the full contents of all sections requested\n\
241 -g --debugging Display debug information in object file\n\
242 -G --stabs Display the STABS contents of an ELF format file\n\
243 -t --syms Display the contents of the symbol table(s)\n\
244 -T --dynamic-syms Display the contents of the dynamic symbol table\n\
245 -r --reloc Display the relocation entries in the file\n\
246 -R --dynamic-reloc Display the dynamic relocation entries in the file\n\
247 -V --version Display this program's version number\n\
248 -i --info List object formats and architectures supported\n\
249 -H --help Display this information\n\
253 fprintf (stream
, _("\n The following switches are optional:\n"));
254 fprintf (stream
, _("\
255 -b --target <bfdname> Specify the target object format as <bfdname>\n\
256 -m --architecture <machine> Specify the target architecture as <machine>\n\
257 -j --section <name> Only display information for section <name>\n\
258 -M --disassembler-options <o> Pass text <o> on to the disassembler\n\
259 -EB --endian=big Assume big endian format when disassembling\n\
260 -EL --endian=little Assume little endian format when disassembling\n\
261 --file-start-context Include context from start of file (with -S)\n\
262 -l --line-numbers Include line numbers and filenames in output\n\
263 -C --demangle Decode mangled/processed symbol names\n\
264 -w --wide Format output for more than 80 columns\n\
265 -z --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
266 --start-address <addr> Only process data whoes address is >= <addr>\n\
267 --stop-address <addr> Only process data whoes address is <= <addr>\n\
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
270 --adjust-vma <offset> Add <offset> to all displayed section addresses\n\
272 list_supported_targets (program_name
, stream
);
274 disassembler_usage (stream
);
277 fprintf (stream
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
281 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
283 #define OPTION_ENDIAN (150)
284 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
285 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
286 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
288 static struct option long_options
[]=
290 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
291 {"all-headers", no_argument
, NULL
, 'x'},
292 {"private-headers", no_argument
, NULL
, 'p'},
293 {"architecture", required_argument
, NULL
, 'm'},
294 {"archive-headers", no_argument
, NULL
, 'a'},
295 {"debugging", no_argument
, NULL
, 'g'},
296 {"demangle", no_argument
, NULL
, 'C'},
297 {"disassemble", no_argument
, NULL
, 'd'},
298 {"disassemble-all", no_argument
, NULL
, 'D'},
299 {"disassembler-options", required_argument
, NULL
, 'M'},
300 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
301 {"dynamic-reloc", no_argument
, NULL
, 'R'},
302 {"dynamic-syms", no_argument
, NULL
, 'T'},
303 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
304 {"file-headers", no_argument
, NULL
, 'f'},
305 {"file-start-context", no_argument
, &file_start_context
, 1},
306 {"full-contents", no_argument
, NULL
, 's'},
307 {"headers", no_argument
, NULL
, 'h'},
308 {"help", no_argument
, NULL
, 'H'},
309 {"info", no_argument
, NULL
, 'i'},
310 {"line-numbers", no_argument
, NULL
, 'l'},
311 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
312 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
313 {"reloc", no_argument
, NULL
, 'r'},
314 {"section", required_argument
, NULL
, 'j'},
315 {"section-headers", no_argument
, NULL
, 'h'},
316 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
317 {"source", no_argument
, NULL
, 'S'},
318 {"stabs", no_argument
, NULL
, 'G'},
319 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
320 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
321 {"syms", no_argument
, NULL
, 't'},
322 {"target", required_argument
, NULL
, 'b'},
323 {"version", no_argument
, NULL
, 'V'},
324 {"wide", no_argument
, NULL
, 'w'},
325 {0, no_argument
, 0, 0}
337 dump_section_header (abfd
, section
, ignored
)
338 bfd
*abfd ATTRIBUTE_UNUSED
;
340 PTR ignored ATTRIBUTE_UNUSED
;
343 unsigned int opb
= bfd_octets_per_byte (abfd
);
345 printf ("%3d %-13s %08lx ", section
->index
,
346 bfd_get_section_name (abfd
, section
),
347 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
348 printf_vma (bfd_get_section_vma (abfd
, section
));
350 printf_vma (section
->lma
);
351 printf (" %08lx 2**%u", section
->filepos
,
352 bfd_get_section_alignment (abfd
, section
));
358 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
360 PF (SEC_HAS_CONTENTS
, "CONTENTS");
361 PF (SEC_ALLOC
, "ALLOC");
362 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
363 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
364 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
365 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
366 PF (SEC_LOAD
, "LOAD");
367 PF (SEC_RELOC
, "RELOC");
369 PF (SEC_BALIGN
, "BALIGN");
371 PF (SEC_READONLY
, "READONLY");
372 PF (SEC_CODE
, "CODE");
373 PF (SEC_DATA
, "DATA");
375 PF (SEC_DEBUGGING
, "DEBUGGING");
376 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
377 PF (SEC_EXCLUDE
, "EXCLUDE");
378 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
379 PF (SEC_BLOCK
, "BLOCK");
380 PF (SEC_CLINK
, "CLINK");
381 PF (SEC_SMALL_DATA
, "SMALL_DATA");
382 PF (SEC_SHARED
, "SHARED");
384 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
388 switch (section
->flags
& SEC_LINK_DUPLICATES
)
392 case SEC_LINK_DUPLICATES_DISCARD
:
393 ls
= "LINK_ONCE_DISCARD";
395 case SEC_LINK_DUPLICATES_ONE_ONLY
:
396 ls
= "LINK_ONCE_ONE_ONLY";
398 case SEC_LINK_DUPLICATES_SAME_SIZE
:
399 ls
= "LINK_ONCE_SAME_SIZE";
401 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
402 ls
= "LINK_ONCE_SAME_CONTENTS";
405 printf ("%s%s", comma
, ls
);
407 if (section
->comdat
!= NULL
)
408 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
409 section
->comdat
->symbol
);
422 printf (_("Sections:\n"));
425 printf (_("Idx Name Size VMA LMA File off Algn"));
427 printf (_("Idx Name Size VMA LMA File off Algn"));
431 printf (_(" Flags"));
434 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
441 asymbol
**sy
= (asymbol
**) NULL
;
444 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
446 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
451 storage
= bfd_get_symtab_upper_bound (abfd
);
453 bfd_fatal (bfd_get_filename (abfd
));
457 sy
= (asymbol
**) xmalloc (storage
);
459 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
461 bfd_fatal (bfd_get_filename (abfd
));
463 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
467 /* Read in the dynamic symbols. */
470 slurp_dynamic_symtab (abfd
)
473 asymbol
**sy
= (asymbol
**) NULL
;
476 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
479 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
481 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
486 bfd_fatal (bfd_get_filename (abfd
));
491 sy
= (asymbol
**) xmalloc (storage
);
493 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
495 bfd_fatal (bfd_get_filename (abfd
));
496 if (dynsymcount
== 0)
497 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
501 /* Filter out (in place) symbols that are useless for disassembly.
502 COUNT is the number of elements in SYMBOLS.
503 Return the number of useful symbols. */
506 remove_useless_symbols (symbols
, count
)
510 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
514 asymbol
*sym
= *in_ptr
++;
516 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
518 if (sym
->flags
& (BSF_DEBUGGING
))
520 if (bfd_is_und_section (sym
->section
)
521 || bfd_is_com_section (sym
->section
))
526 return out_ptr
- symbols
;
529 /* Sort symbols into value order. */
532 compare_symbols (ap
, bp
)
536 const asymbol
*a
= *(const asymbol
**)ap
;
537 const asymbol
*b
= *(const asymbol
**)bp
;
541 flagword aflags
, bflags
;
543 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
545 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
548 if (a
->section
> b
->section
)
550 else if (a
->section
< b
->section
)
553 an
= bfd_asymbol_name (a
);
554 bn
= bfd_asymbol_name (b
);
558 /* The symbols gnu_compiled and gcc2_compiled convey no real
559 information, so put them after other symbols with the same value. */
561 af
= (strstr (an
, "gnu_compiled") != NULL
562 || strstr (an
, "gcc2_compiled") != NULL
);
563 bf
= (strstr (bn
, "gnu_compiled") != NULL
564 || strstr (bn
, "gcc2_compiled") != NULL
);
571 /* We use a heuristic for the file name, to try to sort it after
572 more useful symbols. It may not work on non Unix systems, but it
573 doesn't really matter; the only difference is precisely which
574 symbol names get printed. */
576 #define file_symbol(s, sn, snl) \
577 (((s)->flags & BSF_FILE) != 0 \
578 || ((sn)[(snl) - 2] == '.' \
579 && ((sn)[(snl) - 1] == 'o' \
580 || (sn)[(snl) - 1] == 'a')))
582 af
= file_symbol (a
, an
, anl
);
583 bf
= file_symbol (b
, bn
, bnl
);
590 /* Try to sort global symbols before local symbols before function
591 symbols before debugging symbols. */
596 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
598 if ((aflags
& BSF_DEBUGGING
) != 0)
603 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
605 if ((aflags
& BSF_FUNCTION
) != 0)
610 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
612 if ((aflags
& BSF_LOCAL
) != 0)
617 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
619 if ((aflags
& BSF_GLOBAL
) != 0)
625 /* Symbols that start with '.' might be section names, so sort them
626 after symbols that don't start with '.'. */
627 if (an
[0] == '.' && bn
[0] != '.')
629 if (an
[0] != '.' && bn
[0] == '.')
632 /* Finally, if we can't distinguish them in any other way, try to
633 get consistent results by sorting the symbols by name. */
634 return strcmp (an
, bn
);
637 /* Sort relocs into address order. */
640 compare_relocs (ap
, bp
)
644 const arelent
*a
= *(const arelent
**)ap
;
645 const arelent
*b
= *(const arelent
**)bp
;
647 if (a
->address
> b
->address
)
649 else if (a
->address
< b
->address
)
652 /* So that associated relocations tied to the same address show up
653 in the correct order, we don't do any further sorting. */
662 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
665 objdump_print_value (vma
, info
, skip_zeroes
)
667 struct disassemble_info
*info
;
673 sprintf_vma (buf
, vma
);
678 for (p
= buf
; *p
== '0'; ++p
)
683 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
686 /* Print the name of a symbol. */
689 objdump_print_symname (abfd
, info
, sym
)
691 struct disassemble_info
*info
;
699 name
= bfd_asymbol_name (sym
);
700 if (! do_demangle
|| name
[0] == '\0')
704 /* Demangle the name. */
705 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
708 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
716 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
718 printf ("%s", print
);
724 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
725 is true, then always require the symbol to be in the section. This
726 returns NULL if there is no suitable symbol. If PLACE is not NULL,
727 then *PLACE is set to the index of the symbol in sorted_syms. */
730 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
737 /* @@ Would it speed things up to cache the last two symbols returned,
738 and maybe their address ranges? For many processors, only one memory
739 operand can be present at a time, so the 2-entry cache wouldn't be
740 constantly churned by code doing heavy memory accesses. */
742 /* Indices in `sorted_syms'. */
744 long max
= sorted_symcount
;
746 unsigned int opb
= bfd_octets_per_byte (abfd
);
748 if (sorted_symcount
< 1)
751 /* Perform a binary search looking for the closest symbol to the
752 required value. We are searching the range (min, max]. */
753 while (min
+ 1 < max
)
757 thisplace
= (max
+ min
) / 2;
758 sym
= sorted_syms
[thisplace
];
760 if (bfd_asymbol_value (sym
) > vma
)
762 else if (bfd_asymbol_value (sym
) < vma
)
771 /* The symbol we want is now in min, the low end of the range we
772 were searching. If there are several symbols with the same
773 value, we want the first one. */
776 && (bfd_asymbol_value (sorted_syms
[thisplace
])
777 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
780 /* If the file is relocateable, and the symbol could be from this
781 section, prefer a symbol from this section over symbols from
782 others, even if the other symbol's value might be closer.
784 Note that this may be wrong for some symbol references if the
785 sections have overlapping memory ranges, but in that case there's
786 no way to tell what's desired without looking at the relocation
789 if (sorted_syms
[thisplace
]->section
!= sec
791 || ((abfd
->flags
& HAS_RELOC
) != 0
792 && vma
>= bfd_get_section_vma (abfd
, sec
)
793 && vma
< (bfd_get_section_vma (abfd
, sec
)
794 + bfd_section_size (abfd
, sec
) / opb
))))
798 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
800 if (bfd_asymbol_value (sorted_syms
[i
])
801 != bfd_asymbol_value (sorted_syms
[thisplace
]))
807 if (sorted_syms
[i
]->section
== sec
809 || sorted_syms
[i
- 1]->section
!= sec
810 || (bfd_asymbol_value (sorted_syms
[i
])
811 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
818 if (sorted_syms
[thisplace
]->section
!= sec
)
820 /* We didn't find a good symbol with a smaller value.
821 Look for one with a larger value. */
822 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
824 if (sorted_syms
[i
]->section
== sec
)
832 if (sorted_syms
[thisplace
]->section
!= sec
834 || ((abfd
->flags
& HAS_RELOC
) != 0
835 && vma
>= bfd_get_section_vma (abfd
, sec
)
836 && vma
< (bfd_get_section_vma (abfd
, sec
)
837 + bfd_section_size (abfd
, sec
)))))
839 /* There is no suitable symbol. */
847 return sorted_syms
[thisplace
];
850 /* Print an address to INFO symbolically. */
853 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
858 struct disassemble_info
*info
;
861 objdump_print_value (vma
, info
, skip_zeroes
);
867 (*info
->fprintf_func
) (info
->stream
, " <%s",
868 bfd_get_section_name (abfd
, sec
));
869 secaddr
= bfd_get_section_vma (abfd
, sec
);
872 (*info
->fprintf_func
) (info
->stream
, "-0x");
873 objdump_print_value (secaddr
- vma
, info
, true);
875 else if (vma
> secaddr
)
877 (*info
->fprintf_func
) (info
->stream
, "+0x");
878 objdump_print_value (vma
- secaddr
, info
, true);
880 (*info
->fprintf_func
) (info
->stream
, ">");
884 (*info
->fprintf_func
) (info
->stream
, " <");
885 objdump_print_symname (abfd
, info
, sym
);
886 if (bfd_asymbol_value (sym
) > vma
)
888 (*info
->fprintf_func
) (info
->stream
, "-0x");
889 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
891 else if (vma
> bfd_asymbol_value (sym
))
893 (*info
->fprintf_func
) (info
->stream
, "+0x");
894 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
896 (*info
->fprintf_func
) (info
->stream
, ">");
900 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
901 true, don't output leading zeroes. */
904 objdump_print_addr (vma
, info
, skip_zeroes
)
906 struct disassemble_info
*info
;
909 struct objdump_disasm_info
*aux
;
912 if (sorted_symcount
< 1)
914 (*info
->fprintf_func
) (info
->stream
, "0x");
915 objdump_print_value (vma
, info
, skip_zeroes
);
919 aux
= (struct objdump_disasm_info
*) info
->application_data
;
920 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
922 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
926 /* Print VMA to INFO. This function is passed to the disassembler
930 objdump_print_address (vma
, info
)
932 struct disassemble_info
*info
;
934 objdump_print_addr (vma
, info
, ! prefix_addresses
);
937 /* Determine of the given address has a symbol associated with it. */
940 objdump_symbol_at_address (vma
, info
)
942 struct disassemble_info
* info
;
944 struct objdump_disasm_info
* aux
;
947 /* No symbols - do not bother checking. */
948 if (sorted_symcount
< 1)
951 aux
= (struct objdump_disasm_info
*) info
->application_data
;
952 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
955 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
958 /* Hold the last function name and the last line number we displayed
961 static char *prev_functionname
;
962 static unsigned int prev_line
;
964 /* We keep a list of all files that we have seen when doing a
965 dissassembly with source, so that we know how much of the file to
966 display. This can be important for inlined functions. */
968 struct print_file_list
970 struct print_file_list
*next
;
976 static struct print_file_list
*print_files
;
978 /* The number of preceding context lines to show when we start
979 displaying a file for the first time. */
981 #define SHOW_PRECEDING_CONTEXT_LINES (5)
983 /* Skip ahead to a given line in a file, optionally printing each
987 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
990 skip_to_line (p
, line
, show
)
991 struct print_file_list
*p
;
995 while (p
->line
< line
)
999 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1009 if (strchr (buf
, '\n') != NULL
)
1014 /* Show the line number, or the source line, in a dissassembly
1018 show_line (abfd
, section
, addr_offset
)
1021 bfd_vma addr_offset
;
1023 CONST
char *filename
;
1024 CONST
char *functionname
;
1027 if (! with_line_numbers
&& ! with_source_code
)
1030 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1031 &functionname
, &line
))
1034 if (filename
!= NULL
&& *filename
== '\0')
1036 if (functionname
!= NULL
&& *functionname
== '\0')
1037 functionname
= NULL
;
1039 if (with_line_numbers
)
1041 if (functionname
!= NULL
1042 && (prev_functionname
== NULL
1043 || strcmp (functionname
, prev_functionname
) != 0))
1044 printf ("%s():\n", functionname
);
1045 if (line
> 0 && line
!= prev_line
)
1046 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1049 if (with_source_code
1053 struct print_file_list
**pp
, *p
;
1055 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1056 if (strcmp ((*pp
)->filename
, filename
) == 0)
1062 if (p
!= print_files
)
1066 /* We have reencountered a file name which we saw
1067 earlier. This implies that either we are dumping out
1068 code from an included file, or the same file was
1069 linked in more than once. There are two common cases
1070 of an included file: inline functions in a header
1071 file, and a bison or flex skeleton file. In the
1072 former case we want to just start printing (but we
1073 back up a few lines to give context); in the latter
1074 case we want to continue from where we left off. I
1075 can't think of a good way to distinguish the cases,
1076 so I used a heuristic based on the file name. */
1077 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1081 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1088 p
->f
= fopen (p
->filename
, "r");
1092 skip_to_line (p
, l
, false);
1094 if (print_files
->f
!= NULL
)
1096 fclose (print_files
->f
);
1097 print_files
->f
= NULL
;
1103 skip_to_line (p
, line
, true);
1105 p
->next
= print_files
;
1113 f
= fopen (filename
, "r");
1118 p
= ((struct print_file_list
*)
1119 xmalloc (sizeof (struct print_file_list
)));
1120 p
->filename
= xmalloc (strlen (filename
) + 1);
1121 strcpy (p
->filename
, filename
);
1125 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1127 fclose (print_files
->f
);
1128 print_files
->f
= NULL
;
1130 p
->next
= print_files
;
1133 if (file_start_context
)
1136 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1139 skip_to_line (p
, l
, false);
1141 skip_to_line (p
, line
, true);
1146 if (functionname
!= NULL
1147 && (prev_functionname
== NULL
1148 || strcmp (functionname
, prev_functionname
) != 0))
1150 if (prev_functionname
!= NULL
)
1151 free (prev_functionname
);
1152 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1153 strcpy (prev_functionname
, functionname
);
1156 if (line
> 0 && line
!= prev_line
)
1160 /* Pseudo FILE object for strings. */
1168 /* sprintf to a "stream" */
1171 #ifdef ANSI_PROTOTYPES
1172 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1174 objdump_sprintf (va_alist
)
1178 #ifndef ANSI_PROTOTYPES
1186 #ifdef ANSI_PROTOTYPES
1187 va_start (args
, format
);
1190 f
= va_arg (args
, SFILE
*);
1191 format
= va_arg (args
, const char *);
1194 vasprintf (&buf
, format
, args
);
1200 fatal (_("Out of virtual memory"));
1205 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1209 curroff
= f
->current
- f
->buffer
;
1211 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1212 f
->current
= f
->buffer
+ curroff
;
1215 memcpy (f
->current
, buf
, n
);
1217 f
->current
[0] = '\0';
1224 /* The number of zeroes we want to see before we start skipping them.
1225 The number is arbitrarily chosen. */
1227 #define SKIP_ZEROES (8)
1229 /* The number of zeroes to skip at the end of a section. If the
1230 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1231 SKIP_ZEROES, they will be disassembled. If there are fewer than
1232 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1233 attempt to avoid disassembling zeroes inserted by section
1236 #define SKIP_ZEROES_AT_END (3)
1238 /* Disassemble some data in memory between given values. */
1241 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1242 start_offset
, stop_offset
, relppp
,
1244 struct disassemble_info
*info
;
1245 disassembler_ftype disassemble_fn
;
1248 bfd_vma start_offset
;
1249 bfd_vma stop_offset
;
1253 struct objdump_disasm_info
*aux
;
1255 int octets_per_line
;
1257 int skip_addr_chars
;
1258 bfd_vma addr_offset
;
1259 int opb
= info
->octets_per_byte
;
1261 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1265 octets_per_line
= 4;
1267 octets_per_line
= 16;
1269 /* Figure out how many characters to skip at the start of an
1270 address, to make the disassembly look nicer. We discard leading
1271 zeroes in chunks of 4, ensuring that there is always a leading
1273 skip_addr_chars
= 0;
1274 if (! prefix_addresses
)
1279 sprintf_vma (buf
, section
->vma
+
1280 bfd_section_size (section
->owner
, section
) / opb
);
1282 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1285 skip_addr_chars
+= 4;
1290 info
->insn_info_valid
= 0;
1293 addr_offset
= start_offset
;
1294 while (addr_offset
< stop_offset
)
1298 boolean need_nl
= false;
1300 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1302 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1305 if (! disassemble_zeroes
1306 && (info
->insn_info_valid
== 0
1307 || info
->branch_delay_insns
== 0)
1308 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1309 || (z
== stop_offset
* opb
&&
1310 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1314 /* If there are more nonzero octets to follow, we only skip
1315 zeroes in multiples of 4, to try to avoid running over
1316 the start of an instruction which happens to start with
1318 if (z
!= stop_offset
* opb
)
1319 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1321 octets
= z
- addr_offset
* opb
;
1332 if (with_line_numbers
|| with_source_code
)
1333 show_line (aux
->abfd
, section
, addr_offset
);
1335 if (! prefix_addresses
)
1339 sprintf_vma (buf
, section
->vma
+ addr_offset
);
1340 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1344 printf ("%s:\t", buf
+ skip_addr_chars
);
1348 aux
->require_sec
= true;
1349 objdump_print_address (section
->vma
+ addr_offset
, info
);
1350 aux
->require_sec
= false;
1357 sfile
.buffer
= xmalloc (sfile
.size
);
1358 sfile
.current
= sfile
.buffer
;
1359 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1360 info
->stream
= (FILE *) &sfile
;
1361 info
->bytes_per_line
= 0;
1362 info
->bytes_per_chunk
= 0;
1364 /* FIXME: This is wrong. It tests the number of octets
1365 in the last instruction, not the current one. */
1366 if (*relppp
< relppend
1367 && (**relppp
)->address
>= addr_offset
1368 && (**relppp
)->address
< addr_offset
+ octets
/ opb
)
1369 info
->flags
= INSN_HAS_RELOC
;
1373 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1374 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1375 info
->stream
= stdout
;
1376 if (info
->bytes_per_line
!= 0)
1377 octets_per_line
= info
->bytes_per_line
;
1380 if (sfile
.current
!= sfile
.buffer
)
1381 printf ("%s\n", sfile
.buffer
);
1382 free (sfile
.buffer
);
1390 octets
= octets_per_line
;
1391 if (addr_offset
+ octets
/ opb
> stop_offset
)
1392 octets
= (stop_offset
- addr_offset
) * opb
;
1394 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1396 if (isprint (data
[j
]))
1397 buf
[j
- addr_offset
* opb
] = data
[j
];
1399 buf
[j
- addr_offset
* opb
] = '.';
1401 buf
[j
- addr_offset
* opb
] = '\0';
1404 if (prefix_addresses
1406 : show_raw_insn
>= 0)
1410 /* If ! prefix_addresses and ! wide_output, we print
1411 octets_per_line octets per line. */
1413 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1414 pb
= octets_per_line
;
1416 if (info
->bytes_per_chunk
)
1417 bpc
= info
->bytes_per_chunk
;
1421 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1424 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1426 for (k
= bpc
- 1; k
>= 0; k
--)
1427 printf ("%02x", (unsigned) data
[j
+ k
]);
1432 for (k
= 0; k
< bpc
; k
++)
1433 printf ("%02x", (unsigned) data
[j
+ k
]);
1438 for (; pb
< octets_per_line
; pb
+= bpc
)
1442 for (k
= 0; k
< bpc
; k
++)
1447 /* Separate raw data from instruction by extra space. */
1458 printf ("%s", sfile
.buffer
);
1459 free (sfile
.buffer
);
1462 if (prefix_addresses
1464 : show_raw_insn
>= 0)
1472 j
= addr_offset
* opb
+ pb
;
1474 sprintf_vma (buf
, section
->vma
+ j
/ opb
);
1475 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1479 printf ("%s:\t", buf
+ skip_addr_chars
);
1481 pb
+= octets_per_line
;
1484 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1488 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1490 for (k
= bpc
- 1; k
>= 0; k
--)
1491 printf ("%02x", (unsigned) data
[j
+ k
]);
1496 for (k
= 0; k
< bpc
; k
++)
1497 printf ("%02x", (unsigned) data
[j
+ k
]);
1511 && (section
->flags
& SEC_RELOC
) != 0)
1513 while ((*relppp
) < relppend
1514 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1515 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1526 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1528 printf (": %s\t", q
->howto
->name
);
1530 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1531 printf ("*unknown*");
1534 const char *sym_name
;
1536 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1537 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1538 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1543 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1544 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1545 if (sym_name
== NULL
|| *sym_name
== '\0')
1546 sym_name
= "*unknown*";
1547 printf ("%s", sym_name
);
1554 objdump_print_value (q
->addend
, info
, true);
1566 addr_offset
+= octets
/ opb
;
1570 /* Disassemble the contents of an object file. */
1573 disassemble_data (abfd
)
1576 unsigned long addr_offset
;
1577 disassembler_ftype disassemble_fn
;
1578 struct disassemble_info disasm_info
;
1579 struct objdump_disasm_info aux
;
1581 unsigned int opb
= bfd_octets_per_byte (abfd
);
1584 prev_functionname
= NULL
;
1587 /* We make a copy of syms to sort. We don't want to sort syms
1588 because that will screw up the relocs. */
1589 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1590 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1592 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1594 /* Sort the symbols into section and symbol order */
1595 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1597 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1598 disasm_info
.application_data
= (PTR
) &aux
;
1600 aux
.require_sec
= false;
1601 disasm_info
.print_address_func
= objdump_print_address
;
1602 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1603 disasm_info
.octets_per_byte
= opb
;
1605 if (machine
!= (char *) NULL
)
1607 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1610 fatal (_("Can't use supplied machine %s"), machine
);
1612 abfd
->arch_info
= info
;
1615 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1617 struct bfd_target
*xvec
;
1619 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1620 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1621 xvec
->byteorder
= endian
;
1625 disassemble_fn
= disassembler (abfd
);
1626 if (!disassemble_fn
)
1628 non_fatal (_("Can't disassemble for architecture %s\n"),
1629 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1634 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1635 disasm_info
.arch
= bfd_get_arch (abfd
);
1636 disasm_info
.mach
= bfd_get_mach (abfd
);
1637 disasm_info
.disassembler_options
= disassembler_options
;
1639 if (bfd_big_endian (abfd
))
1640 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1641 else if (bfd_little_endian (abfd
))
1642 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1644 /* ??? Aborting here seems too drastic. We could default to big or little
1646 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1648 for (section
= abfd
->sections
;
1649 section
!= (asection
*) NULL
;
1650 section
= section
->next
)
1652 bfd_byte
*data
= NULL
;
1653 bfd_size_type datasize
= 0;
1654 arelent
**relbuf
= NULL
;
1655 arelent
**relpp
= NULL
;
1656 arelent
**relppend
= NULL
;
1657 unsigned long stop_offset
;
1658 asymbol
*sym
= NULL
;
1661 if ((section
->flags
& SEC_LOAD
) == 0
1662 || (! disassemble_all
1664 && (section
->flags
& SEC_CODE
) == 0))
1666 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1670 && (section
->flags
& SEC_RELOC
) != 0)
1674 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1676 bfd_fatal (bfd_get_filename (abfd
));
1682 relbuf
= (arelent
**) xmalloc (relsize
);
1683 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1685 bfd_fatal (bfd_get_filename (abfd
));
1687 /* Sort the relocs by address. */
1688 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1691 relppend
= relpp
+ relcount
;
1693 /* Skip over the relocs belonging to addresses below the
1695 if (start_address
!= (bfd_vma
) -1)
1697 while (relpp
< relppend
1698 && (*relpp
)->address
< start_address
)
1704 printf (_("Disassembly of section %s:\n"), section
->name
);
1706 datasize
= bfd_get_section_size_before_reloc (section
);
1710 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1712 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1715 disasm_info
.buffer
= data
;
1716 disasm_info
.buffer_vma
= section
->vma
;
1717 disasm_info
.buffer_length
= datasize
;
1718 if (start_address
== (bfd_vma
) -1
1719 || start_address
< disasm_info
.buffer_vma
)
1722 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1723 if (stop_address
== (bfd_vma
) -1)
1724 stop_offset
= datasize
/ opb
;
1727 if (stop_address
< disasm_info
.buffer_vma
)
1730 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1731 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1732 stop_offset
= disasm_info
.buffer_length
/ opb
;
1735 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1738 while (addr_offset
< stop_offset
)
1741 unsigned long nextstop_offset
;
1744 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1749 (x
< sorted_symcount
1750 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1753 disasm_info
.symbols
= & sorted_syms
[place
];
1754 disasm_info
.num_symbols
= x
- place
;
1757 disasm_info
.symbols
= NULL
;
1759 if (! prefix_addresses
)
1762 objdump_print_addr_with_sym (abfd
, section
, sym
,
1763 section
->vma
+ addr_offset
,
1769 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1771 else if (sym
== NULL
)
1775 /* Search forward for the next appropriate symbol in
1776 SECTION. Note that all the symbols are sorted
1777 together into one big array, and that some sections
1778 may have overlapping addresses. */
1779 while (place
< sorted_symcount
1780 && (sorted_syms
[place
]->section
!= section
1781 || (bfd_asymbol_value (sorted_syms
[place
])
1782 <= bfd_asymbol_value (sym
))))
1784 if (place
>= sorted_symcount
)
1787 nextsym
= sorted_syms
[place
];
1790 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1792 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1793 if (nextstop_offset
> stop_offset
)
1794 nextstop_offset
= stop_offset
;
1796 else if (nextsym
== NULL
)
1797 nextstop_offset
= stop_offset
;
1800 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1801 if (nextstop_offset
> stop_offset
)
1802 nextstop_offset
= stop_offset
;
1805 /* If a symbol is explicitly marked as being an object
1806 rather than a function, just dump the bytes without
1807 disassembling them. */
1810 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1811 || ((sym
->flags
& BSF_OBJECT
) == 0
1812 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1814 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1816 || (sym
->flags
& BSF_FUNCTION
) != 0)
1821 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1822 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1824 addr_offset
= nextstop_offset
;
1836 /* Define a table of stab values and print-strings. We wish the initializer
1837 could be a direct-mapped table, but instead we build one the first
1840 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1841 char *strsect_name
));
1843 /* Dump the stabs sections from an object file that has a section that
1844 uses Sun stabs encoding. */
1850 dump_section_stabs (abfd
, ".stab", ".stabstr");
1851 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1852 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1853 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1856 static bfd_byte
*stabs
;
1857 static bfd_size_type stab_size
;
1859 static char *strtab
;
1860 static bfd_size_type stabstr_size
;
1862 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1863 and string table section STRSECT_NAME into `strtab'.
1864 If the section exists and was read, allocate the space and return true.
1865 Otherwise return false. */
1868 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1870 const char *stabsect_name
;
1871 const char *strsect_name
;
1873 asection
*stabsect
, *stabstrsect
;
1875 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1878 printf (_("No %s section present\n\n"), stabsect_name
);
1882 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1883 if (0 == stabstrsect
)
1885 non_fatal (_("%s has no %s section"),
1886 bfd_get_filename (abfd
), strsect_name
);
1891 stab_size
= bfd_section_size (abfd
, stabsect
);
1892 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1894 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1895 strtab
= (char *) xmalloc (stabstr_size
);
1897 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1899 non_fatal (_("Reading %s section of %s failed: %s"),
1900 stabsect_name
, bfd_get_filename (abfd
),
1901 bfd_errmsg (bfd_get_error ()));
1908 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1911 non_fatal (_("Reading %s section of %s failed: %s\n"),
1912 strsect_name
, bfd_get_filename (abfd
),
1913 bfd_errmsg (bfd_get_error ()));
1923 /* Stabs entries use a 12 byte format:
1924 4 byte string table index
1926 1 byte stab other field
1927 2 byte stab desc field
1929 FIXME: This will have to change for a 64 bit object format. */
1931 #define STRDXOFF (0)
1933 #define OTHEROFF (5)
1936 #define STABSIZE (12)
1938 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1939 using string table section STRSECT_NAME (in `strtab'). */
1942 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1944 const char *stabsect_name
;
1945 const char *strsect_name ATTRIBUTE_UNUSED
;
1948 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1949 bfd_byte
*stabp
, *stabs_end
;
1952 stabs_end
= stabp
+ stab_size
;
1954 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1955 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1957 /* Loop through all symbols and print them.
1959 We start the index at -1 because there is a dummy symbol on
1960 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1962 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1966 unsigned char type
, other
;
1967 unsigned short desc
;
1970 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1971 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1972 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1973 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1974 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1976 printf ("\n%-6d ", i
);
1977 /* Either print the stab name, or, if unnamed, print its number
1978 again (makes consistent formatting for tools like awk). */
1979 name
= bfd_get_stab_name (type
);
1981 printf ("%-6s", name
);
1982 else if (type
== N_UNDF
)
1985 printf ("%-6d", type
);
1986 printf (" %-6d %-6d ", other
, desc
);
1988 printf (" %-6lu", strx
);
1990 /* Symbols with type == 0 (N_UNDF) specify the length of the
1991 string table associated with this file. We use that info
1992 to know how to relocate the *next* file's string table indices. */
1996 file_string_table_offset
= next_file_string_table_offset
;
1997 next_file_string_table_offset
+= value
;
2001 /* Using the (possibly updated) string table offset, print the
2002 string (if any) associated with this symbol. */
2004 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2005 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2014 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
2016 char *stabsect_name
;
2021 /* Check for section names for which stabsect_name is a prefix, to
2022 handle .stab0, etc. */
2023 for (s
= abfd
->sections
;
2029 len
= strlen (stabsect_name
);
2031 /* If the prefix matches, and the files section name ends with a
2032 nul or a digit, then we match. I.e., we want either an exact
2033 match or a section followed by a number. */
2034 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2035 && (s
->name
[len
] == '\000'
2036 || isdigit ((unsigned char) s
->name
[len
])))
2038 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2040 print_section_stabs (abfd
, s
->name
, strsect_name
);
2049 dump_bfd_header (abfd
)
2054 printf (_("architecture: %s, "),
2055 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2056 bfd_get_mach (abfd
)));
2057 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2059 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2060 PF (HAS_RELOC
, "HAS_RELOC");
2061 PF (EXEC_P
, "EXEC_P");
2062 PF (HAS_LINENO
, "HAS_LINENO");
2063 PF (HAS_DEBUG
, "HAS_DEBUG");
2064 PF (HAS_SYMS
, "HAS_SYMS");
2065 PF (HAS_LOCALS
, "HAS_LOCALS");
2066 PF (DYNAMIC
, "DYNAMIC");
2067 PF (WP_TEXT
, "WP_TEXT");
2068 PF (D_PAGED
, "D_PAGED");
2069 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2070 printf (_("\nstart address 0x"));
2071 printf_vma (abfd
->start_address
);
2076 dump_bfd_private_header (abfd
)
2079 bfd_print_private_bfd_data (abfd
, stdout
);
2082 /* Dump selected contents of ABFD */
2088 /* If we are adjusting section VMA's, change them all now. Changing
2089 the BFD information is a hack. However, we must do it, or
2090 bfd_find_nearest_line will not do the right thing. */
2091 if (adjust_section_vma
!= 0)
2095 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2097 s
->vma
+= adjust_section_vma
;
2098 s
->lma
+= adjust_section_vma
;
2102 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2105 print_arelt_descr (stdout
, abfd
, true);
2106 if (dump_file_header
)
2107 dump_bfd_header (abfd
);
2108 if (dump_private_headers
)
2109 dump_bfd_private_header (abfd
);
2111 if (dump_section_headers
)
2112 dump_headers (abfd
);
2113 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2115 syms
= slurp_symtab (abfd
);
2117 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2119 dynsyms
= slurp_dynamic_symtab (abfd
);
2122 dump_symbols (abfd
, false);
2123 if (dump_dynamic_symtab
)
2124 dump_symbols (abfd
, true);
2125 if (dump_stab_section_info
)
2127 if (dump_reloc_info
&& ! disassemble
)
2129 if (dump_dynamic_reloc_info
)
2130 dump_dynamic_relocs (abfd
);
2131 if (dump_section_contents
)
2134 disassemble_data (abfd
);
2139 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2140 if (dhandle
!= NULL
)
2142 if (! print_debugging_info (stdout
, dhandle
))
2144 non_fatal (_("%s: printing debugging information failed"),
2145 bfd_get_filename (abfd
));
2168 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2174 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2176 nonfatal (bfd_get_filename (abfd
));
2177 list_matching_formats (matching
);
2182 if (bfd_get_error () != bfd_error_file_not_recognized
)
2184 nonfatal (bfd_get_filename (abfd
));
2188 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2194 nonfatal (bfd_get_filename (abfd
));
2196 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2198 list_matching_formats (matching
);
2204 display_file (filename
, target
)
2208 bfd
*file
, *arfile
= (bfd
*) NULL
;
2210 file
= bfd_openr (filename
, target
);
2213 nonfatal (filename
);
2217 if (bfd_check_format (file
, bfd_archive
) == true)
2219 bfd
*last_arfile
= NULL
;
2221 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2224 bfd_set_error (bfd_error_no_error
);
2226 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2229 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2230 nonfatal (bfd_get_filename (file
));
2234 display_bfd (arfile
);
2236 if (last_arfile
!= NULL
)
2237 bfd_close (last_arfile
);
2238 last_arfile
= arfile
;
2241 if (last_arfile
!= NULL
)
2242 bfd_close (last_arfile
);
2250 /* Actually display the various requested regions */
2258 bfd_size_type datasize
= 0;
2259 bfd_size_type addr_offset
;
2260 bfd_size_type start_offset
, stop_offset
;
2261 unsigned int opb
= bfd_octets_per_byte (abfd
);
2263 for (section
= abfd
->sections
; section
!= NULL
; section
=
2268 if (only
== (char *) NULL
||
2269 strcmp (only
, section
->name
) == 0)
2271 if (section
->flags
& SEC_HAS_CONTENTS
)
2273 printf (_("Contents of section %s:\n"), section
->name
);
2275 if (bfd_section_size (abfd
, section
) == 0)
2277 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2278 datasize
= bfd_section_size (abfd
, section
);
2281 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2283 if (start_address
== (bfd_vma
) -1
2284 || start_address
< section
->vma
)
2287 start_offset
= start_address
- section
->vma
;
2288 if (stop_address
== (bfd_vma
) -1)
2289 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2292 if (stop_address
< section
->vma
)
2295 stop_offset
= stop_address
- section
->vma
;
2296 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2297 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2299 for (addr_offset
= start_offset
;
2300 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2304 printf (" %04lx ", (unsigned long int)
2305 (addr_offset
+ section
->vma
));
2306 for (j
= addr_offset
* opb
;
2307 j
< addr_offset
* opb
+ onaline
; j
++)
2309 if (j
< stop_offset
* opb
)
2310 printf ("%02x", (unsigned) (data
[j
]));
2318 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2320 if (j
>= stop_offset
* opb
)
2323 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2333 /* Should perhaps share code and display with nm? */
2335 dump_symbols (abfd
, dynamic
)
2336 bfd
*abfd ATTRIBUTE_UNUSED
;
2349 printf ("DYNAMIC SYMBOL TABLE:\n");
2357 printf ("SYMBOL TABLE:\n");
2360 for (count
= 0; count
< max
; count
++)
2364 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2366 if (cur_bfd
!= NULL
)
2371 name
= bfd_asymbol_name (*current
);
2373 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2377 /* If we want to demangle the name, we demangle it
2378 here, and temporarily clobber it while calling
2379 bfd_print_symbol. FIXME: This is a gross hack. */
2382 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2384 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2386 (*current
)->name
= alloc
;
2388 (*current
)->name
= n
;
2391 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2392 bfd_print_symbol_all
);
2394 (*current
)->name
= name
;
2415 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2419 if (bfd_is_abs_section (a
))
2421 if (bfd_is_und_section (a
))
2423 if (bfd_is_com_section (a
))
2428 if (strcmp (only
, a
->name
))
2431 else if ((a
->flags
& SEC_RELOC
) == 0)
2434 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2436 bfd_fatal (bfd_get_filename (abfd
));
2438 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2442 printf (" (none)\n\n");
2446 relpp
= (arelent
**) xmalloc (relsize
);
2447 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2449 bfd_fatal (bfd_get_filename (abfd
));
2450 else if (relcount
== 0)
2452 printf (" (none)\n\n");
2457 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2466 dump_dynamic_relocs (abfd
)
2473 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2475 bfd_fatal (bfd_get_filename (abfd
));
2477 printf ("DYNAMIC RELOCATION RECORDS");
2481 printf (" (none)\n\n");
2485 relpp
= (arelent
**) xmalloc (relsize
);
2486 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2488 bfd_fatal (bfd_get_filename (abfd
));
2489 else if (relcount
== 0)
2491 printf (" (none)\n\n");
2496 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2504 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2511 char *last_filename
, *last_functionname
;
2512 unsigned int last_line
;
2514 /* Get column headers lined up reasonably. */
2520 sprintf_vma (buf
, (bfd_vma
) -1);
2521 width
= strlen (buf
) - 7;
2523 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2526 last_filename
= NULL
;
2527 last_functionname
= NULL
;
2530 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2533 const char *filename
, *functionname
;
2535 const char *sym_name
;
2536 const char *section_name
;
2538 if (start_address
!= (bfd_vma
) -1
2539 && q
->address
< start_address
)
2541 if (stop_address
!= (bfd_vma
) -1
2542 && q
->address
> stop_address
)
2545 if (with_line_numbers
2547 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2548 &filename
, &functionname
, &line
))
2550 if (functionname
!= NULL
2551 && (last_functionname
== NULL
2552 || strcmp (functionname
, last_functionname
) != 0))
2554 printf ("%s():\n", functionname
);
2555 if (last_functionname
!= NULL
)
2556 free (last_functionname
);
2557 last_functionname
= xstrdup (functionname
);
2560 && (line
!= last_line
2561 || (filename
!= NULL
2562 && last_filename
!= NULL
2563 && strcmp (filename
, last_filename
) != 0)))
2565 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2567 if (last_filename
!= NULL
)
2568 free (last_filename
);
2569 if (filename
== NULL
)
2570 last_filename
= NULL
;
2572 last_filename
= xstrdup (filename
);
2576 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2578 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2579 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2584 section_name
= NULL
;
2588 printf_vma (q
->address
);
2590 printf (" %-16s ", q
->howto
->name
);
2592 printf (" %-16d ", q
->howto
->type
);
2593 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2598 if (section_name
== (CONST
char *) NULL
)
2599 section_name
= "*unknown*";
2600 printf_vma (q
->address
);
2601 printf (" %-16s [%s]",
2608 printf_vma (q
->addend
);
2614 /* The length of the longest architecture name + 1. */
2615 #define LONGEST_ARCH sizeof("rs6000:6000")
2618 endian_string (endian
)
2619 enum bfd_endian endian
;
2621 if (endian
== BFD_ENDIAN_BIG
)
2622 return "big endian";
2623 else if (endian
== BFD_ENDIAN_LITTLE
)
2624 return "little endian";
2626 return "endianness unknown";
2629 /* List the targets that BFD is configured to support, each followed
2630 by its endianness and the architectures it supports. */
2633 display_target_list ()
2635 extern bfd_target
*bfd_target_vector
[];
2639 dummy_name
= choose_temp_base ();
2640 for (t
= 0; bfd_target_vector
[t
]; t
++)
2642 bfd_target
*p
= bfd_target_vector
[t
];
2643 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2646 printf ("%s\n (header %s, data %s)\n", p
->name
,
2647 endian_string (p
->header_byteorder
),
2648 endian_string (p
->byteorder
));
2652 nonfatal (dummy_name
);
2656 if (! bfd_set_format (abfd
, bfd_object
))
2658 if (bfd_get_error () != bfd_error_invalid_operation
)
2663 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2664 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2666 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2668 unlink (dummy_name
);
2672 /* Print a table showing which architectures are supported for entries
2673 FIRST through LAST-1 of bfd_target_vector (targets across,
2674 architectures down). */
2677 display_info_table (first
, last
)
2681 extern bfd_target
*bfd_target_vector
[];
2685 /* Print heading of target names. */
2686 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2687 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2688 printf ("%s ", bfd_target_vector
[t
]->name
);
2691 dummy_name
= choose_temp_base ();
2692 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2693 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2695 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2696 bfd_printable_arch_mach (a
, 0));
2697 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2699 bfd_target
*p
= bfd_target_vector
[t
];
2701 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2711 if (! bfd_set_format (abfd
, bfd_object
))
2713 if (bfd_get_error () != bfd_error_invalid_operation
)
2721 if (! bfd_set_arch_mach (abfd
, a
, 0))
2726 printf ("%s ", p
->name
);
2729 int l
= strlen (p
->name
);
2737 unlink (dummy_name
);
2741 /* Print tables of all the target-architecture combinations that
2742 BFD has been configured to support. */
2745 display_target_tables ()
2748 extern bfd_target
*bfd_target_vector
[];
2752 colum
= getenv ("COLUMNS");
2754 columns
= atoi (colum
);
2759 while (bfd_target_vector
[t
] != NULL
)
2763 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2765 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2769 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2770 if (newwid
>= columns
)
2775 display_info_table (oldt
, t
);
2782 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2783 display_target_list ();
2784 display_target_tables ();
2793 char *target
= default_target
;
2794 boolean seenflag
= false;
2796 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2797 setlocale (LC_MESSAGES
, "");
2799 bindtextdomain (PACKAGE
, LOCALEDIR
);
2800 textdomain (PACKAGE
);
2802 program_name
= *argv
;
2803 xmalloc_set_program_name (program_name
);
2805 START_PROGRESS (program_name
, 0);
2808 set_default_bfd_target ();
2810 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2811 long_options
, (int *) 0))
2817 break; /* we've been given a long option */
2822 disassembler_options
= optarg
;
2828 with_line_numbers
= true;
2839 case OPTION_ADJUST_VMA
:
2840 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2842 case OPTION_START_ADDRESS
:
2843 start_address
= parse_vma (optarg
, "--start-address");
2845 case OPTION_STOP_ADDRESS
:
2846 stop_address
= parse_vma (optarg
, "--stop-address");
2849 if (strcmp (optarg
, "B") == 0)
2850 endian
= BFD_ENDIAN_BIG
;
2851 else if (strcmp (optarg
, "L") == 0)
2852 endian
= BFD_ENDIAN_LITTLE
;
2855 non_fatal (_("unrecognized -E option"));
2860 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2861 endian
= BFD_ENDIAN_BIG
;
2862 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2863 endian
= BFD_ENDIAN_LITTLE
;
2866 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2872 dump_file_header
= true;
2876 formats_info
= true;
2880 dump_private_headers
= true;
2884 dump_private_headers
= true;
2886 dump_reloc_info
= true;
2887 dump_file_header
= true;
2888 dump_ar_hdrs
= true;
2889 dump_section_headers
= true;
2897 dump_dynamic_symtab
= true;
2905 disassemble_zeroes
= true;
2909 disassemble_all
= true;
2914 with_source_code
= true;
2922 dump_stab_section_info
= true;
2926 dump_section_contents
= true;
2930 dump_reloc_info
= true;
2934 dump_dynamic_reloc_info
= true;
2938 dump_ar_hdrs
= true;
2942 dump_section_headers
= true;
2949 show_version
= true;
2959 print_version ("objdump");
2961 if (seenflag
== false)
2969 display_file ("a.out", target
);
2971 for (; optind
< argc
;)
2972 display_file (argv
[optind
++], target
);
2975 END_PROGRESS (program_name
);