1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "libiberty.h"
30 #ifdef ANSI_PROTOTYPES
36 /* Internal headers for the ELF .stab-dump code - sorry. */
37 #define BYTES_IN_WORD 32
38 #include "aout/aout64.h"
40 #ifdef NEED_DECLARATION_FPRINTF
41 /* This is needed by INIT_DISASSEMBLE_INFO. */
42 extern int fprintf
PARAMS ((FILE *, const char *, ...));
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 boolean disassemble
; /* -d */
63 static boolean disassemble_all
; /* -D */
64 static int disassemble_zeroes
; /* --disassemble-zeroes */
65 static boolean formats_info
; /* -i */
66 static char *only
; /* -j secname */
67 static int wide_output
; /* -w */
68 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
69 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
70 static int dump_debugging
; /* --debugging */
71 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
73 /* Extra info to pass to the disassembler address printing function. */
74 struct objdump_disasm_info
{
80 /* Architecture to disassemble for, or default if NULL. */
81 static char *machine
= (char *) NULL
;
83 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
84 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
86 /* The symbol table. */
87 static asymbol
**syms
;
89 /* Number of symbols in `syms'. */
90 static long symcount
= 0;
92 /* The sorted symbol table. */
93 static asymbol
**sorted_syms
;
95 /* Number of symbols in `sorted_syms'. */
96 static long sorted_symcount
= 0;
98 /* The dynamic symbol table. */
99 static asymbol
**dynsyms
;
101 /* Number of symbols in `dynsyms'. */
102 static long dynsymcount
= 0;
104 /* Forward declarations. */
107 display_file
PARAMS ((char *filename
, char *target
));
110 dump_data
PARAMS ((bfd
*abfd
));
113 dump_relocs
PARAMS ((bfd
*abfd
));
116 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
119 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
122 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
125 display_bfd
PARAMS ((bfd
*abfd
));
128 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
131 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
134 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
135 struct disassemble_info
*, boolean
));
138 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
141 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
144 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
147 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
148 boolean
, bfd_byte
*, long, long, arelent
***,
152 disassemble_data
PARAMS ((bfd
*));
155 endian_string
PARAMS ((enum bfd_endian
));
158 usage (stream
, status
)
163 Usage: %s [-ahifdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\
164 [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
165 [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
166 [--section-headers] [--headers]\n\
167 [--info] [--section=section-name] [--line-numbers] [--source]\n",
170 [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
171 [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
172 [--wide] [--version] [--help] [--private-headers]\n\
173 [--start-address=addr] [--stop-address=addr]\n\
174 [--prefix-addresses] [--[no-]show-raw-insn] [--adjust-vma=offset]\n\
175 [-EB|-EL] [--endian={big|little}] objfile...\n\
176 at least one option besides -l (--line-numbers) must be given\n");
177 list_supported_targets (program_name
, stream
);
179 fprintf (stream
, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n");
183 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
185 #define OPTION_ENDIAN (150)
186 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
187 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
188 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
190 static struct option long_options
[]=
192 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
193 {"all-headers", no_argument
, NULL
, 'x'},
194 {"private-headers", no_argument
, NULL
, 'p'},
195 {"architecture", required_argument
, NULL
, 'm'},
196 {"archive-headers", no_argument
, NULL
, 'a'},
197 {"debugging", no_argument
, &dump_debugging
, 1},
198 {"disassemble", no_argument
, NULL
, 'd'},
199 {"disassemble-all", no_argument
, NULL
, 'D'},
200 {"disassemble-zeroes", no_argument
, &disassemble_zeroes
, 1},
201 {"dynamic-reloc", no_argument
, NULL
, 'R'},
202 {"dynamic-syms", no_argument
, NULL
, 'T'},
203 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
204 {"file-headers", no_argument
, NULL
, 'f'},
205 {"full-contents", no_argument
, NULL
, 's'},
206 {"headers", no_argument
, NULL
, 'h'},
207 {"help", no_argument
, NULL
, 'H'},
208 {"info", no_argument
, NULL
, 'i'},
209 {"line-numbers", no_argument
, NULL
, 'l'},
210 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
211 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
212 {"reloc", no_argument
, NULL
, 'r'},
213 {"section", required_argument
, NULL
, 'j'},
214 {"section-headers", no_argument
, NULL
, 'h'},
215 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
216 {"source", no_argument
, NULL
, 'S'},
217 {"stabs", no_argument
, &dump_stab_section_info
, 1},
218 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
219 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
220 {"syms", no_argument
, NULL
, 't'},
221 {"target", required_argument
, NULL
, 'b'},
222 {"version", no_argument
, &show_version
, 1},
223 {"wide", no_argument
, &wide_output
, 'w'},
224 {0, no_argument
, 0, 0}
228 dump_section_header (abfd
, section
, ignored
)
235 printf ("%3d %-13s %08lx ", section
->index
,
236 bfd_get_section_name (abfd
, section
),
237 (unsigned long) bfd_section_size (abfd
, section
));
238 printf_vma (bfd_get_section_vma (abfd
, section
));
240 printf_vma (section
->lma
);
241 printf (" %08lx 2**%u", section
->filepos
,
242 bfd_get_section_alignment (abfd
, section
));
248 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
250 PF (SEC_HAS_CONTENTS
, "CONTENTS");
251 PF (SEC_ALLOC
, "ALLOC");
252 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
253 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
254 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
255 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
256 PF (SEC_LOAD
, "LOAD");
257 PF (SEC_RELOC
, "RELOC");
259 PF (SEC_BALIGN
, "BALIGN");
261 PF (SEC_READONLY
, "READONLY");
262 PF (SEC_CODE
, "CODE");
263 PF (SEC_DATA
, "DATA");
265 PF (SEC_DEBUGGING
, "DEBUGGING");
266 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
267 PF (SEC_EXCLUDE
, "EXCLUDE");
268 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
270 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
274 switch (section
->flags
& SEC_LINK_DUPLICATES
)
278 case SEC_LINK_DUPLICATES_DISCARD
:
279 ls
= "LINK_ONCE_DISCARD";
281 case SEC_LINK_DUPLICATES_ONE_ONLY
:
282 ls
= "LINK_ONCE_ONE_ONLY";
284 case SEC_LINK_DUPLICATES_SAME_SIZE
:
285 ls
= "LINK_ONCE_SAME_SIZE";
287 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
288 ls
= "LINK_ONCE_SAME_CONTENTS";
291 printf ("%s%s", comma
, ls
);
303 printf ("Sections:\n");
305 printf ("Idx Name Size VMA LMA File off Algn\n");
307 printf ("Idx Name Size VMA LMA File off Algn\n");
309 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
316 asymbol
**sy
= (asymbol
**) NULL
;
319 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
321 printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd
));
326 storage
= bfd_get_symtab_upper_bound (abfd
);
328 bfd_fatal (bfd_get_filename (abfd
));
332 sy
= (asymbol
**) xmalloc (storage
);
334 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
336 bfd_fatal (bfd_get_filename (abfd
));
338 fprintf (stderr
, "%s: %s: No symbols\n",
339 program_name
, bfd_get_filename (abfd
));
343 /* Read in the dynamic symbols. */
346 slurp_dynamic_symtab (abfd
)
349 asymbol
**sy
= (asymbol
**) NULL
;
352 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
355 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
357 fprintf (stderr
, "%s: %s: not a dynamic object\n",
358 program_name
, bfd_get_filename (abfd
));
363 bfd_fatal (bfd_get_filename (abfd
));
368 sy
= (asymbol
**) xmalloc (storage
);
370 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
372 bfd_fatal (bfd_get_filename (abfd
));
373 if (dynsymcount
== 0)
374 fprintf (stderr
, "%s: %s: No dynamic symbols\n",
375 program_name
, bfd_get_filename (abfd
));
379 /* Filter out (in place) symbols that are useless for disassembly.
380 COUNT is the number of elements in SYMBOLS.
381 Return the number of useful symbols. */
384 remove_useless_symbols (symbols
, count
)
388 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
392 asymbol
*sym
= *in_ptr
++;
394 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
396 if (sym
->flags
& (BSF_DEBUGGING
))
398 if (bfd_is_und_section (sym
->section
)
399 || bfd_is_com_section (sym
->section
))
404 return out_ptr
- symbols
;
407 /* Sort symbols into value order. */
410 compare_symbols (ap
, bp
)
414 const asymbol
*a
= *(const asymbol
**)ap
;
415 const asymbol
*b
= *(const asymbol
**)bp
;
419 flagword aflags
, bflags
;
421 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
423 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
426 if (a
->section
> b
->section
)
428 else if (a
->section
< b
->section
)
431 an
= bfd_asymbol_name (a
);
432 bn
= bfd_asymbol_name (b
);
436 /* The symbols gnu_compiled and gcc2_compiled convey no real
437 information, so put them after other symbols with the same value. */
439 af
= (strstr (an
, "gnu_compiled") != NULL
440 || strstr (an
, "gcc2_compiled") != NULL
);
441 bf
= (strstr (bn
, "gnu_compiled") != NULL
442 || strstr (bn
, "gcc2_compiled") != NULL
);
449 /* We use a heuristic for the file name, to try to sort it after
450 more useful symbols. It may not work on non Unix systems, but it
451 doesn't really matter; the only difference is precisely which
452 symbol names get printed. */
454 #define file_symbol(s, sn, snl) \
455 (((s)->flags & BSF_FILE) != 0 \
456 || ((sn)[(snl) - 2] == '.' \
457 && ((sn)[(snl) - 1] == 'o' \
458 || (sn)[(snl) - 1] == 'a')))
460 af
= file_symbol (a
, an
, anl
);
461 bf
= file_symbol (b
, bn
, bnl
);
468 /* Try to sort global symbols before local symbols before function
469 symbols before debugging symbols. */
474 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
476 if ((aflags
& BSF_DEBUGGING
) != 0)
481 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
483 if ((aflags
& BSF_FUNCTION
) != 0)
488 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
490 if ((aflags
& BSF_LOCAL
) != 0)
495 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
497 if ((aflags
& BSF_GLOBAL
) != 0)
503 /* Symbols that start with '.' might be section names, so sort them
504 after symbols that don't start with '.'. */
505 if (an
[0] == '.' && bn
[0] != '.')
507 if (an
[0] != '.' && bn
[0] == '.')
510 /* Finally, if we can't distinguish them in any other way, try to
511 get consistent results by sorting the symbols by name. */
512 return strcmp (an
, bn
);
515 /* Sort relocs into address order. */
518 compare_relocs (ap
, bp
)
522 const arelent
*a
= *(const arelent
**)ap
;
523 const arelent
*b
= *(const arelent
**)bp
;
525 if (a
->address
> b
->address
)
527 else if (a
->address
< b
->address
)
530 /* So that associated relocations tied to the same address show up
531 in the correct order, we don't do any further sorting. */
540 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
543 objdump_print_value (vma
, info
, skip_zeroes
)
545 struct disassemble_info
*info
;
551 sprintf_vma (buf
, vma
);
556 for (p
= buf
; *p
== '0'; ++p
)
561 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
564 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
565 is true, then always require the symbol to be in the section. This
566 returns NULL if there is no suitable symbol. If PLACE is not NULL,
567 then *PLACE is set to the index of the symbol in sorted_syms. */
570 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
577 /* @@ Would it speed things up to cache the last two symbols returned,
578 and maybe their address ranges? For many processors, only one memory
579 operand can be present at a time, so the 2-entry cache wouldn't be
580 constantly churned by code doing heavy memory accesses. */
582 /* Indices in `sorted_syms'. */
584 long max
= sorted_symcount
;
587 if (sorted_symcount
< 1)
590 /* Perform a binary search looking for the closest symbol to the
591 required value. We are searching the range (min, max]. */
592 while (min
+ 1 < max
)
596 thisplace
= (max
+ min
) / 2;
597 sym
= sorted_syms
[thisplace
];
599 if (bfd_asymbol_value (sym
) > vma
)
601 else if (bfd_asymbol_value (sym
) < vma
)
610 /* The symbol we want is now in min, the low end of the range we
611 were searching. If there are several symbols with the same
612 value, we want the first one. */
615 && (bfd_asymbol_value (sorted_syms
[thisplace
])
616 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
619 /* If the file is relocateable, and the symbol could be from this
620 section, prefer a symbol from this section over symbols from
621 others, even if the other symbol's value might be closer.
623 Note that this may be wrong for some symbol references if the
624 sections have overlapping memory ranges, but in that case there's
625 no way to tell what's desired without looking at the relocation
628 if (sorted_syms
[thisplace
]->section
!= sec
630 || ((abfd
->flags
& HAS_RELOC
) != 0
631 && vma
>= bfd_get_section_vma (abfd
, sec
)
632 && vma
< (bfd_get_section_vma (abfd
, sec
)
633 + bfd_section_size (abfd
, sec
)))))
637 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
639 if (bfd_asymbol_value (sorted_syms
[i
])
640 != bfd_asymbol_value (sorted_syms
[thisplace
]))
646 if (sorted_syms
[i
]->section
== sec
648 || sorted_syms
[i
- 1]->section
!= sec
649 || (bfd_asymbol_value (sorted_syms
[i
])
650 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
657 if (sorted_syms
[thisplace
]->section
!= sec
)
659 /* We didn't find a good symbol with a smaller value.
660 Look for one with a larger value. */
661 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
663 if (sorted_syms
[i
]->section
== sec
)
671 if (sorted_syms
[thisplace
]->section
!= sec
673 || ((abfd
->flags
& HAS_RELOC
) != 0
674 && vma
>= bfd_get_section_vma (abfd
, sec
)
675 && vma
< (bfd_get_section_vma (abfd
, sec
)
676 + bfd_section_size (abfd
, sec
)))))
678 /* There is no suitable symbol. */
686 return sorted_syms
[thisplace
];
689 /* Print an address to INFO symbolically. */
692 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
697 struct disassemble_info
*info
;
700 objdump_print_value (vma
, info
, skip_zeroes
);
706 (*info
->fprintf_func
) (info
->stream
, " <%s",
707 bfd_get_section_name (abfd
, sec
));
708 secaddr
= bfd_get_section_vma (abfd
, sec
);
711 (*info
->fprintf_func
) (info
->stream
, "-");
712 objdump_print_value (secaddr
- vma
, info
, true);
714 else if (vma
> secaddr
)
716 (*info
->fprintf_func
) (info
->stream
, "+");
717 objdump_print_value (vma
- secaddr
, info
, true);
719 (*info
->fprintf_func
) (info
->stream
, ">");
723 (*info
->fprintf_func
) (info
->stream
, " <%s", sym
->name
);
724 if (bfd_asymbol_value (sym
) > vma
)
726 (*info
->fprintf_func
) (info
->stream
, "-");
727 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
729 else if (vma
> bfd_asymbol_value (sym
))
731 (*info
->fprintf_func
) (info
->stream
, "+");
732 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
734 (*info
->fprintf_func
) (info
->stream
, ">");
738 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
739 true, don't output leading zeroes. */
742 objdump_print_addr (vma
, info
, skip_zeroes
)
744 struct disassemble_info
*info
;
747 struct objdump_disasm_info
*aux
;
750 if (sorted_symcount
< 1)
752 objdump_print_value (vma
, info
, skip_zeroes
);
756 aux
= (struct objdump_disasm_info
*) info
->application_data
;
757 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
759 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
763 /* Print VMA to INFO. This function is passed to the disassembler
767 objdump_print_address (vma
, info
)
769 struct disassemble_info
*info
;
771 objdump_print_addr (vma
, info
, ! prefix_addresses
);
774 /* Hold the last function name and the last line number we displayed
777 static char *prev_functionname
;
778 static unsigned int prev_line
;
780 /* We keep a list of all files that we have seen when doing a
781 dissassembly with source, so that we know how much of the file to
782 display. This can be important for inlined functions. */
784 struct print_file_list
786 struct print_file_list
*next
;
792 static struct print_file_list
*print_files
;
794 /* The number of preceding context lines to show when we start
795 displaying a file for the first time. */
797 #define SHOW_PRECEDING_CONTEXT_LINES (5)
799 /* Skip ahead to a given line in a file, optionally printing each
803 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
806 skip_to_line (p
, line
, show
)
807 struct print_file_list
*p
;
811 while (p
->line
< line
)
815 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
825 if (strchr (buf
, '\n') != NULL
)
830 /* Show the line number, or the source line, in a dissassembly
834 show_line (abfd
, section
, off
)
839 CONST
char *filename
;
840 CONST
char *functionname
;
843 if (! with_line_numbers
&& ! with_source_code
)
846 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
847 &functionname
, &line
))
850 if (filename
!= NULL
&& *filename
== '\0')
852 if (functionname
!= NULL
&& *functionname
== '\0')
855 if (with_line_numbers
)
857 if (functionname
!= NULL
858 && (prev_functionname
== NULL
859 || strcmp (functionname
, prev_functionname
) != 0))
860 printf ("%s():\n", functionname
);
861 if (line
> 0 && line
!= prev_line
)
862 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
869 struct print_file_list
**pp
, *p
;
871 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
872 if (strcmp ((*pp
)->filename
, filename
) == 0)
878 if (p
!= print_files
)
882 /* We have reencountered a file name which we saw
883 earlier. This implies that either we are dumping out
884 code from an included file, or the same file was
885 linked in more than once. There are two common cases
886 of an included file: inline functions in a header
887 file, and a bison or flex skeleton file. In the
888 former case we want to just start printing (but we
889 back up a few lines to give context); in the latter
890 case we want to continue from where we left off. I
891 can't think of a good way to distinguish the cases,
892 so I used a heuristic based on the file name. */
893 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
897 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
904 p
->f
= fopen (p
->filename
, "r");
908 skip_to_line (p
, l
, false);
910 if (print_files
->f
!= NULL
)
912 fclose (print_files
->f
);
913 print_files
->f
= NULL
;
919 skip_to_line (p
, line
, true);
921 p
->next
= print_files
;
929 f
= fopen (filename
, "r");
934 p
= ((struct print_file_list
*)
935 xmalloc (sizeof (struct print_file_list
)));
936 p
->filename
= xmalloc (strlen (filename
) + 1);
937 strcpy (p
->filename
, filename
);
941 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
943 fclose (print_files
->f
);
944 print_files
->f
= NULL
;
946 p
->next
= print_files
;
949 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
952 skip_to_line (p
, l
, false);
954 skip_to_line (p
, line
, true);
959 if (functionname
!= NULL
960 && (prev_functionname
== NULL
961 || strcmp (functionname
, prev_functionname
) != 0))
963 if (prev_functionname
!= NULL
)
964 free (prev_functionname
);
965 prev_functionname
= xmalloc (strlen (functionname
) + 1);
966 strcpy (prev_functionname
, functionname
);
969 if (line
> 0 && line
!= prev_line
)
973 /* Pseudo FILE object for strings. */
979 /* sprintf to a "stream" */
981 #ifdef ANSI_PROTOTYPES
983 objdump_sprintf (SFILE
*f
, const char *format
, ...)
988 va_start (args
, format
);
989 vsprintf (f
->current
, format
, args
);
990 f
->current
+= n
= strlen (f
->current
);
996 objdump_sprintf (va_alist
)
1005 f
= va_arg (args
, SFILE
*);
1006 format
= va_arg (args
, const char *);
1007 vsprintf (f
->current
, format
, args
);
1008 f
->current
+= n
= strlen (f
->current
);
1014 /* The number of zeroes we want to see before we start skipping them.
1015 The number is arbitrarily chosen. */
1017 #define SKIP_ZEROES (8)
1019 /* The number of zeroes to skip at the end of a section. If the
1020 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1021 SKIP_ZEROES, they will be disassembled. If there are fewer than
1022 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1023 attempt to avoid disassembling zeroes inserted by section
1026 #define SKIP_ZEROES_AT_END (3)
1028 /* Disassemble some data in memory between given values. */
1031 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1033 struct disassemble_info
*info
;
1034 disassembler_ftype disassemble_fn
;
1042 struct objdump_disasm_info
*aux
;
1046 int skip_addr_chars
;
1049 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1055 bytes_per_line
= 16;
1057 /* Figure out how many characters to skip at the start of an
1058 address, to make the disassembly look nicer. We discard leading
1059 zeroes in chunks of 4, ensuring that there is always a leading
1061 skip_addr_chars
= 0;
1062 if (! prefix_addresses
)
1068 section
->vma
+ bfd_section_size (section
->owner
, section
));
1070 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1073 skip_addr_chars
+= 4;
1078 info
->insn_info_valid
= 0;
1086 boolean need_nl
= false;
1088 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1090 for (z
= i
; z
< stop
; z
++)
1093 if (! disassemble_zeroes
1094 && (info
->insn_info_valid
== 0
1095 || info
->branch_delay_insns
== 0)
1096 && (z
- i
>= SKIP_ZEROES
1097 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1101 /* If there are more nonzero bytes to follow, we only skip
1102 zeroes in multiples of 4, to try to avoid running over
1103 the start of an instruction which happens to start with
1106 z
= i
+ ((z
- i
) &~ 3);
1118 if (with_line_numbers
|| with_source_code
)
1119 show_line (aux
->abfd
, section
, i
);
1121 if (! prefix_addresses
)
1125 sprintf_vma (buf
, section
->vma
+ i
);
1126 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1130 printf ("%s:\t", buf
+ skip_addr_chars
);
1134 aux
->require_sec
= true;
1135 objdump_print_address (section
->vma
+ i
, info
);
1136 aux
->require_sec
= false;
1142 sfile
.buffer
= sfile
.current
= buf
;
1143 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1144 info
->stream
= (FILE *) &sfile
;
1145 info
->bytes_per_line
= 0;
1146 info
->bytes_per_chunk
= 0;
1147 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1148 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1149 info
->stream
= stdout
;
1150 if (info
->bytes_per_line
!= 0)
1151 bytes_per_line
= info
->bytes_per_line
;
1159 bytes
= bytes_per_line
;
1160 if (i
+ bytes
> stop
)
1163 for (j
= i
; j
< i
+ bytes
; ++j
)
1165 if (isprint (data
[j
]))
1166 buf
[j
- i
] = data
[j
];
1173 if (prefix_addresses
1175 : show_raw_insn
>= 0)
1179 /* If ! prefix_addresses and ! wide_output, we print
1180 bytes_per_line bytes per line. */
1182 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1183 pb
= bytes_per_line
;
1185 if (info
->bytes_per_chunk
)
1186 bpc
= info
->bytes_per_chunk
;
1190 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1193 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1195 for (k
= bpc
- 1; k
>= 0; k
--)
1196 printf ("%02x", (unsigned) data
[j
+ k
]);
1201 for (k
= 0; k
< bpc
; k
++)
1202 printf ("%02x", (unsigned) data
[j
+ k
]);
1207 for (; pb
< bytes_per_line
; pb
+= bpc
)
1211 for (k
= 0; k
< bpc
; k
++)
1216 /* Separate raw data from instruction by extra space. */
1225 if (prefix_addresses
1227 : show_raw_insn
>= 0)
1237 sprintf_vma (buf
, section
->vma
+ j
);
1238 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1242 printf ("%s:\t", buf
+ skip_addr_chars
);
1244 pb
+= bytes_per_line
;
1247 for (; j
< i
+ pb
; j
+= bpc
)
1251 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1253 for (k
= bpc
- 1; k
>= 0; k
--)
1254 printf ("%02x", (unsigned) data
[j
+ k
]);
1259 for (k
= 0; k
< bpc
; k
++)
1260 printf ("%02x", (unsigned) data
[j
+ k
]);
1274 && (section
->flags
& SEC_RELOC
) != 0)
1276 while ((*relppp
) < relppend
1277 && ((**relppp
)->address
>= (bfd_vma
) i
1278 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1281 const char *sym_name
;
1290 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1292 printf (": %s\t", q
->howto
->name
);
1294 if (q
->sym_ptr_ptr
!= NULL
1295 && *q
->sym_ptr_ptr
!= NULL
)
1297 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1298 if (sym_name
== NULL
|| *sym_name
== '\0')
1302 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1303 sym_name
= bfd_get_section_name (abfd
, sym_sec
);
1304 if (sym_name
== NULL
|| *sym_name
== '\0')
1305 sym_name
= "*unknown*";
1309 sym_name
= "*unknown*";
1311 printf ("%s", sym_name
);
1316 objdump_print_value (q
->addend
, info
, true);
1332 /* Disassemble the contents of an object file. */
1335 disassemble_data (abfd
)
1339 disassembler_ftype disassemble_fn
;
1340 struct disassemble_info disasm_info
;
1341 struct objdump_disasm_info aux
;
1345 prev_functionname
= NULL
;
1348 /* We make a copy of syms to sort. We don't want to sort syms
1349 because that will screw up the relocs. */
1350 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1351 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1353 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1355 /* Sort the symbols into section and symbol order */
1356 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1358 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1359 disasm_info
.application_data
= (PTR
) &aux
;
1361 aux
.require_sec
= false;
1362 disasm_info
.print_address_func
= objdump_print_address
;
1364 if (machine
!= (char *) NULL
)
1366 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1369 fprintf (stderr
, "%s: Can't use supplied machine %s\n",
1374 abfd
->arch_info
= info
;
1377 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1379 struct bfd_target
*xvec
;
1381 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1382 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1383 xvec
->byteorder
= endian
;
1387 disassemble_fn
= disassembler (abfd
);
1388 if (!disassemble_fn
)
1390 fprintf (stderr
, "%s: Can't disassemble for architecture %s\n",
1392 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1396 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1397 disasm_info
.arch
= bfd_get_arch (abfd
);
1398 disasm_info
.mach
= bfd_get_mach (abfd
);
1399 if (bfd_big_endian (abfd
))
1400 disasm_info
.endian
= BFD_ENDIAN_BIG
;
1401 else if (bfd_little_endian (abfd
))
1402 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1404 /* ??? Aborting here seems too drastic. We could default to big or little
1406 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1408 for (section
= abfd
->sections
;
1409 section
!= (asection
*) NULL
;
1410 section
= section
->next
)
1412 bfd_byte
*data
= NULL
;
1413 bfd_size_type datasize
= 0;
1414 arelent
**relbuf
= NULL
;
1415 arelent
**relpp
= NULL
;
1416 arelent
**relppend
= NULL
;
1419 if ((section
->flags
& SEC_LOAD
) == 0
1420 || (! disassemble_all
1422 && (section
->flags
& SEC_CODE
) == 0))
1424 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1428 && (section
->flags
& SEC_RELOC
) != 0)
1432 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1434 bfd_fatal (bfd_get_filename (abfd
));
1440 relbuf
= (arelent
**) xmalloc (relsize
);
1441 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1443 bfd_fatal (bfd_get_filename (abfd
));
1445 /* Sort the relocs by address. */
1446 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1449 relppend
= relpp
+ relcount
;
1453 printf ("Disassembly of section %s:\n", section
->name
);
1455 datasize
= bfd_get_section_size_before_reloc (section
);
1459 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1461 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1464 disasm_info
.buffer
= data
;
1465 disasm_info
.buffer_vma
= section
->vma
;
1466 disasm_info
.buffer_length
= datasize
;
1467 if (start_address
== (bfd_vma
) -1
1468 || start_address
< disasm_info
.buffer_vma
)
1471 i
= start_address
- disasm_info
.buffer_vma
;
1472 if (stop_address
== (bfd_vma
) -1)
1476 if (stop_address
< disasm_info
.buffer_vma
)
1479 stop
= stop_address
- disasm_info
.buffer_vma
;
1480 if (stop
> disasm_info
.buffer_length
)
1481 stop
= disasm_info
.buffer_length
;
1484 if (prefix_addresses
)
1485 disassemble_bytes (&disasm_info
, disassemble_fn
, true, data
, i
, stop
,
1492 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1501 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1502 disasm_info
.symbol
= sym
;
1504 disasm_info
.symbol
= NULL
;
1507 objdump_print_addr_with_sym (abfd
, section
, sym
,
1513 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1515 else if (sym
== NULL
)
1519 while (place
< sorted_symcount
1520 && (sorted_syms
[place
]->section
!= section
1521 || (bfd_asymbol_value (sorted_syms
[place
])
1522 <= bfd_asymbol_value (sym
))))
1524 if (place
>= sorted_symcount
)
1527 nextsym
= sorted_syms
[place
];
1530 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1532 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1533 if (nextstop
> stop
)
1536 else if (nextsym
== NULL
)
1540 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1541 if (nextstop
> stop
)
1545 /* If a symbol is explicitly marked as being an object
1546 rather than a function, just dump the bytes without
1547 disassembling them. */
1550 || bfd_asymbol_value (sym
) > section
->vma
+ i
1551 || ((sym
->flags
& BSF_OBJECT
) == 0
1552 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1554 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1556 || (sym
->flags
& BSF_FUNCTION
) != 0)
1561 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1562 nextstop
, &relpp
, relppend
);
1577 /* Define a table of stab values and print-strings. We wish the initializer
1578 could be a direct-mapped table, but instead we build one the first
1581 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1582 char *strsect_name
));
1584 /* Dump the stabs sections from an object file that has a section that
1585 uses Sun stabs encoding. */
1591 dump_section_stabs (abfd
, ".stab", ".stabstr");
1592 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1593 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1594 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1597 static bfd_byte
*stabs
;
1598 static bfd_size_type stab_size
;
1600 static char *strtab
;
1601 static bfd_size_type stabstr_size
;
1603 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1604 and string table section STRSECT_NAME into `strtab'.
1605 If the section exists and was read, allocate the space and return true.
1606 Otherwise return false. */
1609 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1611 char *stabsect_name
;
1614 asection
*stabsect
, *stabstrsect
;
1616 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1619 printf ("No %s section present\n\n", stabsect_name
);
1623 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1624 if (0 == stabstrsect
)
1626 fprintf (stderr
, "%s: %s has no %s section\n", program_name
,
1627 bfd_get_filename (abfd
), strsect_name
);
1631 stab_size
= bfd_section_size (abfd
, stabsect
);
1632 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1634 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1635 strtab
= (char *) xmalloc (stabstr_size
);
1637 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1639 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1640 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1641 bfd_errmsg (bfd_get_error ()));
1647 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1650 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1651 program_name
, strsect_name
, bfd_get_filename (abfd
),
1652 bfd_errmsg (bfd_get_error ()));
1661 /* Stabs entries use a 12 byte format:
1662 4 byte string table index
1664 1 byte stab other field
1665 2 byte stab desc field
1667 FIXME: This will have to change for a 64 bit object format. */
1669 #define STRDXOFF (0)
1671 #define OTHEROFF (5)
1674 #define STABSIZE (12)
1676 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1677 using string table section STRSECT_NAME (in `strtab'). */
1680 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1682 char *stabsect_name
;
1686 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1687 bfd_byte
*stabp
, *stabs_end
;
1690 stabs_end
= stabp
+ stab_size
;
1692 printf ("Contents of %s section:\n\n", stabsect_name
);
1693 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1695 /* Loop through all symbols and print them.
1697 We start the index at -1 because there is a dummy symbol on
1698 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1700 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1704 unsigned char type
, other
;
1705 unsigned short desc
;
1708 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1709 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1710 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1711 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1712 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1714 printf ("\n%-6d ", i
);
1715 /* Either print the stab name, or, if unnamed, print its number
1716 again (makes consistent formatting for tools like awk). */
1717 name
= bfd_get_stab_name (type
);
1719 printf ("%-6s", name
);
1720 else if (type
== N_UNDF
)
1723 printf ("%-6d", type
);
1724 printf (" %-6d %-6d ", other
, desc
);
1726 printf (" %-6lu", strx
);
1728 /* Symbols with type == 0 (N_UNDF) specify the length of the
1729 string table associated with this file. We use that info
1730 to know how to relocate the *next* file's string table indices. */
1734 file_string_table_offset
= next_file_string_table_offset
;
1735 next_file_string_table_offset
+= value
;
1739 /* Using the (possibly updated) string table offset, print the
1740 string (if any) associated with this symbol. */
1742 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1743 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1752 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1754 char *stabsect_name
;
1759 /* Check for section names for which stabsect_name is a prefix, to
1760 handle .stab0, etc. */
1761 for (s
= abfd
->sections
;
1767 len
= strlen (stabsect_name
);
1769 /* If the prefix matches, and the files section name ends with a nul or a digit,
1770 then we match. Ie: we want either an exact match or a a section followed by
1772 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1773 && (s
->name
[len
] == '\000' || isdigit (s
->name
[len
])))
1775 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1777 print_section_stabs (abfd
, s
->name
, strsect_name
);
1786 dump_bfd_header (abfd
)
1791 printf ("architecture: %s, ",
1792 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1793 bfd_get_mach (abfd
)));
1794 printf ("flags 0x%08x:\n", abfd
->flags
);
1796 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1797 PF (HAS_RELOC
, "HAS_RELOC");
1798 PF (EXEC_P
, "EXEC_P");
1799 PF (HAS_LINENO
, "HAS_LINENO");
1800 PF (HAS_DEBUG
, "HAS_DEBUG");
1801 PF (HAS_SYMS
, "HAS_SYMS");
1802 PF (HAS_LOCALS
, "HAS_LOCALS");
1803 PF (DYNAMIC
, "DYNAMIC");
1804 PF (WP_TEXT
, "WP_TEXT");
1805 PF (D_PAGED
, "D_PAGED");
1806 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
1807 printf ("\nstart address 0x");
1808 printf_vma (abfd
->start_address
);
1813 dump_bfd_private_header (abfd
)
1816 bfd_print_private_bfd_data (abfd
, stdout
);
1825 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
1827 bfd_nonfatal (bfd_get_filename (abfd
));
1828 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1830 list_matching_formats (matching
);
1836 /* If we are adjusting section VMA's, change them all now. Changing
1837 the BFD information is a hack. However, we must do it, or
1838 bfd_find_nearest_line will not do the right thing. */
1839 if (adjust_section_vma
!= 0)
1843 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1845 s
->vma
+= adjust_section_vma
;
1846 s
->lma
+= adjust_section_vma
;
1850 printf ("\n%s: file format %s\n", bfd_get_filename (abfd
),
1853 print_arelt_descr (stdout
, abfd
, true);
1854 if (dump_file_header
)
1855 dump_bfd_header (abfd
);
1856 if (dump_private_headers
)
1857 dump_bfd_private_header (abfd
);
1859 if (dump_section_headers
)
1860 dump_headers (abfd
);
1861 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
1863 syms
= slurp_symtab (abfd
);
1865 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
1867 dynsyms
= slurp_dynamic_symtab (abfd
);
1870 dump_symbols (abfd
, false);
1871 if (dump_dynamic_symtab
)
1872 dump_symbols (abfd
, true);
1873 if (dump_stab_section_info
)
1875 if (dump_reloc_info
&& ! disassemble
)
1877 if (dump_dynamic_reloc_info
)
1878 dump_dynamic_relocs (abfd
);
1879 if (dump_section_contents
)
1882 disassemble_data (abfd
);
1887 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
1888 if (dhandle
!= NULL
)
1890 if (! print_debugging_info (stdout
, dhandle
))
1891 fprintf (stderr
, "%s: printing debugging information failed\n",
1892 bfd_get_filename (abfd
));
1908 display_file (filename
, target
)
1912 bfd
*file
, *arfile
= (bfd
*) NULL
;
1914 file
= bfd_openr (filename
, target
);
1917 bfd_nonfatal (filename
);
1921 if (bfd_check_format (file
, bfd_archive
) == true)
1923 bfd
*last_arfile
= NULL
;
1925 printf ("In archive %s:\n", bfd_get_filename (file
));
1928 bfd_set_error (bfd_error_no_error
);
1930 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1933 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1935 bfd_nonfatal (bfd_get_filename (file
));
1940 display_bfd (arfile
);
1942 if (last_arfile
!= NULL
)
1943 bfd_close (last_arfile
);
1944 last_arfile
= arfile
;
1947 if (last_arfile
!= NULL
)
1948 bfd_close (last_arfile
);
1956 /* Actually display the various requested regions */
1964 bfd_size_type datasize
= 0;
1966 bfd_size_type start
, stop
;
1968 for (section
= abfd
->sections
; section
!= NULL
; section
=
1973 if (only
== (char *) NULL
||
1974 strcmp (only
, section
->name
) == 0)
1976 if (section
->flags
& SEC_HAS_CONTENTS
)
1978 printf ("Contents of section %s:\n", section
->name
);
1980 if (bfd_section_size (abfd
, section
) == 0)
1982 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
1983 datasize
= bfd_section_size (abfd
, section
);
1986 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
1988 if (start_address
== (bfd_vma
) -1
1989 || start_address
< section
->vma
)
1992 start
= start_address
- section
->vma
;
1993 if (stop_address
== (bfd_vma
) -1)
1994 stop
= bfd_section_size (abfd
, section
);
1997 if (stop_address
< section
->vma
)
2000 stop
= stop_address
- section
->vma
;
2001 if (stop
> bfd_section_size (abfd
, section
))
2002 stop
= bfd_section_size (abfd
, section
);
2004 for (i
= start
; i
< stop
; i
+= onaline
)
2008 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2009 for (j
= i
; j
< i
+ onaline
; j
++)
2012 printf ("%02x", (unsigned) (data
[j
]));
2020 for (j
= i
; j
< i
+ onaline
; j
++)
2025 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2035 /* Should perhaps share code and display with nm? */
2037 dump_symbols (abfd
, dynamic
)
2051 printf ("DYNAMIC SYMBOL TABLE:\n");
2059 printf ("SYMBOL TABLE:\n");
2062 for (count
= 0; count
< max
; count
++)
2066 bfd
*cur_bfd
= bfd_asymbol_bfd(*current
);
2069 bfd_print_symbol (cur_bfd
,
2071 *current
, bfd_print_symbol_all
);
2089 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2093 if (bfd_is_abs_section (a
))
2095 if (bfd_is_und_section (a
))
2097 if (bfd_is_com_section (a
))
2102 if (strcmp (only
, a
->name
))
2105 else if ((a
->flags
& SEC_RELOC
) == 0)
2108 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2110 bfd_fatal (bfd_get_filename (abfd
));
2112 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2116 printf (" (none)\n\n");
2120 relpp
= (arelent
**) xmalloc (relsize
);
2121 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2123 bfd_fatal (bfd_get_filename (abfd
));
2124 else if (relcount
== 0)
2126 printf (" (none)\n\n");
2131 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2140 dump_dynamic_relocs (abfd
)
2147 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2149 bfd_fatal (bfd_get_filename (abfd
));
2151 printf ("DYNAMIC RELOCATION RECORDS");
2155 printf (" (none)\n\n");
2159 relpp
= (arelent
**) xmalloc (relsize
);
2160 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2162 bfd_fatal (bfd_get_filename (abfd
));
2163 else if (relcount
== 0)
2165 printf (" (none)\n\n");
2170 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2178 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2185 char *last_filename
, *last_functionname
;
2186 unsigned int last_line
;
2188 /* Get column headers lined up reasonably. */
2194 sprintf_vma (buf
, (bfd_vma
) -1);
2195 width
= strlen (buf
) - 7;
2197 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2200 last_filename
= NULL
;
2201 last_functionname
= NULL
;
2204 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2207 const char *filename
, *functionname
;
2209 const char *sym_name
;
2210 const char *section_name
;
2212 if (start_address
!= (bfd_vma
) -1
2213 && q
->address
< start_address
)
2215 if (stop_address
!= (bfd_vma
) -1
2216 && q
->address
> stop_address
)
2219 if (with_line_numbers
2221 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2222 &filename
, &functionname
, &line
))
2224 if (functionname
!= NULL
2225 && (last_functionname
== NULL
2226 || strcmp (functionname
, last_functionname
) != 0))
2228 printf ("%s():\n", functionname
);
2229 if (last_functionname
!= NULL
)
2230 free (last_functionname
);
2231 last_functionname
= xstrdup (functionname
);
2234 && (line
!= last_line
2235 || (filename
!= NULL
2236 && last_filename
!= NULL
2237 && strcmp (filename
, last_filename
) != 0)))
2239 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2241 if (last_filename
!= NULL
)
2242 free (last_filename
);
2243 if (filename
== NULL
)
2244 last_filename
= NULL
;
2246 last_filename
= xstrdup (filename
);
2250 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2252 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2253 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2258 section_name
= NULL
;
2262 printf_vma (q
->address
);
2263 printf (" %-16s %s",
2269 if (section_name
== (CONST
char *) NULL
)
2270 section_name
= "*unknown*";
2271 printf_vma (q
->address
);
2272 printf (" %-16s [%s]",
2279 printf_vma (q
->addend
);
2285 /* The length of the longest architecture name + 1. */
2286 #define LONGEST_ARCH sizeof("rs6000:6000")
2289 endian_string (endian
)
2290 enum bfd_endian endian
;
2292 if (endian
== BFD_ENDIAN_BIG
)
2293 return "big endian";
2294 else if (endian
== BFD_ENDIAN_LITTLE
)
2295 return "little endian";
2297 return "endianness unknown";
2300 /* List the targets that BFD is configured to support, each followed
2301 by its endianness and the architectures it supports. */
2304 display_target_list ()
2306 extern bfd_target
*bfd_target_vector
[];
2310 dummy_name
= choose_temp_base ();
2311 for (t
= 0; bfd_target_vector
[t
]; t
++)
2313 bfd_target
*p
= bfd_target_vector
[t
];
2314 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2317 printf ("%s\n (header %s, data %s)\n", p
->name
,
2318 endian_string (p
->header_byteorder
),
2319 endian_string (p
->byteorder
));
2323 bfd_nonfatal (dummy_name
);
2327 if (! bfd_set_format (abfd
, bfd_object
))
2329 if (bfd_get_error () != bfd_error_invalid_operation
)
2330 bfd_nonfatal (p
->name
);
2334 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2335 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2337 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2339 unlink (dummy_name
);
2343 /* Print a table showing which architectures are supported for entries
2344 FIRST through LAST-1 of bfd_target_vector (targets across,
2345 architectures down). */
2348 display_info_table (first
, last
)
2352 extern bfd_target
*bfd_target_vector
[];
2356 /* Print heading of target names. */
2357 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2358 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2359 printf ("%s ", bfd_target_vector
[t
]->name
);
2362 dummy_name
= choose_temp_base ();
2363 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2364 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2366 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2367 bfd_printable_arch_mach (a
, 0));
2368 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2370 bfd_target
*p
= bfd_target_vector
[t
];
2372 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2376 bfd_nonfatal (p
->name
);
2382 if (! bfd_set_format (abfd
, bfd_object
))
2384 if (bfd_get_error () != bfd_error_invalid_operation
)
2385 bfd_nonfatal (p
->name
);
2392 if (! bfd_set_arch_mach (abfd
, a
, 0))
2397 printf ("%s ", p
->name
);
2400 int l
= strlen (p
->name
);
2408 unlink (dummy_name
);
2412 /* Print tables of all the target-architecture combinations that
2413 BFD has been configured to support. */
2416 display_target_tables ()
2419 extern bfd_target
*bfd_target_vector
[];
2421 extern char *getenv ();
2424 colum
= getenv ("COLUMNS");
2426 columns
= atoi (colum
);
2431 while (bfd_target_vector
[t
] != NULL
)
2435 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2437 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2441 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2442 if (newwid
>= columns
)
2447 display_info_table (oldt
, t
);
2454 printf ("BFD header file version %s\n", BFD_VERSION
);
2455 display_target_list ();
2456 display_target_tables ();
2465 char *target
= default_target
;
2466 boolean seenflag
= false;
2468 program_name
= *argv
;
2469 xmalloc_set_program_name (program_name
);
2471 START_PROGRESS (program_name
, 0);
2474 set_default_bfd_target ();
2476 while ((c
= getopt_long (argc
, argv
, "pib:m:VdDlfahrRtTxsSj:wE:",
2477 long_options
, (int *) 0))
2480 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2485 break; /* we've been given a long option */
2493 with_line_numbers
= 1;
2499 dump_file_header
= true;
2502 formats_info
= true;
2505 dump_private_headers
= 1;
2508 dump_private_headers
= 1;
2510 dump_reloc_info
= 1;
2511 dump_file_header
= true;
2513 dump_section_headers
= 1;
2519 dump_dynamic_symtab
= 1;
2525 disassemble
= disassemble_all
= true;
2529 with_source_code
= true;
2532 dump_section_contents
= 1;
2535 dump_reloc_info
= 1;
2538 dump_dynamic_reloc_info
= 1;
2544 dump_section_headers
= 1;
2554 case OPTION_ADJUST_VMA
:
2555 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2557 case OPTION_START_ADDRESS
:
2558 start_address
= parse_vma (optarg
, "--start-address");
2560 case OPTION_STOP_ADDRESS
:
2561 stop_address
= parse_vma (optarg
, "--stop-address");
2564 if (strcmp (optarg
, "B") == 0)
2565 endian
= BFD_ENDIAN_BIG
;
2566 else if (strcmp (optarg
, "L") == 0)
2567 endian
= BFD_ENDIAN_LITTLE
;
2570 fprintf (stderr
, "%s: unrecognized -E option\n", program_name
);
2575 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2576 endian
= BFD_ENDIAN_BIG
;
2577 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2578 endian
= BFD_ENDIAN_LITTLE
;
2581 fprintf (stderr
, "%s: unrecognized --endian type `%s'\n",
2582 program_name
, optarg
);
2592 print_version ("objdump");
2594 if (seenflag
== false)
2604 display_file ("a.out", target
);
2606 for (; optind
< argc
;)
2607 display_file (argv
[optind
++], target
);
2610 END_PROGRESS (program_name
);