1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
129 #include "elf/msp430.h"
130 #include "elf/or32.h"
133 #include "elf/ppc64.h"
135 #include "elf/s390.h"
136 #include "elf/score.h"
138 #include "elf/sparc.h"
140 #include "elf/tic6x.h"
141 #include "elf/v850.h"
143 #include "elf/x86-64.h"
144 #include "elf/xc16x.h"
145 #include "elf/xstormy16.h"
146 #include "elf/xtensa.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
155 char * program_name
= "readelf";
156 static long archive_file_offset
;
157 static unsigned long archive_file_size
;
158 static unsigned long dynamic_addr
;
159 static bfd_size_type dynamic_size
;
160 static unsigned int dynamic_nent
;
161 static char * dynamic_strings
;
162 static unsigned long dynamic_strings_length
;
163 static char * string_table
;
164 static unsigned long string_table_length
;
165 static unsigned long num_dynamic_syms
;
166 static Elf_Internal_Sym
* dynamic_symbols
;
167 static Elf_Internal_Syminfo
* dynamic_syminfo
;
168 static unsigned long dynamic_syminfo_offset
;
169 static unsigned int dynamic_syminfo_nent
;
170 static char program_interpreter
[PATH_MAX
];
171 static bfd_vma dynamic_info
[DT_ENCODING
];
172 static bfd_vma dynamic_info_DT_GNU_HASH
;
173 static bfd_vma version_info
[16];
174 static Elf_Internal_Ehdr elf_header
;
175 static Elf_Internal_Shdr
* section_headers
;
176 static Elf_Internal_Phdr
* program_headers
;
177 static Elf_Internal_Dyn
* dynamic_section
;
178 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
179 static int show_name
;
180 static int do_dynamic
;
182 static int do_dyn_syms
;
184 static int do_sections
;
185 static int do_section_groups
;
186 static int do_section_details
;
187 static int do_segments
;
188 static int do_unwind
;
189 static int do_using_dynamic
;
190 static int do_header
;
192 static int do_version
;
193 static int do_histogram
;
194 static int do_debugging
;
197 static int do_archive_index
;
198 static int is_32bit_elf
;
202 struct group_list
* next
;
203 unsigned int section_index
;
208 struct group_list
* root
;
209 unsigned int group_index
;
212 static size_t group_count
;
213 static struct group
* section_groups
;
214 static struct group
** section_headers_groups
;
217 /* Flag bits indicating particular types of dump. */
218 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
219 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
222 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
224 typedef unsigned char dump_type
;
226 /* A linked list of the section names for which dumps were requested. */
227 struct dump_list_entry
231 struct dump_list_entry
* next
;
233 static struct dump_list_entry
* dump_sects_byname
;
235 /* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237 static dump_type
* cmdline_dump_sects
= NULL
;
238 static unsigned int num_cmdline_dump_sects
= 0;
240 /* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
245 static dump_type
* dump_sects
= NULL
;
246 static unsigned int num_dump_sects
= 0;
249 /* How to print a vma value. */
250 typedef enum print_mode
262 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
270 : string_table + (X)->sh_name))
272 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
274 #define BYTE_GET(field) byte_get (field, sizeof (field))
276 #define GET_ELF_SYMBOLS(file, section) \
277 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
278 : get_64bit_elf_symbols (file, section))
280 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
281 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
282 already been called and verified that the string exists. */
283 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
285 /* This is just a bit of syntatic sugar. */
286 #define streq(a,b) (strcmp ((a), (b)) == 0)
287 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
288 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 #define REMOVE_ARCH_BITS(ADDR) do { \
291 if (elf_header.e_machine == EM_ARM) \
296 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
301 if (size
== 0 || nmemb
== 0)
304 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
306 error (_("Unable to seek to 0x%lx for %s\n"),
307 (unsigned long) archive_file_offset
+ offset
, reason
);
314 /* Check for overflow. */
315 if (nmemb
< (~(size_t) 0 - 1) / size
)
316 /* + 1 so that we can '\0' terminate invalid string table sections. */
317 mvar
= malloc (size
* nmemb
+ 1);
321 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
322 (unsigned long)(size
* nmemb
), reason
);
326 ((char *) mvar
)[size
* nmemb
] = '\0';
329 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
331 error (_("Unable to read in 0x%lx bytes of %s\n"),
332 (unsigned long)(size
* nmemb
), reason
);
342 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
347 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
348 field
[6] = ((value
>> 24) >> 24) & 0xff;
349 field
[5] = ((value
>> 24) >> 16) & 0xff;
350 field
[4] = ((value
>> 24) >> 8) & 0xff;
353 field
[3] = (value
>> 24) & 0xff;
356 field
[2] = (value
>> 16) & 0xff;
359 field
[1] = (value
>> 8) & 0xff;
362 field
[0] = value
& 0xff;
366 error (_("Unhandled data length: %d\n"), size
);
371 /* Print a VMA value. */
374 print_vma (bfd_vma vma
, print_mode mode
)
387 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
394 return printf ("%5" BFD_VMA_FMT
"d", vma
);
402 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
405 return printf ("%" BFD_VMA_FMT
"d", vma
);
408 return printf ("%" BFD_VMA_FMT
"u", vma
);
413 /* Display a symbol on stdout. Handles the display of non-printing characters.
415 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
416 truncating as necessary. If WIDTH is negative then format the string to be
417 exactly - WIDTH characters, truncating or padding as necessary.
419 Returns the number of emitted characters. */
422 print_symbol (int width
, const char * symbol
)
425 bfd_boolean extra_padding
= FALSE
;
426 unsigned int num_printed
= 0;
430 /* Set the width to a very large value. This simplifies the code below. */
435 /* Keep the width positive. This also helps. */
437 extra_padding
= TRUE
;
446 /* Look for non-printing symbols inside the symbol's name.
447 This test is triggered in particular by the names generated
448 by the assembler for local labels. */
449 while (ISPRINT (* c
))
459 printf ("%.*s", len
, symbol
);
465 if (* c
== 0 || width
== 0)
468 /* Now display the non-printing character, if
469 there is room left in which to dipslay it. */
475 printf ("^%c", *c
+ 0x40);
485 printf ("<0x%.2x>", *c
);
494 if (extra_padding
&& width
> 0)
496 /* Fill in the remaining spaces. */
497 printf ("%-*s", width
, " ");
505 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
510 field
[7] = value
& 0xff;
511 field
[6] = (value
>> 8) & 0xff;
512 field
[5] = (value
>> 16) & 0xff;
513 field
[4] = (value
>> 24) & 0xff;
518 field
[3] = value
& 0xff;
522 field
[2] = value
& 0xff;
526 field
[1] = value
& 0xff;
530 field
[0] = value
& 0xff;
534 error (_("Unhandled data length: %d\n"), size
);
539 /* Return a pointer to section NAME, or NULL if no such section exists. */
541 static Elf_Internal_Shdr
*
542 find_section (const char * name
)
546 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
547 if (streq (SECTION_NAME (section_headers
+ i
), name
))
548 return section_headers
+ i
;
553 /* Return a pointer to a section containing ADDR, or NULL if no such
556 static Elf_Internal_Shdr
*
557 find_section_by_address (bfd_vma addr
)
561 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
563 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
564 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
571 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
575 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
577 return read_leb128 (data
, length_return
, 0);
580 /* Guess the relocation size commonly used by the specific machines. */
583 guess_is_rela (unsigned int e_machine
)
587 /* Targets that use REL relocations. */
603 /* Targets that use RELA relocations. */
607 case EM_ALTERA_NIOS2
:
627 case EM_LATTICEMICO32
:
635 case EM_CYGNUS_MN10200
:
637 case EM_CYGNUS_MN10300
:
662 case EM_MICROBLAZE_OLD
:
683 warn (_("Don't know about relocations on this machine architecture\n"));
689 slurp_rela_relocs (FILE * file
,
690 unsigned long rel_offset
,
691 unsigned long rel_size
,
692 Elf_Internal_Rela
** relasp
,
693 unsigned long * nrelasp
)
695 Elf_Internal_Rela
* relas
;
696 unsigned long nrelas
;
701 Elf32_External_Rela
* erelas
;
703 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
704 rel_size
, _("relocs"));
708 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
710 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
711 sizeof (Elf_Internal_Rela
));
716 error (_("out of memory parsing relocs\n"));
720 for (i
= 0; i
< nrelas
; i
++)
722 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
723 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
724 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
731 Elf64_External_Rela
* erelas
;
733 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
734 rel_size
, _("relocs"));
738 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
740 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
741 sizeof (Elf_Internal_Rela
));
746 error (_("out of memory parsing relocs\n"));
750 for (i
= 0; i
< nrelas
; i
++)
752 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
753 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
754 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
756 /* The #ifdef BFD64 below is to prevent a compile time
757 warning. We know that if we do not have a 64 bit data
758 type that we will never execute this code anyway. */
760 if (elf_header
.e_machine
== EM_MIPS
761 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
763 /* In little-endian objects, r_info isn't really a
764 64-bit little-endian value: it has a 32-bit
765 little-endian symbol index followed by four
766 individual byte fields. Reorder INFO
768 bfd_vma inf
= relas
[i
].r_info
;
769 inf
= (((inf
& 0xffffffff) << 32)
770 | ((inf
>> 56) & 0xff)
771 | ((inf
>> 40) & 0xff00)
772 | ((inf
>> 24) & 0xff0000)
773 | ((inf
>> 8) & 0xff000000));
774 relas
[i
].r_info
= inf
;
787 slurp_rel_relocs (FILE * file
,
788 unsigned long rel_offset
,
789 unsigned long rel_size
,
790 Elf_Internal_Rela
** relsp
,
791 unsigned long * nrelsp
)
793 Elf_Internal_Rela
* rels
;
799 Elf32_External_Rel
* erels
;
801 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
802 rel_size
, _("relocs"));
806 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
808 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
813 error (_("out of memory parsing relocs\n"));
817 for (i
= 0; i
< nrels
; i
++)
819 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
820 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
821 rels
[i
].r_addend
= 0;
828 Elf64_External_Rel
* erels
;
830 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
831 rel_size
, _("relocs"));
835 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
837 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
842 error (_("out of memory parsing relocs\n"));
846 for (i
= 0; i
< nrels
; i
++)
848 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
849 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
850 rels
[i
].r_addend
= 0;
852 /* The #ifdef BFD64 below is to prevent a compile time
853 warning. We know that if we do not have a 64 bit data
854 type that we will never execute this code anyway. */
856 if (elf_header
.e_machine
== EM_MIPS
857 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
859 /* In little-endian objects, r_info isn't really a
860 64-bit little-endian value: it has a 32-bit
861 little-endian symbol index followed by four
862 individual byte fields. Reorder INFO
864 bfd_vma inf
= rels
[i
].r_info
;
865 inf
= (((inf
& 0xffffffff) << 32)
866 | ((inf
>> 56) & 0xff)
867 | ((inf
>> 40) & 0xff00)
868 | ((inf
>> 24) & 0xff0000)
869 | ((inf
>> 8) & 0xff000000));
870 rels
[i
].r_info
= inf
;
882 /* Returns the reloc type extracted from the reloc info field. */
885 get_reloc_type (bfd_vma reloc_info
)
888 return ELF32_R_TYPE (reloc_info
);
890 switch (elf_header
.e_machine
)
893 /* Note: We assume that reloc_info has already been adjusted for us. */
894 return ELF64_MIPS_R_TYPE (reloc_info
);
897 return ELF64_R_TYPE_ID (reloc_info
);
900 return ELF64_R_TYPE (reloc_info
);
904 /* Return the symbol index extracted from the reloc info field. */
907 get_reloc_symindex (bfd_vma reloc_info
)
909 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
912 /* Display the contents of the relocation data found at the specified
916 dump_relocations (FILE * file
,
917 unsigned long rel_offset
,
918 unsigned long rel_size
,
919 Elf_Internal_Sym
* symtab
,
922 unsigned long strtablen
,
926 Elf_Internal_Rela
* rels
;
928 if (is_rela
== UNKNOWN
)
929 is_rela
= guess_is_rela (elf_header
.e_machine
);
933 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
938 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
947 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
949 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
954 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
956 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
964 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
966 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
971 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
973 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
977 for (i
= 0; i
< rel_size
; i
++)
982 bfd_vma symtab_index
;
985 offset
= rels
[i
].r_offset
;
986 inf
= rels
[i
].r_info
;
988 type
= get_reloc_type (inf
);
989 symtab_index
= get_reloc_symindex (inf
);
993 printf ("%8.8lx %8.8lx ",
994 (unsigned long) offset
& 0xffffffff,
995 (unsigned long) inf
& 0xffffffff);
999 #if BFD_HOST_64BIT_LONG
1001 ? "%16.16lx %16.16lx "
1002 : "%12.12lx %12.12lx ",
1004 #elif BFD_HOST_64BIT_LONG_LONG
1007 ? "%16.16llx %16.16llx "
1008 : "%12.12llx %12.12llx ",
1012 ? "%16.16I64x %16.16I64x "
1013 : "%12.12I64x %12.12I64x ",
1018 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1019 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1020 _bfd_int64_high (offset
),
1021 _bfd_int64_low (offset
),
1022 _bfd_int64_high (inf
),
1023 _bfd_int64_low (inf
));
1027 switch (elf_header
.e_machine
)
1034 case EM_CYGNUS_M32R
:
1035 rtype
= elf_m32r_reloc_type (type
);
1040 rtype
= elf_i386_reloc_type (type
);
1045 rtype
= elf_m68hc11_reloc_type (type
);
1049 rtype
= elf_m68k_reloc_type (type
);
1053 rtype
= elf_i960_reloc_type (type
);
1058 rtype
= elf_avr_reloc_type (type
);
1061 case EM_OLD_SPARCV9
:
1062 case EM_SPARC32PLUS
:
1065 rtype
= elf_sparc_reloc_type (type
);
1069 rtype
= elf_spu_reloc_type (type
);
1073 case EM_CYGNUS_V850
:
1074 rtype
= v850_reloc_type (type
);
1078 case EM_CYGNUS_D10V
:
1079 rtype
= elf_d10v_reloc_type (type
);
1083 case EM_CYGNUS_D30V
:
1084 rtype
= elf_d30v_reloc_type (type
);
1088 rtype
= elf_dlx_reloc_type (type
);
1092 rtype
= elf_sh_reloc_type (type
);
1096 case EM_CYGNUS_MN10300
:
1097 rtype
= elf_mn10300_reloc_type (type
);
1101 case EM_CYGNUS_MN10200
:
1102 rtype
= elf_mn10200_reloc_type (type
);
1106 case EM_CYGNUS_FR30
:
1107 rtype
= elf_fr30_reloc_type (type
);
1111 rtype
= elf_frv_reloc_type (type
);
1115 rtype
= elf_mcore_reloc_type (type
);
1119 rtype
= elf_mmix_reloc_type (type
);
1124 rtype
= elf_msp430_reloc_type (type
);
1128 rtype
= elf_ppc_reloc_type (type
);
1132 rtype
= elf_ppc64_reloc_type (type
);
1136 case EM_MIPS_RS3_LE
:
1137 rtype
= elf_mips_reloc_type (type
);
1141 rtype
= elf_alpha_reloc_type (type
);
1145 rtype
= elf_arm_reloc_type (type
);
1149 rtype
= elf_arc_reloc_type (type
);
1153 rtype
= elf_hppa_reloc_type (type
);
1159 rtype
= elf_h8_reloc_type (type
);
1164 rtype
= elf_or32_reloc_type (type
);
1169 rtype
= elf_pj_reloc_type (type
);
1172 rtype
= elf_ia64_reloc_type (type
);
1176 rtype
= elf_cris_reloc_type (type
);
1180 rtype
= elf_i860_reloc_type (type
);
1185 rtype
= elf_x86_64_reloc_type (type
);
1189 rtype
= i370_reloc_type (type
);
1194 rtype
= elf_s390_reloc_type (type
);
1198 rtype
= elf_score_reloc_type (type
);
1202 rtype
= elf_xstormy16_reloc_type (type
);
1206 rtype
= elf_crx_reloc_type (type
);
1210 rtype
= elf_vax_reloc_type (type
);
1215 rtype
= elf_ip2k_reloc_type (type
);
1219 rtype
= elf_iq2000_reloc_type (type
);
1224 rtype
= elf_xtensa_reloc_type (type
);
1227 case EM_LATTICEMICO32
:
1228 rtype
= elf_lm32_reloc_type (type
);
1233 rtype
= elf_m32c_reloc_type (type
);
1237 rtype
= elf_mt_reloc_type (type
);
1241 rtype
= elf_bfin_reloc_type (type
);
1245 rtype
= elf_mep_reloc_type (type
);
1250 rtype
= elf_cr16_reloc_type (type
);
1254 case EM_MICROBLAZE_OLD
:
1255 rtype
= elf_microblaze_reloc_type (type
);
1259 rtype
= elf_rx_reloc_type (type
);
1264 rtype
= elf_xc16x_reloc_type (type
);
1268 rtype
= elf_tic6x_reloc_type (type
);
1273 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1275 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1277 if (elf_header
.e_machine
== EM_ALPHA
1279 && streq (rtype
, "R_ALPHA_LITUSE")
1282 switch (rels
[i
].r_addend
)
1284 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1285 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1286 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1287 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1288 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1289 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1290 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1291 default: rtype
= NULL
;
1294 printf (" (%s)", rtype
);
1298 printf (_("<unknown addend: %lx>"),
1299 (unsigned long) rels
[i
].r_addend
);
1302 else if (symtab_index
)
1304 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1305 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1308 Elf_Internal_Sym
* psym
;
1310 psym
= symtab
+ symtab_index
;
1314 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1318 unsigned int width
= is_32bit_elf
? 8 : 14;
1320 /* Relocations against GNU_IFUNC symbols do not use the value
1321 of the symbol as the address to relocate against. Instead
1322 they invoke the function named by the symbol and use its
1323 result as the address for relocation.
1325 To indicate this to the user, do not display the value of
1326 the symbol in the "Symbols's Value" field. Instead show
1327 its name followed by () as a hint that the symbol is
1331 || psym
->st_name
== 0
1332 || psym
->st_name
>= strtablen
)
1335 name
= strtab
+ psym
->st_name
;
1337 len
= print_symbol (width
, name
);
1338 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1342 print_vma (psym
->st_value
, LONG_HEX
);
1344 printf (is_32bit_elf
? " " : " ");
1347 if (psym
->st_name
== 0)
1349 const char * sec_name
= "<null>";
1352 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1354 if (psym
->st_shndx
< elf_header
.e_shnum
)
1356 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1357 else if (psym
->st_shndx
== SHN_ABS
)
1359 else if (psym
->st_shndx
== SHN_COMMON
)
1360 sec_name
= "COMMON";
1361 else if (elf_header
.e_machine
== EM_MIPS
1362 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1363 sec_name
= "SCOMMON";
1364 else if (elf_header
.e_machine
== EM_MIPS
1365 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1366 sec_name
= "SUNDEF";
1367 else if ((elf_header
.e_machine
== EM_X86_64
1368 || elf_header
.e_machine
== EM_L1OM
)
1369 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1370 sec_name
= "LARGE_COMMON";
1371 else if (elf_header
.e_machine
== EM_IA_64
1372 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1373 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1374 sec_name
= "ANSI_COM";
1375 else if (elf_header
.e_machine
== EM_IA_64
1376 && (elf_header
.e_ident
[EI_OSABI
]
1377 == ELFOSABI_OPENVMS
)
1378 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1379 sec_name
= "VMS_SYMVEC";
1382 sprintf (name_buf
, "<section 0x%x>",
1383 (unsigned int) psym
->st_shndx
);
1384 sec_name
= name_buf
;
1387 print_symbol (22, sec_name
);
1389 else if (strtab
== NULL
)
1390 printf (_("<string table index: %3ld>"), psym
->st_name
);
1391 else if (psym
->st_name
>= strtablen
)
1392 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1394 print_symbol (22, strtab
+ psym
->st_name
);
1398 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1401 printf (" - %lx", - off
);
1403 printf (" + %lx", off
);
1409 printf ("%*c", is_32bit_elf
?
1410 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1411 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1414 if (elf_header
.e_machine
== EM_SPARCV9
1416 && streq (rtype
, "R_SPARC_OLO10"))
1417 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1422 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1424 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1425 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1426 const char * rtype2
= elf_mips_reloc_type (type2
);
1427 const char * rtype3
= elf_mips_reloc_type (type3
);
1429 printf (" Type2: ");
1432 printf (_("unrecognized: %-7lx"),
1433 (unsigned long) type2
& 0xffffffff);
1435 printf ("%-17.17s", rtype2
);
1437 printf ("\n Type3: ");
1440 printf (_("unrecognized: %-7lx"),
1441 (unsigned long) type3
& 0xffffffff);
1443 printf ("%-17.17s", rtype3
);
1454 get_mips_dynamic_type (unsigned long type
)
1458 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1459 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1460 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1461 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1462 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1463 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1464 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1465 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1466 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1467 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1468 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1469 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1470 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1471 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1472 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1473 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1474 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1475 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1476 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1477 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1478 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1479 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1480 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1481 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1482 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1483 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1484 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1485 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1486 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1487 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1488 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1489 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1490 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1491 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1492 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1493 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1494 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1495 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1496 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1497 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1498 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1499 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1500 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1501 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1502 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1509 get_sparc64_dynamic_type (unsigned long type
)
1513 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1520 get_ppc_dynamic_type (unsigned long type
)
1524 case DT_PPC_GOT
: return "PPC_GOT";
1525 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1532 get_ppc64_dynamic_type (unsigned long type
)
1536 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1537 case DT_PPC64_OPD
: return "PPC64_OPD";
1538 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1539 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1546 get_parisc_dynamic_type (unsigned long type
)
1550 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1551 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1552 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1553 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1554 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1555 case DT_HP_PREINIT
: return "HP_PREINIT";
1556 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1557 case DT_HP_NEEDED
: return "HP_NEEDED";
1558 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1559 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1560 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1561 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1562 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1563 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1564 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1565 case DT_HP_FILTERED
: return "HP_FILTERED";
1566 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1567 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1568 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1569 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1570 case DT_PLT
: return "PLT";
1571 case DT_PLT_SIZE
: return "PLT_SIZE";
1572 case DT_DLT
: return "DLT";
1573 case DT_DLT_SIZE
: return "DLT_SIZE";
1580 get_ia64_dynamic_type (unsigned long type
)
1584 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1585 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1586 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1587 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1588 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1589 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1590 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1591 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1592 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1593 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1594 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1595 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1596 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1597 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1598 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1599 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1600 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1601 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1602 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1603 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1604 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1605 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1606 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1607 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1608 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1609 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1610 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1611 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1612 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1613 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1614 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1621 get_alpha_dynamic_type (unsigned long type
)
1625 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1632 get_score_dynamic_type (unsigned long type
)
1636 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1637 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1638 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1639 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1640 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1641 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1648 get_tic6x_dynamic_type (unsigned long type
)
1652 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1653 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1654 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1655 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1656 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1657 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1664 get_dynamic_type (unsigned long type
)
1666 static char buff
[64];
1670 case DT_NULL
: return "NULL";
1671 case DT_NEEDED
: return "NEEDED";
1672 case DT_PLTRELSZ
: return "PLTRELSZ";
1673 case DT_PLTGOT
: return "PLTGOT";
1674 case DT_HASH
: return "HASH";
1675 case DT_STRTAB
: return "STRTAB";
1676 case DT_SYMTAB
: return "SYMTAB";
1677 case DT_RELA
: return "RELA";
1678 case DT_RELASZ
: return "RELASZ";
1679 case DT_RELAENT
: return "RELAENT";
1680 case DT_STRSZ
: return "STRSZ";
1681 case DT_SYMENT
: return "SYMENT";
1682 case DT_INIT
: return "INIT";
1683 case DT_FINI
: return "FINI";
1684 case DT_SONAME
: return "SONAME";
1685 case DT_RPATH
: return "RPATH";
1686 case DT_SYMBOLIC
: return "SYMBOLIC";
1687 case DT_REL
: return "REL";
1688 case DT_RELSZ
: return "RELSZ";
1689 case DT_RELENT
: return "RELENT";
1690 case DT_PLTREL
: return "PLTREL";
1691 case DT_DEBUG
: return "DEBUG";
1692 case DT_TEXTREL
: return "TEXTREL";
1693 case DT_JMPREL
: return "JMPREL";
1694 case DT_BIND_NOW
: return "BIND_NOW";
1695 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1696 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1697 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1698 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1699 case DT_RUNPATH
: return "RUNPATH";
1700 case DT_FLAGS
: return "FLAGS";
1702 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1703 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1705 case DT_CHECKSUM
: return "CHECKSUM";
1706 case DT_PLTPADSZ
: return "PLTPADSZ";
1707 case DT_MOVEENT
: return "MOVEENT";
1708 case DT_MOVESZ
: return "MOVESZ";
1709 case DT_FEATURE
: return "FEATURE";
1710 case DT_POSFLAG_1
: return "POSFLAG_1";
1711 case DT_SYMINSZ
: return "SYMINSZ";
1712 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1714 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1715 case DT_CONFIG
: return "CONFIG";
1716 case DT_DEPAUDIT
: return "DEPAUDIT";
1717 case DT_AUDIT
: return "AUDIT";
1718 case DT_PLTPAD
: return "PLTPAD";
1719 case DT_MOVETAB
: return "MOVETAB";
1720 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1722 case DT_VERSYM
: return "VERSYM";
1724 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1725 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1726 case DT_RELACOUNT
: return "RELACOUNT";
1727 case DT_RELCOUNT
: return "RELCOUNT";
1728 case DT_FLAGS_1
: return "FLAGS_1";
1729 case DT_VERDEF
: return "VERDEF";
1730 case DT_VERDEFNUM
: return "VERDEFNUM";
1731 case DT_VERNEED
: return "VERNEED";
1732 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1734 case DT_AUXILIARY
: return "AUXILIARY";
1735 case DT_USED
: return "USED";
1736 case DT_FILTER
: return "FILTER";
1738 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1739 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1740 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1741 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1742 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1743 case DT_GNU_HASH
: return "GNU_HASH";
1746 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1748 const char * result
;
1750 switch (elf_header
.e_machine
)
1753 case EM_MIPS_RS3_LE
:
1754 result
= get_mips_dynamic_type (type
);
1757 result
= get_sparc64_dynamic_type (type
);
1760 result
= get_ppc_dynamic_type (type
);
1763 result
= get_ppc64_dynamic_type (type
);
1766 result
= get_ia64_dynamic_type (type
);
1769 result
= get_alpha_dynamic_type (type
);
1772 result
= get_score_dynamic_type (type
);
1775 result
= get_tic6x_dynamic_type (type
);
1785 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1787 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1788 || (elf_header
.e_machine
== EM_PARISC
1789 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1791 const char * result
;
1793 switch (elf_header
.e_machine
)
1796 result
= get_parisc_dynamic_type (type
);
1799 result
= get_ia64_dynamic_type (type
);
1809 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1813 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1820 get_file_type (unsigned e_type
)
1822 static char buff
[32];
1826 case ET_NONE
: return _("NONE (None)");
1827 case ET_REL
: return _("REL (Relocatable file)");
1828 case ET_EXEC
: return _("EXEC (Executable file)");
1829 case ET_DYN
: return _("DYN (Shared object file)");
1830 case ET_CORE
: return _("CORE (Core file)");
1833 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1834 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1835 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1836 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1838 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1844 get_machine_name (unsigned e_machine
)
1846 static char buff
[64]; /* XXX */
1850 case EM_NONE
: return _("None");
1851 case EM_M32
: return "WE32100";
1852 case EM_SPARC
: return "Sparc";
1853 case EM_SPU
: return "SPU";
1854 case EM_386
: return "Intel 80386";
1855 case EM_68K
: return "MC68000";
1856 case EM_88K
: return "MC88000";
1857 case EM_486
: return "Intel 80486";
1858 case EM_860
: return "Intel 80860";
1859 case EM_MIPS
: return "MIPS R3000";
1860 case EM_S370
: return "IBM System/370";
1861 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1862 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1863 case EM_PARISC
: return "HPPA";
1864 case EM_PPC_OLD
: return "Power PC (old)";
1865 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1866 case EM_960
: return "Intel 90860";
1867 case EM_PPC
: return "PowerPC";
1868 case EM_PPC64
: return "PowerPC64";
1869 case EM_V800
: return "NEC V800";
1870 case EM_FR20
: return "Fujitsu FR20";
1871 case EM_RH32
: return "TRW RH32";
1872 case EM_MCORE
: return "MCORE";
1873 case EM_ARM
: return "ARM";
1874 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1875 case EM_SH
: return "Renesas / SuperH SH";
1876 case EM_SPARCV9
: return "Sparc v9";
1877 case EM_TRICORE
: return "Siemens Tricore";
1878 case EM_ARC
: return "ARC";
1879 case EM_H8_300
: return "Renesas H8/300";
1880 case EM_H8_300H
: return "Renesas H8/300H";
1881 case EM_H8S
: return "Renesas H8S";
1882 case EM_H8_500
: return "Renesas H8/500";
1883 case EM_IA_64
: return "Intel IA-64";
1884 case EM_MIPS_X
: return "Stanford MIPS-X";
1885 case EM_COLDFIRE
: return "Motorola Coldfire";
1886 case EM_68HC12
: return "Motorola M68HC12";
1887 case EM_ALPHA
: return "Alpha";
1888 case EM_CYGNUS_D10V
:
1889 case EM_D10V
: return "d10v";
1890 case EM_CYGNUS_D30V
:
1891 case EM_D30V
: return "d30v";
1892 case EM_CYGNUS_M32R
:
1893 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1894 case EM_CYGNUS_V850
:
1895 case EM_V850
: return "NEC v850";
1896 case EM_CYGNUS_MN10300
:
1897 case EM_MN10300
: return "mn10300";
1898 case EM_CYGNUS_MN10200
:
1899 case EM_MN10200
: return "mn10200";
1900 case EM_CYGNUS_FR30
:
1901 case EM_FR30
: return "Fujitsu FR30";
1902 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1904 case EM_PJ
: return "picoJava";
1905 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1906 case EM_PCP
: return "Siemens PCP";
1907 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1908 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1909 case EM_STARCORE
: return "Motorola Star*Core processor";
1910 case EM_ME16
: return "Toyota ME16 processor";
1911 case EM_ST100
: return "STMicroelectronics ST100 processor";
1912 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1913 case EM_PDSP
: return "Sony DSP processor";
1914 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1915 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1916 case EM_FX66
: return "Siemens FX66 microcontroller";
1917 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1918 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1919 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1920 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1921 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1922 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1923 case EM_SVX
: return "Silicon Graphics SVx";
1924 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1925 case EM_VAX
: return "Digital VAX";
1927 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1928 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1929 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1930 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1931 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1932 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1933 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1934 case EM_PRISM
: return "Vitesse Prism";
1935 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1936 case EM_L1OM
: return "Intel L1OM";
1938 case EM_S390
: return "IBM S/390";
1939 case EM_SCORE
: return "SUNPLUS S+Core";
1940 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1942 case EM_OR32
: return "OpenRISC";
1943 case EM_ARC_A5
: return "ARC International ARCompact processor";
1944 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1945 case EM_DLX
: return "OpenDLX";
1947 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1948 case EM_IQ2000
: return "Vitesse IQ2000";
1950 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1951 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1952 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1953 case EM_NS32K
: return "National Semiconductor 32000 series";
1954 case EM_TPC
: return "Tenor Network TPC processor";
1955 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1956 case EM_MAX
: return "MAX Processor";
1957 case EM_CR
: return "National Semiconductor CompactRISC";
1958 case EM_F2MC16
: return "Fujitsu F2MC16";
1959 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1960 case EM_LATTICEMICO32
: return "Lattice Mico32";
1962 case EM_M32C
: return "Renesas M32c";
1963 case EM_MT
: return "Morpho Techologies MT processor";
1964 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1965 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1966 case EM_SEP
: return "Sharp embedded microprocessor";
1967 case EM_ARCA
: return "Arca RISC microprocessor";
1968 case EM_UNICORE
: return "Unicore";
1969 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1970 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1971 case EM_NIOS32
: return "Altera Nios";
1972 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1974 case EM_XC16X
: return "Infineon Technologies xc16x";
1975 case EM_M16C
: return "Renesas M16C series microprocessors";
1976 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1977 case EM_CE
: return "Freescale Communication Engine RISC core";
1978 case EM_TSK3000
: return "Altium TSK3000 core";
1979 case EM_RS08
: return "Freescale RS08 embedded processor";
1980 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1981 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1982 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1983 case EM_SE_C17
: return "Seiko Epson C17 family";
1984 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1985 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1986 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1987 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1988 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1989 case EM_R32C
: return "Renesas R32C series microprocessors";
1990 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1991 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1992 case EM_8051
: return "Intel 8051 and variants";
1993 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1994 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1995 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1996 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1997 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1998 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1999 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2000 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2002 case EM_CR16_OLD
: return "National Semiconductor's CR16";
2003 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
2004 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2005 case EM_RX
: return "Renesas RX";
2006 case EM_METAG
: return "Imagination Technologies META processor architecture";
2007 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2008 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2009 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2010 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2011 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2012 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2013 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2014 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2015 case EM_CUDA
: return "NVIDIA CUDA architecture";
2017 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2023 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2028 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2029 e_flags
&= ~ EF_ARM_EABIMASK
;
2031 /* Handle "generic" ARM flags. */
2032 if (e_flags
& EF_ARM_RELEXEC
)
2034 strcat (buf
, ", relocatable executable");
2035 e_flags
&= ~ EF_ARM_RELEXEC
;
2038 if (e_flags
& EF_ARM_HASENTRY
)
2040 strcat (buf
, ", has entry point");
2041 e_flags
&= ~ EF_ARM_HASENTRY
;
2044 /* Now handle EABI specific flags. */
2048 strcat (buf
, ", <unrecognized EABI>");
2053 case EF_ARM_EABI_VER1
:
2054 strcat (buf
, ", Version1 EABI");
2059 /* Process flags one bit at a time. */
2060 flag
= e_flags
& - e_flags
;
2065 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2066 strcat (buf
, ", sorted symbol tables");
2076 case EF_ARM_EABI_VER2
:
2077 strcat (buf
, ", Version2 EABI");
2082 /* Process flags one bit at a time. */
2083 flag
= e_flags
& - e_flags
;
2088 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2089 strcat (buf
, ", sorted symbol tables");
2092 case EF_ARM_DYNSYMSUSESEGIDX
:
2093 strcat (buf
, ", dynamic symbols use segment index");
2096 case EF_ARM_MAPSYMSFIRST
:
2097 strcat (buf
, ", mapping symbols precede others");
2107 case EF_ARM_EABI_VER3
:
2108 strcat (buf
, ", Version3 EABI");
2111 case EF_ARM_EABI_VER4
:
2112 strcat (buf
, ", Version4 EABI");
2115 case EF_ARM_EABI_VER5
:
2116 strcat (buf
, ", Version5 EABI");
2122 /* Process flags one bit at a time. */
2123 flag
= e_flags
& - e_flags
;
2129 strcat (buf
, ", BE8");
2133 strcat (buf
, ", LE8");
2143 case EF_ARM_EABI_UNKNOWN
:
2144 strcat (buf
, ", GNU EABI");
2149 /* Process flags one bit at a time. */
2150 flag
= e_flags
& - e_flags
;
2155 case EF_ARM_INTERWORK
:
2156 strcat (buf
, ", interworking enabled");
2159 case EF_ARM_APCS_26
:
2160 strcat (buf
, ", uses APCS/26");
2163 case EF_ARM_APCS_FLOAT
:
2164 strcat (buf
, ", uses APCS/float");
2168 strcat (buf
, ", position independent");
2172 strcat (buf
, ", 8 bit structure alignment");
2175 case EF_ARM_NEW_ABI
:
2176 strcat (buf
, ", uses new ABI");
2179 case EF_ARM_OLD_ABI
:
2180 strcat (buf
, ", uses old ABI");
2183 case EF_ARM_SOFT_FLOAT
:
2184 strcat (buf
, ", software FP");
2187 case EF_ARM_VFP_FLOAT
:
2188 strcat (buf
, ", VFP");
2191 case EF_ARM_MAVERICK_FLOAT
:
2192 strcat (buf
, ", Maverick FP");
2203 strcat (buf
,_(", <unknown>"));
2207 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2209 static char buf
[1024];
2221 decode_ARM_machine_flags (e_flags
, buf
);
2225 switch (e_flags
& EF_FRV_CPU_MASK
)
2227 case EF_FRV_CPU_GENERIC
:
2231 strcat (buf
, ", fr???");
2234 case EF_FRV_CPU_FR300
:
2235 strcat (buf
, ", fr300");
2238 case EF_FRV_CPU_FR400
:
2239 strcat (buf
, ", fr400");
2241 case EF_FRV_CPU_FR405
:
2242 strcat (buf
, ", fr405");
2245 case EF_FRV_CPU_FR450
:
2246 strcat (buf
, ", fr450");
2249 case EF_FRV_CPU_FR500
:
2250 strcat (buf
, ", fr500");
2252 case EF_FRV_CPU_FR550
:
2253 strcat (buf
, ", fr550");
2256 case EF_FRV_CPU_SIMPLE
:
2257 strcat (buf
, ", simple");
2259 case EF_FRV_CPU_TOMCAT
:
2260 strcat (buf
, ", tomcat");
2266 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2267 strcat (buf
, ", m68000");
2268 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2269 strcat (buf
, ", cpu32");
2270 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2271 strcat (buf
, ", fido_a");
2274 char const * isa
= _("unknown");
2275 char const * mac
= _("unknown mac");
2276 char const * additional
= NULL
;
2278 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2280 case EF_M68K_CF_ISA_A_NODIV
:
2282 additional
= ", nodiv";
2284 case EF_M68K_CF_ISA_A
:
2287 case EF_M68K_CF_ISA_A_PLUS
:
2290 case EF_M68K_CF_ISA_B_NOUSP
:
2292 additional
= ", nousp";
2294 case EF_M68K_CF_ISA_B
:
2298 strcat (buf
, ", cf, isa ");
2301 strcat (buf
, additional
);
2302 if (e_flags
& EF_M68K_CF_FLOAT
)
2303 strcat (buf
, ", float");
2304 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2309 case EF_M68K_CF_MAC
:
2312 case EF_M68K_CF_EMAC
:
2325 if (e_flags
& EF_PPC_EMB
)
2326 strcat (buf
, ", emb");
2328 if (e_flags
& EF_PPC_RELOCATABLE
)
2329 strcat (buf
, _(", relocatable"));
2331 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2332 strcat (buf
, _(", relocatable-lib"));
2336 case EM_CYGNUS_V850
:
2337 switch (e_flags
& EF_V850_ARCH
)
2340 strcat (buf
, ", v850e1");
2343 strcat (buf
, ", v850e");
2346 strcat (buf
, ", v850");
2349 strcat (buf
, _(", unknown v850 architecture variant"));
2355 case EM_CYGNUS_M32R
:
2356 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2357 strcat (buf
, ", m32r");
2361 case EM_MIPS_RS3_LE
:
2362 if (e_flags
& EF_MIPS_NOREORDER
)
2363 strcat (buf
, ", noreorder");
2365 if (e_flags
& EF_MIPS_PIC
)
2366 strcat (buf
, ", pic");
2368 if (e_flags
& EF_MIPS_CPIC
)
2369 strcat (buf
, ", cpic");
2371 if (e_flags
& EF_MIPS_UCODE
)
2372 strcat (buf
, ", ugen_reserved");
2374 if (e_flags
& EF_MIPS_ABI2
)
2375 strcat (buf
, ", abi2");
2377 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2378 strcat (buf
, ", odk first");
2380 if (e_flags
& EF_MIPS_32BITMODE
)
2381 strcat (buf
, ", 32bitmode");
2383 switch ((e_flags
& EF_MIPS_MACH
))
2385 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2386 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2387 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2388 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2389 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2390 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2391 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2392 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2393 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2394 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2395 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2396 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2397 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2398 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2399 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2401 /* We simply ignore the field in this case to avoid confusion:
2402 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2405 default: strcat (buf
, _(", unknown CPU")); break;
2408 switch ((e_flags
& EF_MIPS_ABI
))
2410 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2411 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2412 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2413 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2415 /* We simply ignore the field in this case to avoid confusion:
2416 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2417 This means it is likely to be an o32 file, but not for
2420 default: strcat (buf
, _(", unknown ABI")); break;
2423 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2424 strcat (buf
, ", mdmx");
2426 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2427 strcat (buf
, ", mips16");
2429 switch ((e_flags
& EF_MIPS_ARCH
))
2431 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2432 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2433 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2434 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2435 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2436 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2437 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2438 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2439 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2440 default: strcat (buf
, _(", unknown ISA")); break;
2446 switch ((e_flags
& EF_SH_MACH_MASK
))
2448 case EF_SH1
: strcat (buf
, ", sh1"); break;
2449 case EF_SH2
: strcat (buf
, ", sh2"); break;
2450 case EF_SH3
: strcat (buf
, ", sh3"); break;
2451 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2452 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2453 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2454 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2455 case EF_SH4
: strcat (buf
, ", sh4"); break;
2456 case EF_SH5
: strcat (buf
, ", sh5"); break;
2457 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2458 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2459 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2460 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2461 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2462 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2463 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2464 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2465 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2466 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2467 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2468 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2469 default: strcat (buf
, _(", unknown ISA")); break;
2475 if (e_flags
& EF_SPARC_32PLUS
)
2476 strcat (buf
, ", v8+");
2478 if (e_flags
& EF_SPARC_SUN_US1
)
2479 strcat (buf
, ", ultrasparcI");
2481 if (e_flags
& EF_SPARC_SUN_US3
)
2482 strcat (buf
, ", ultrasparcIII");
2484 if (e_flags
& EF_SPARC_HAL_R1
)
2485 strcat (buf
, ", halr1");
2487 if (e_flags
& EF_SPARC_LEDATA
)
2488 strcat (buf
, ", ledata");
2490 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2491 strcat (buf
, ", tso");
2493 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2494 strcat (buf
, ", pso");
2496 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2497 strcat (buf
, ", rmo");
2501 switch (e_flags
& EF_PARISC_ARCH
)
2503 case EFA_PARISC_1_0
:
2504 strcpy (buf
, ", PA-RISC 1.0");
2506 case EFA_PARISC_1_1
:
2507 strcpy (buf
, ", PA-RISC 1.1");
2509 case EFA_PARISC_2_0
:
2510 strcpy (buf
, ", PA-RISC 2.0");
2515 if (e_flags
& EF_PARISC_TRAPNIL
)
2516 strcat (buf
, ", trapnil");
2517 if (e_flags
& EF_PARISC_EXT
)
2518 strcat (buf
, ", ext");
2519 if (e_flags
& EF_PARISC_LSB
)
2520 strcat (buf
, ", lsb");
2521 if (e_flags
& EF_PARISC_WIDE
)
2522 strcat (buf
, ", wide");
2523 if (e_flags
& EF_PARISC_NO_KABP
)
2524 strcat (buf
, ", no kabp");
2525 if (e_flags
& EF_PARISC_LAZYSWAP
)
2526 strcat (buf
, ", lazyswap");
2531 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2532 strcat (buf
, ", new calling convention");
2534 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2535 strcat (buf
, ", gnu calling convention");
2539 if ((e_flags
& EF_IA_64_ABI64
))
2540 strcat (buf
, ", 64-bit");
2542 strcat (buf
, ", 32-bit");
2543 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2544 strcat (buf
, ", reduced fp model");
2545 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2546 strcat (buf
, ", no function descriptors, constant gp");
2547 else if ((e_flags
& EF_IA_64_CONS_GP
))
2548 strcat (buf
, ", constant gp");
2549 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2550 strcat (buf
, ", absolute");
2554 if ((e_flags
& EF_VAX_NONPIC
))
2555 strcat (buf
, ", non-PIC");
2556 if ((e_flags
& EF_VAX_DFLOAT
))
2557 strcat (buf
, ", D-Float");
2558 if ((e_flags
& EF_VAX_GFLOAT
))
2559 strcat (buf
, ", G-Float");
2563 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2564 strcat (buf
, ", 64-bit doubles");
2565 if (e_flags
& E_FLAG_RX_DSP
)
2566 strcat (buf
, ", dsp");
2569 if (e_flags
& EF_S390_HIGH_GPRS
)
2570 strcat (buf
, ", highgprs");
2573 if ((e_flags
& EF_C6000_REL
))
2574 strcat (buf
, ", relocatable module");
2582 get_osabi_name (unsigned int osabi
)
2584 static char buff
[32];
2588 case ELFOSABI_NONE
: return "UNIX - System V";
2589 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2590 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2591 case ELFOSABI_LINUX
: return "UNIX - Linux";
2592 case ELFOSABI_HURD
: return "GNU/Hurd";
2593 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2594 case ELFOSABI_AIX
: return "UNIX - AIX";
2595 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2596 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2597 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2598 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2599 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2600 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2601 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2602 case ELFOSABI_AROS
: return "AROS";
2603 case ELFOSABI_FENIXOS
: return "FenixOS";
2606 switch (elf_header
.e_machine
)
2611 case ELFOSABI_ARM
: return "ARM";
2621 case ELFOSABI_STANDALONE
: return _("Standalone App");
2630 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2631 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2640 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2646 get_arm_segment_type (unsigned long type
)
2660 get_mips_segment_type (unsigned long type
)
2664 case PT_MIPS_REGINFO
:
2666 case PT_MIPS_RTPROC
:
2668 case PT_MIPS_OPTIONS
:
2678 get_parisc_segment_type (unsigned long type
)
2682 case PT_HP_TLS
: return "HP_TLS";
2683 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2684 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2685 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2686 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2687 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2688 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2689 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2690 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2691 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2692 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2693 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2694 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2695 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2696 case PT_HP_STACK
: return "HP_STACK";
2697 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2698 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2699 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2700 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2709 get_ia64_segment_type (unsigned long type
)
2713 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2714 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2715 case PT_HP_TLS
: return "HP_TLS";
2716 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2717 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2718 case PT_IA_64_HP_STACK
: return "HP_STACK";
2727 get_tic6x_segment_type (unsigned long type
)
2731 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2740 get_segment_type (unsigned long p_type
)
2742 static char buff
[32];
2746 case PT_NULL
: return "NULL";
2747 case PT_LOAD
: return "LOAD";
2748 case PT_DYNAMIC
: return "DYNAMIC";
2749 case PT_INTERP
: return "INTERP";
2750 case PT_NOTE
: return "NOTE";
2751 case PT_SHLIB
: return "SHLIB";
2752 case PT_PHDR
: return "PHDR";
2753 case PT_TLS
: return "TLS";
2755 case PT_GNU_EH_FRAME
:
2756 return "GNU_EH_FRAME";
2757 case PT_GNU_STACK
: return "GNU_STACK";
2758 case PT_GNU_RELRO
: return "GNU_RELRO";
2761 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2763 const char * result
;
2765 switch (elf_header
.e_machine
)
2768 result
= get_arm_segment_type (p_type
);
2771 case EM_MIPS_RS3_LE
:
2772 result
= get_mips_segment_type (p_type
);
2775 result
= get_parisc_segment_type (p_type
);
2778 result
= get_ia64_segment_type (p_type
);
2781 result
= get_tic6x_segment_type (p_type
);
2791 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2793 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2795 const char * result
;
2797 switch (elf_header
.e_machine
)
2800 result
= get_parisc_segment_type (p_type
);
2803 result
= get_ia64_segment_type (p_type
);
2813 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2816 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2823 get_mips_section_type_name (unsigned int sh_type
)
2827 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2828 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2829 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2830 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2831 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2832 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2833 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2834 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2835 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2836 case SHT_MIPS_RELD
: return "MIPS_RELD";
2837 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2838 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2839 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2840 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2841 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2842 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2843 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2844 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2845 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2846 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2847 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2848 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2849 case SHT_MIPS_LINE
: return "MIPS_LINE";
2850 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2851 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2852 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2853 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2854 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2855 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2856 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2857 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2858 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2859 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2860 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2861 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2862 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2863 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2864 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2865 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2873 get_parisc_section_type_name (unsigned int sh_type
)
2877 case SHT_PARISC_EXT
: return "PARISC_EXT";
2878 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2879 case SHT_PARISC_DOC
: return "PARISC_DOC";
2880 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2881 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2882 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2883 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2891 get_ia64_section_type_name (unsigned int sh_type
)
2893 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2894 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2895 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2899 case SHT_IA_64_EXT
: return "IA_64_EXT";
2900 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2901 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2902 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2903 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2904 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2905 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2906 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2907 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2908 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2916 get_x86_64_section_type_name (unsigned int sh_type
)
2920 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2928 get_arm_section_type_name (unsigned int sh_type
)
2932 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2933 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2934 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2935 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2936 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2944 get_tic6x_section_type_name (unsigned int sh_type
)
2948 case SHT_C6000_UNWIND
:
2949 return "C6000_UNWIND";
2950 case SHT_C6000_PREEMPTMAP
:
2951 return "C6000_PREEMPTMAP";
2952 case SHT_C6000_ATTRIBUTES
:
2953 return "C6000_ATTRIBUTES";
2958 case SHT_TI_HANDLER
:
2959 return "TI_HANDLER";
2960 case SHT_TI_INITINFO
:
2961 return "TI_INITINFO";
2962 case SHT_TI_PHATTRS
:
2963 return "TI_PHATTRS";
2971 get_section_type_name (unsigned int sh_type
)
2973 static char buff
[32];
2977 case SHT_NULL
: return "NULL";
2978 case SHT_PROGBITS
: return "PROGBITS";
2979 case SHT_SYMTAB
: return "SYMTAB";
2980 case SHT_STRTAB
: return "STRTAB";
2981 case SHT_RELA
: return "RELA";
2982 case SHT_HASH
: return "HASH";
2983 case SHT_DYNAMIC
: return "DYNAMIC";
2984 case SHT_NOTE
: return "NOTE";
2985 case SHT_NOBITS
: return "NOBITS";
2986 case SHT_REL
: return "REL";
2987 case SHT_SHLIB
: return "SHLIB";
2988 case SHT_DYNSYM
: return "DYNSYM";
2989 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2990 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2991 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2992 case SHT_GNU_HASH
: return "GNU_HASH";
2993 case SHT_GROUP
: return "GROUP";
2994 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2995 case SHT_GNU_verdef
: return "VERDEF";
2996 case SHT_GNU_verneed
: return "VERNEED";
2997 case SHT_GNU_versym
: return "VERSYM";
2998 case 0x6ffffff0: return "VERSYM";
2999 case 0x6ffffffc: return "VERDEF";
3000 case 0x7ffffffd: return "AUXILIARY";
3001 case 0x7fffffff: return "FILTER";
3002 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3005 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3007 const char * result
;
3009 switch (elf_header
.e_machine
)
3012 case EM_MIPS_RS3_LE
:
3013 result
= get_mips_section_type_name (sh_type
);
3016 result
= get_parisc_section_type_name (sh_type
);
3019 result
= get_ia64_section_type_name (sh_type
);
3023 result
= get_x86_64_section_type_name (sh_type
);
3026 result
= get_arm_section_type_name (sh_type
);
3029 result
= get_tic6x_section_type_name (sh_type
);
3039 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3041 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3043 const char * result
;
3045 switch (elf_header
.e_machine
)
3048 result
= get_ia64_section_type_name (sh_type
);
3058 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3060 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3061 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3063 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3069 #define OPTION_DEBUG_DUMP 512
3070 #define OPTION_DYN_SYMS 513
3072 static struct option options
[] =
3074 {"all", no_argument
, 0, 'a'},
3075 {"file-header", no_argument
, 0, 'h'},
3076 {"program-headers", no_argument
, 0, 'l'},
3077 {"headers", no_argument
, 0, 'e'},
3078 {"histogram", no_argument
, 0, 'I'},
3079 {"segments", no_argument
, 0, 'l'},
3080 {"sections", no_argument
, 0, 'S'},
3081 {"section-headers", no_argument
, 0, 'S'},
3082 {"section-groups", no_argument
, 0, 'g'},
3083 {"section-details", no_argument
, 0, 't'},
3084 {"full-section-name",no_argument
, 0, 'N'},
3085 {"symbols", no_argument
, 0, 's'},
3086 {"syms", no_argument
, 0, 's'},
3087 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3088 {"relocs", no_argument
, 0, 'r'},
3089 {"notes", no_argument
, 0, 'n'},
3090 {"dynamic", no_argument
, 0, 'd'},
3091 {"arch-specific", no_argument
, 0, 'A'},
3092 {"version-info", no_argument
, 0, 'V'},
3093 {"use-dynamic", no_argument
, 0, 'D'},
3094 {"unwind", no_argument
, 0, 'u'},
3095 {"archive-index", no_argument
, 0, 'c'},
3096 {"hex-dump", required_argument
, 0, 'x'},
3097 {"relocated-dump", required_argument
, 0, 'R'},
3098 {"string-dump", required_argument
, 0, 'p'},
3099 #ifdef SUPPORT_DISASSEMBLY
3100 {"instruction-dump", required_argument
, 0, 'i'},
3102 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3104 {"version", no_argument
, 0, 'v'},
3105 {"wide", no_argument
, 0, 'W'},
3106 {"help", no_argument
, 0, 'H'},
3107 {0, no_argument
, 0, 0}
3111 usage (FILE * stream
)
3113 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3114 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3115 fprintf (stream
, _(" Options are:\n\
3116 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3117 -h --file-header Display the ELF file header\n\
3118 -l --program-headers Display the program headers\n\
3119 --segments An alias for --program-headers\n\
3120 -S --section-headers Display the sections' header\n\
3121 --sections An alias for --section-headers\n\
3122 -g --section-groups Display the section groups\n\
3123 -t --section-details Display the section details\n\
3124 -e --headers Equivalent to: -h -l -S\n\
3125 -s --syms Display the symbol table\n\
3126 --symbols An alias for --syms\n\
3127 --dyn-syms Display the dynamic symbol table\n\
3128 -n --notes Display the core notes (if present)\n\
3129 -r --relocs Display the relocations (if present)\n\
3130 -u --unwind Display the unwind info (if present)\n\
3131 -d --dynamic Display the dynamic section (if present)\n\
3132 -V --version-info Display the version sections (if present)\n\
3133 -A --arch-specific Display architecture specific information (if any).\n\
3134 -c --archive-index Display the symbol/file index in an archive\n\
3135 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3136 -x --hex-dump=<number|name>\n\
3137 Dump the contents of section <number|name> as bytes\n\
3138 -p --string-dump=<number|name>\n\
3139 Dump the contents of section <number|name> as strings\n\
3140 -R --relocated-dump=<number|name>\n\
3141 Dump the contents of section <number|name> as relocated bytes\n\
3142 -w[lLiaprmfFsoRt] or\n\
3143 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3144 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
3145 Display the contents of DWARF2 debug sections\n"));
3146 #ifdef SUPPORT_DISASSEMBLY
3147 fprintf (stream
, _("\
3148 -i --instruction-dump=<number|name>\n\
3149 Disassemble the contents of section <number|name>\n"));
3151 fprintf (stream
, _("\
3152 -I --histogram Display histogram of bucket list lengths\n\
3153 -W --wide Allow output width to exceed 80 characters\n\
3154 @<file> Read options from <file>\n\
3155 -H --help Display this information\n\
3156 -v --version Display the version number of readelf\n"));
3158 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3159 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3161 exit (stream
== stdout
? 0 : 1);
3164 /* Record the fact that the user wants the contents of section number
3165 SECTION to be displayed using the method(s) encoded as flags bits
3166 in TYPE. Note, TYPE can be zero if we are creating the array for
3170 request_dump_bynumber (unsigned int section
, dump_type type
)
3172 if (section
>= num_dump_sects
)
3174 dump_type
* new_dump_sects
;
3176 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3177 sizeof (* dump_sects
));
3179 if (new_dump_sects
== NULL
)
3180 error (_("Out of memory allocating dump request table.\n"));
3183 /* Copy current flag settings. */
3184 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3188 dump_sects
= new_dump_sects
;
3189 num_dump_sects
= section
+ 1;
3194 dump_sects
[section
] |= type
;
3199 /* Request a dump by section name. */
3202 request_dump_byname (const char * section
, dump_type type
)
3204 struct dump_list_entry
* new_request
;
3206 new_request
= (struct dump_list_entry
*)
3207 malloc (sizeof (struct dump_list_entry
));
3209 error (_("Out of memory allocating dump request table.\n"));
3211 new_request
->name
= strdup (section
);
3212 if (!new_request
->name
)
3213 error (_("Out of memory allocating dump request table.\n"));
3215 new_request
->type
= type
;
3217 new_request
->next
= dump_sects_byname
;
3218 dump_sects_byname
= new_request
;
3222 request_dump (dump_type type
)
3228 section
= strtoul (optarg
, & cp
, 0);
3230 if (! *cp
&& section
>= 0)
3231 request_dump_bynumber (section
, type
);
3233 request_dump_byname (optarg
, type
);
3238 parse_args (int argc
, char ** argv
)
3245 while ((c
= getopt_long
3246 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3264 do_section_groups
++;
3272 do_section_groups
++;
3277 do_section_details
++;
3321 request_dump (HEX_DUMP
);
3324 request_dump (STRING_DUMP
);
3327 request_dump (RELOC_DUMP
);
3334 dwarf_select_sections_all ();
3339 dwarf_select_sections_by_letters (optarg
);
3342 case OPTION_DEBUG_DUMP
:
3349 dwarf_select_sections_by_names (optarg
);
3352 case OPTION_DYN_SYMS
:
3355 #ifdef SUPPORT_DISASSEMBLY
3357 request_dump (DISASS_DUMP
);
3361 print_version (program_name
);
3370 /* xgettext:c-format */
3371 error (_("Invalid option '-%c'\n"), c
);
3378 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3379 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3380 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3381 && !do_section_groups
&& !do_archive_index
3386 warn (_("Nothing to do.\n"));
3392 get_elf_class (unsigned int elf_class
)
3394 static char buff
[32];
3398 case ELFCLASSNONE
: return _("none");
3399 case ELFCLASS32
: return "ELF32";
3400 case ELFCLASS64
: return "ELF64";
3402 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3408 get_data_encoding (unsigned int encoding
)
3410 static char buff
[32];
3414 case ELFDATANONE
: return _("none");
3415 case ELFDATA2LSB
: return _("2's complement, little endian");
3416 case ELFDATA2MSB
: return _("2's complement, big endian");
3418 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3423 /* Decode the data held in 'elf_header'. */
3426 process_file_header (void)
3428 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3429 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3430 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3431 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3434 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3438 init_dwarf_regnames (elf_header
.e_machine
);
3444 printf (_("ELF Header:\n"));
3445 printf (_(" Magic: "));
3446 for (i
= 0; i
< EI_NIDENT
; i
++)
3447 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3449 printf (_(" Class: %s\n"),
3450 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3451 printf (_(" Data: %s\n"),
3452 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3453 printf (_(" Version: %d %s\n"),
3454 elf_header
.e_ident
[EI_VERSION
],
3455 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3457 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3458 ? _("<unknown: %lx>")
3460 printf (_(" OS/ABI: %s\n"),
3461 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3462 printf (_(" ABI Version: %d\n"),
3463 elf_header
.e_ident
[EI_ABIVERSION
]);
3464 printf (_(" Type: %s\n"),
3465 get_file_type (elf_header
.e_type
));
3466 printf (_(" Machine: %s\n"),
3467 get_machine_name (elf_header
.e_machine
));
3468 printf (_(" Version: 0x%lx\n"),
3469 (unsigned long) elf_header
.e_version
);
3471 printf (_(" Entry point address: "));
3472 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3473 printf (_("\n Start of program headers: "));
3474 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3475 printf (_(" (bytes into file)\n Start of section headers: "));
3476 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3477 printf (_(" (bytes into file)\n"));
3479 printf (_(" Flags: 0x%lx%s\n"),
3480 (unsigned long) elf_header
.e_flags
,
3481 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3482 printf (_(" Size of this header: %ld (bytes)\n"),
3483 (long) elf_header
.e_ehsize
);
3484 printf (_(" Size of program headers: %ld (bytes)\n"),
3485 (long) elf_header
.e_phentsize
);
3486 printf (_(" Number of program headers: %ld"),
3487 (long) elf_header
.e_phnum
);
3488 if (section_headers
!= NULL
3489 && elf_header
.e_phnum
== PN_XNUM
3490 && section_headers
[0].sh_info
!= 0)
3491 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3492 putc ('\n', stdout
);
3493 printf (_(" Size of section headers: %ld (bytes)\n"),
3494 (long) elf_header
.e_shentsize
);
3495 printf (_(" Number of section headers: %ld"),
3496 (long) elf_header
.e_shnum
);
3497 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3498 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3499 putc ('\n', stdout
);
3500 printf (_(" Section header string table index: %ld"),
3501 (long) elf_header
.e_shstrndx
);
3502 if (section_headers
!= NULL
3503 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3504 printf (" (%u)", section_headers
[0].sh_link
);
3505 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3506 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3507 printf (_(" <corrupt: out of range>"));
3508 putc ('\n', stdout
);
3511 if (section_headers
!= NULL
)
3513 if (elf_header
.e_phnum
== PN_XNUM
3514 && section_headers
[0].sh_info
!= 0)
3515 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3516 if (elf_header
.e_shnum
== SHN_UNDEF
)
3517 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3518 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3519 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3520 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3521 elf_header
.e_shstrndx
= SHN_UNDEF
;
3522 free (section_headers
);
3523 section_headers
= NULL
;
3531 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3533 Elf32_External_Phdr
* phdrs
;
3534 Elf32_External_Phdr
* external
;
3535 Elf_Internal_Phdr
* internal
;
3538 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3539 elf_header
.e_phentsize
,
3541 _("program headers"));
3545 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3546 i
< elf_header
.e_phnum
;
3547 i
++, internal
++, external
++)
3549 internal
->p_type
= BYTE_GET (external
->p_type
);
3550 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3551 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3552 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3553 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3554 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3555 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3556 internal
->p_align
= BYTE_GET (external
->p_align
);
3565 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3567 Elf64_External_Phdr
* phdrs
;
3568 Elf64_External_Phdr
* external
;
3569 Elf_Internal_Phdr
* internal
;
3572 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3573 elf_header
.e_phentsize
,
3575 _("program headers"));
3579 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3580 i
< elf_header
.e_phnum
;
3581 i
++, internal
++, external
++)
3583 internal
->p_type
= BYTE_GET (external
->p_type
);
3584 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3585 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3586 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3587 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3588 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3589 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3590 internal
->p_align
= BYTE_GET (external
->p_align
);
3598 /* Returns 1 if the program headers were read into `program_headers'. */
3601 get_program_headers (FILE * file
)
3603 Elf_Internal_Phdr
* phdrs
;
3605 /* Check cache of prior read. */
3606 if (program_headers
!= NULL
)
3609 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3610 sizeof (Elf_Internal_Phdr
));
3614 error (_("Out of memory\n"));
3619 ? get_32bit_program_headers (file
, phdrs
)
3620 : get_64bit_program_headers (file
, phdrs
))
3622 program_headers
= phdrs
;
3630 /* Returns 1 if the program headers were loaded. */
3633 process_program_headers (FILE * file
)
3635 Elf_Internal_Phdr
* segment
;
3638 if (elf_header
.e_phnum
== 0)
3641 printf (_("\nThere are no program headers in this file.\n"));
3645 if (do_segments
&& !do_header
)
3647 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3648 printf (_("Entry point "));
3649 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3650 printf (_("\nThere are %d program headers, starting at offset "),
3651 elf_header
.e_phnum
);
3652 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3656 if (! get_program_headers (file
))
3661 if (elf_header
.e_phnum
> 1)
3662 printf (_("\nProgram Headers:\n"));
3664 printf (_("\nProgram Headers:\n"));
3668 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3671 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3675 (_(" Type Offset VirtAddr PhysAddr\n"));
3677 (_(" FileSiz MemSiz Flags Align\n"));
3684 for (i
= 0, segment
= program_headers
;
3685 i
< elf_header
.e_phnum
;
3690 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3694 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3695 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3696 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3697 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3698 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3700 (segment
->p_flags
& PF_R
? 'R' : ' '),
3701 (segment
->p_flags
& PF_W
? 'W' : ' '),
3702 (segment
->p_flags
& PF_X
? 'E' : ' '));
3703 printf ("%#lx", (unsigned long) segment
->p_align
);
3707 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3708 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3711 print_vma (segment
->p_offset
, FULL_HEX
);
3715 print_vma (segment
->p_vaddr
, FULL_HEX
);
3717 print_vma (segment
->p_paddr
, FULL_HEX
);
3720 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3721 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3724 print_vma (segment
->p_filesz
, FULL_HEX
);
3728 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3729 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3732 print_vma (segment
->p_offset
, FULL_HEX
);
3736 (segment
->p_flags
& PF_R
? 'R' : ' '),
3737 (segment
->p_flags
& PF_W
? 'W' : ' '),
3738 (segment
->p_flags
& PF_X
? 'E' : ' '));
3740 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3741 printf ("%#lx", (unsigned long) segment
->p_align
);
3744 print_vma (segment
->p_align
, PREFIX_HEX
);
3749 print_vma (segment
->p_offset
, FULL_HEX
);
3751 print_vma (segment
->p_vaddr
, FULL_HEX
);
3753 print_vma (segment
->p_paddr
, FULL_HEX
);
3755 print_vma (segment
->p_filesz
, FULL_HEX
);
3757 print_vma (segment
->p_memsz
, FULL_HEX
);
3759 (segment
->p_flags
& PF_R
? 'R' : ' '),
3760 (segment
->p_flags
& PF_W
? 'W' : ' '),
3761 (segment
->p_flags
& PF_X
? 'E' : ' '));
3762 print_vma (segment
->p_align
, HEX
);
3766 switch (segment
->p_type
)
3770 error (_("more than one dynamic segment\n"));
3772 /* By default, assume that the .dynamic section is the first
3773 section in the DYNAMIC segment. */
3774 dynamic_addr
= segment
->p_offset
;
3775 dynamic_size
= segment
->p_filesz
;
3777 /* Try to locate the .dynamic section. If there is
3778 a section header table, we can easily locate it. */
3779 if (section_headers
!= NULL
)
3781 Elf_Internal_Shdr
* sec
;
3783 sec
= find_section (".dynamic");
3784 if (sec
== NULL
|| sec
->sh_size
== 0)
3786 error (_("no .dynamic section in the dynamic segment\n"));
3790 if (sec
->sh_type
== SHT_NOBITS
)
3796 dynamic_addr
= sec
->sh_offset
;
3797 dynamic_size
= sec
->sh_size
;
3799 if (dynamic_addr
< segment
->p_offset
3800 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3801 warn (_("the .dynamic section is not contained"
3802 " within the dynamic segment\n"));
3803 else if (dynamic_addr
> segment
->p_offset
)
3804 warn (_("the .dynamic section is not the first section"
3805 " in the dynamic segment.\n"));
3810 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3812 error (_("Unable to find program interpreter name\n"));
3816 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3818 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3819 error (_("Internal error: failed to create format string to display program interpreter\n"));
3821 program_interpreter
[0] = 0;
3822 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3823 error (_("Unable to read program interpreter name\n"));
3826 printf (_("\n [Requesting program interpreter: %s]"),
3827 program_interpreter
);
3833 putc ('\n', stdout
);
3836 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3838 printf (_("\n Section to Segment mapping:\n"));
3839 printf (_(" Segment Sections...\n"));
3841 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3844 Elf_Internal_Shdr
* section
;
3846 segment
= program_headers
+ i
;
3847 section
= section_headers
+ 1;
3849 printf (" %2.2d ", i
);
3851 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3853 if (ELF_SECTION_SIZE (section
, segment
) != 0
3854 && ELF_SECTION_IN_SEGMENT (section
, segment
))
3855 printf ("%s ", SECTION_NAME (section
));
3866 /* Find the file offset corresponding to VMA by using the program headers. */
3869 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3871 Elf_Internal_Phdr
* seg
;
3873 if (! get_program_headers (file
))
3875 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3879 for (seg
= program_headers
;
3880 seg
< program_headers
+ elf_header
.e_phnum
;
3883 if (seg
->p_type
!= PT_LOAD
)
3886 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3887 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3888 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3891 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3892 (unsigned long) vma
);
3898 get_32bit_section_headers (FILE * file
, unsigned int num
)
3900 Elf32_External_Shdr
* shdrs
;
3901 Elf_Internal_Shdr
* internal
;
3904 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3905 elf_header
.e_shentsize
, num
,
3906 _("section headers"));
3910 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3911 sizeof (Elf_Internal_Shdr
));
3913 if (section_headers
== NULL
)
3915 error (_("Out of memory\n"));
3919 for (i
= 0, internal
= section_headers
;
3923 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3924 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3925 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3926 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3927 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3928 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3929 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3930 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3931 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3932 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3941 get_64bit_section_headers (FILE * file
, unsigned int num
)
3943 Elf64_External_Shdr
* shdrs
;
3944 Elf_Internal_Shdr
* internal
;
3947 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3948 elf_header
.e_shentsize
, num
,
3949 _("section headers"));
3953 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3954 sizeof (Elf_Internal_Shdr
));
3956 if (section_headers
== NULL
)
3958 error (_("Out of memory\n"));
3962 for (i
= 0, internal
= section_headers
;
3966 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3967 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3968 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3969 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3970 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3971 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3972 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3973 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3974 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3975 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3983 static Elf_Internal_Sym
*
3984 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3986 unsigned long number
;
3987 Elf32_External_Sym
* esyms
;
3988 Elf_External_Sym_Shndx
* shndx
;
3989 Elf_Internal_Sym
* isyms
;
3990 Elf_Internal_Sym
* psym
;
3993 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3994 section
->sh_size
, _("symbols"));
3999 if (symtab_shndx_hdr
!= NULL
4000 && (symtab_shndx_hdr
->sh_link
4001 == (unsigned long) (section
- section_headers
)))
4003 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4004 symtab_shndx_hdr
->sh_offset
,
4005 1, symtab_shndx_hdr
->sh_size
,
4014 number
= section
->sh_size
/ section
->sh_entsize
;
4015 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4019 error (_("Out of memory\n"));
4026 for (j
= 0, psym
= isyms
;
4030 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4031 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4032 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4033 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4034 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4036 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4037 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4038 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4039 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4040 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4050 static Elf_Internal_Sym
*
4051 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4053 unsigned long number
;
4054 Elf64_External_Sym
* esyms
;
4055 Elf_External_Sym_Shndx
* shndx
;
4056 Elf_Internal_Sym
* isyms
;
4057 Elf_Internal_Sym
* psym
;
4060 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4061 section
->sh_size
, _("symbols"));
4066 if (symtab_shndx_hdr
!= NULL
4067 && (symtab_shndx_hdr
->sh_link
4068 == (unsigned long) (section
- section_headers
)))
4070 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4071 symtab_shndx_hdr
->sh_offset
,
4072 1, symtab_shndx_hdr
->sh_size
,
4081 number
= section
->sh_size
/ section
->sh_entsize
;
4082 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4086 error (_("Out of memory\n"));
4093 for (j
= 0, psym
= isyms
;
4097 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4098 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4099 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4100 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4101 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4103 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4104 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4105 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4106 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4107 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4118 get_elf_section_flags (bfd_vma sh_flags
)
4120 static char buff
[1024];
4122 int field_size
= is_32bit_elf
? 8 : 16;
4124 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4125 bfd_vma os_flags
= 0;
4126 bfd_vma proc_flags
= 0;
4127 bfd_vma unknown_flags
= 0;
4135 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4136 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4137 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4138 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4139 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4140 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4141 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4142 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4143 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4144 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4145 /* IA-64 specific. */
4146 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4147 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4148 /* IA-64 OpenVMS specific. */
4149 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4150 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4151 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4152 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4153 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4154 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4155 /* SPARC specific. */
4156 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4157 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4160 if (do_section_details
)
4162 sprintf (buff
, "[%*.*lx]: ",
4163 field_size
, field_size
, (unsigned long) sh_flags
);
4164 p
+= field_size
+ 4;
4171 flag
= sh_flags
& - sh_flags
;
4174 if (do_section_details
)
4178 case SHF_WRITE
: sindex
= 0; break;
4179 case SHF_ALLOC
: sindex
= 1; break;
4180 case SHF_EXECINSTR
: sindex
= 2; break;
4181 case SHF_MERGE
: sindex
= 3; break;
4182 case SHF_STRINGS
: sindex
= 4; break;
4183 case SHF_INFO_LINK
: sindex
= 5; break;
4184 case SHF_LINK_ORDER
: sindex
= 6; break;
4185 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4186 case SHF_GROUP
: sindex
= 8; break;
4187 case SHF_TLS
: sindex
= 9; break;
4191 switch (elf_header
.e_machine
)
4194 if (flag
== SHF_IA_64_SHORT
)
4196 else if (flag
== SHF_IA_64_NORECOV
)
4199 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4202 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4203 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4204 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4205 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4206 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4207 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4216 case EM_OLD_SPARCV9
:
4217 case EM_SPARC32PLUS
:
4220 if (flag
== SHF_EXCLUDE
)
4222 else if (flag
== SHF_ORDERED
)
4232 if (p
!= buff
+ field_size
+ 4)
4234 if (size
< (10 + 2))
4241 size
-= flags
[sindex
].len
;
4242 p
= stpcpy (p
, flags
[sindex
].str
);
4244 else if (flag
& SHF_MASKOS
)
4246 else if (flag
& SHF_MASKPROC
)
4249 unknown_flags
|= flag
;
4255 case SHF_WRITE
: *p
= 'W'; break;
4256 case SHF_ALLOC
: *p
= 'A'; break;
4257 case SHF_EXECINSTR
: *p
= 'X'; break;
4258 case SHF_MERGE
: *p
= 'M'; break;
4259 case SHF_STRINGS
: *p
= 'S'; break;
4260 case SHF_INFO_LINK
: *p
= 'I'; break;
4261 case SHF_LINK_ORDER
: *p
= 'L'; break;
4262 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4263 case SHF_GROUP
: *p
= 'G'; break;
4264 case SHF_TLS
: *p
= 'T'; break;
4267 if ((elf_header
.e_machine
== EM_X86_64
4268 || elf_header
.e_machine
== EM_L1OM
)
4269 && flag
== SHF_X86_64_LARGE
)
4271 else if (flag
& SHF_MASKOS
)
4274 sh_flags
&= ~ SHF_MASKOS
;
4276 else if (flag
& SHF_MASKPROC
)
4279 sh_flags
&= ~ SHF_MASKPROC
;
4289 if (do_section_details
)
4293 size
-= 5 + field_size
;
4294 if (p
!= buff
+ field_size
+ 4)
4302 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4303 (unsigned long) os_flags
);
4304 p
+= 5 + field_size
;
4308 size
-= 7 + field_size
;
4309 if (p
!= buff
+ field_size
+ 4)
4317 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4318 (unsigned long) proc_flags
);
4319 p
+= 7 + field_size
;
4323 size
-= 10 + field_size
;
4324 if (p
!= buff
+ field_size
+ 4)
4332 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4333 (unsigned long) unknown_flags
);
4334 p
+= 10 + field_size
;
4343 process_section_headers (FILE * file
)
4345 Elf_Internal_Shdr
* section
;
4348 section_headers
= NULL
;
4350 if (elf_header
.e_shnum
== 0)
4353 printf (_("\nThere are no sections in this file.\n"));
4358 if (do_sections
&& !do_header
)
4359 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4360 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4364 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4367 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4370 /* Read in the string table, so that we have names to display. */
4371 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4372 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4374 section
= section_headers
+ elf_header
.e_shstrndx
;
4376 if (section
->sh_size
!= 0)
4378 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4379 1, section
->sh_size
,
4382 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4386 /* Scan the sections for the dynamic symbol table
4387 and dynamic string table and debug sections. */
4388 dynamic_symbols
= NULL
;
4389 dynamic_strings
= NULL
;
4390 dynamic_syminfo
= NULL
;
4391 symtab_shndx_hdr
= NULL
;
4393 eh_addr_size
= is_32bit_elf
? 4 : 8;
4394 switch (elf_header
.e_machine
)
4397 case EM_MIPS_RS3_LE
:
4398 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4399 FDE addresses. However, the ABI also has a semi-official ILP32
4400 variant for which the normal FDE address size rules apply.
4402 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4403 section, where XX is the size of longs in bits. Unfortunately,
4404 earlier compilers provided no way of distinguishing ILP32 objects
4405 from LP64 objects, so if there's any doubt, we should assume that
4406 the official LP64 form is being used. */
4407 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4408 && find_section (".gcc_compiled_long32") == NULL
)
4414 switch (elf_header
.e_flags
& EF_H8_MACH
)
4416 case E_H8_MACH_H8300
:
4417 case E_H8_MACH_H8300HN
:
4418 case E_H8_MACH_H8300SN
:
4419 case E_H8_MACH_H8300SXN
:
4422 case E_H8_MACH_H8300H
:
4423 case E_H8_MACH_H8300S
:
4424 case E_H8_MACH_H8300SX
:
4432 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4434 case EF_M32C_CPU_M16C
:
4441 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4444 size_t expected_entsize \
4445 = is_32bit_elf ? size32 : size64; \
4446 if (section->sh_entsize != expected_entsize) \
4447 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4448 i, (unsigned long int) section->sh_entsize, \
4449 (unsigned long int) expected_entsize); \
4450 section->sh_entsize = expected_entsize; \
4453 #define CHECK_ENTSIZE(section, i, type) \
4454 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4455 sizeof (Elf64_External_##type))
4457 for (i
= 0, section
= section_headers
;
4458 i
< elf_header
.e_shnum
;
4461 char * name
= SECTION_NAME (section
);
4463 if (section
->sh_type
== SHT_DYNSYM
)
4465 if (dynamic_symbols
!= NULL
)
4467 error (_("File contains multiple dynamic symbol tables\n"));
4471 CHECK_ENTSIZE (section
, i
, Sym
);
4472 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4473 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4475 else if (section
->sh_type
== SHT_STRTAB
4476 && streq (name
, ".dynstr"))
4478 if (dynamic_strings
!= NULL
)
4480 error (_("File contains multiple dynamic string tables\n"));
4484 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4485 1, section
->sh_size
,
4486 _("dynamic strings"));
4487 dynamic_strings_length
= section
->sh_size
;
4489 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4491 if (symtab_shndx_hdr
!= NULL
)
4493 error (_("File contains multiple symtab shndx tables\n"));
4496 symtab_shndx_hdr
= section
;
4498 else if (section
->sh_type
== SHT_SYMTAB
)
4499 CHECK_ENTSIZE (section
, i
, Sym
);
4500 else if (section
->sh_type
== SHT_GROUP
)
4501 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4502 else if (section
->sh_type
== SHT_REL
)
4503 CHECK_ENTSIZE (section
, i
, Rel
);
4504 else if (section
->sh_type
== SHT_RELA
)
4505 CHECK_ENTSIZE (section
, i
, Rela
);
4506 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4507 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4508 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4509 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4510 && (const_strneq (name
, ".debug_")
4511 || const_strneq (name
, ".zdebug_")))
4514 name
+= sizeof (".zdebug_") - 1;
4516 name
+= sizeof (".debug_") - 1;
4519 || (do_debug_info
&& streq (name
, "info"))
4520 || (do_debug_info
&& streq (name
, "types"))
4521 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4522 || (do_debug_lines
&& streq (name
, "line"))
4523 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4524 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4525 || (do_debug_aranges
&& streq (name
, "aranges"))
4526 || (do_debug_ranges
&& streq (name
, "ranges"))
4527 || (do_debug_frames
&& streq (name
, "frame"))
4528 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4529 || (do_debug_str
&& streq (name
, "str"))
4530 || (do_debug_loc
&& streq (name
, "loc"))
4532 request_dump_bynumber (i
, DEBUG_DUMP
);
4534 /* Linkonce section to be combined with .debug_info at link time. */
4535 else if ((do_debugging
|| do_debug_info
)
4536 && const_strneq (name
, ".gnu.linkonce.wi."))
4537 request_dump_bynumber (i
, DEBUG_DUMP
);
4538 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4539 request_dump_bynumber (i
, DEBUG_DUMP
);
4545 if (elf_header
.e_shnum
> 1)
4546 printf (_("\nSection Headers:\n"));
4548 printf (_("\nSection Header:\n"));
4552 if (do_section_details
)
4554 printf (_(" [Nr] Name\n"));
4555 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4559 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4563 if (do_section_details
)
4565 printf (_(" [Nr] Name\n"));
4566 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4570 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4574 if (do_section_details
)
4576 printf (_(" [Nr] Name\n"));
4577 printf (_(" Type Address Offset Link\n"));
4578 printf (_(" Size EntSize Info Align\n"));
4582 printf (_(" [Nr] Name Type Address Offset\n"));
4583 printf (_(" Size EntSize Flags Link Info Align\n"));
4587 if (do_section_details
)
4588 printf (_(" Flags\n"));
4590 for (i
= 0, section
= section_headers
;
4591 i
< elf_header
.e_shnum
;
4594 if (do_section_details
)
4596 printf (" [%2u] %s\n",
4598 SECTION_NAME (section
));
4599 if (is_32bit_elf
|| do_wide
)
4600 printf (" %-15.15s ",
4601 get_section_type_name (section
->sh_type
));
4604 printf ((do_wide
? " [%2u] %-17s %-15s "
4605 : " [%2u] %-17.17s %-15.15s "),
4607 SECTION_NAME (section
),
4608 get_section_type_name (section
->sh_type
));
4612 const char * link_too_big
= NULL
;
4614 print_vma (section
->sh_addr
, LONG_HEX
);
4616 printf ( " %6.6lx %6.6lx %2.2lx",
4617 (unsigned long) section
->sh_offset
,
4618 (unsigned long) section
->sh_size
,
4619 (unsigned long) section
->sh_entsize
);
4621 if (do_section_details
)
4622 fputs (" ", stdout
);
4624 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4626 if (section
->sh_link
>= elf_header
.e_shnum
)
4629 /* The sh_link value is out of range. Normally this indicates
4630 an error but it can have special values in Solaris binaries. */
4631 switch (elf_header
.e_machine
)
4636 case EM_OLD_SPARCV9
:
4637 case EM_SPARC32PLUS
:
4640 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4641 link_too_big
= "BEFORE";
4642 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4643 link_too_big
= "AFTER";
4650 if (do_section_details
)
4652 if (link_too_big
!= NULL
&& * link_too_big
)
4653 printf ("<%s> ", link_too_big
);
4655 printf ("%2u ", section
->sh_link
);
4656 printf ("%3u %2lu\n", section
->sh_info
,
4657 (unsigned long) section
->sh_addralign
);
4660 printf ("%2u %3u %2lu\n",
4663 (unsigned long) section
->sh_addralign
);
4665 if (link_too_big
&& ! * link_too_big
)
4666 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4667 i
, section
->sh_link
);
4671 print_vma (section
->sh_addr
, LONG_HEX
);
4673 if ((long) section
->sh_offset
== section
->sh_offset
)
4674 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4678 print_vma (section
->sh_offset
, LONG_HEX
);
4681 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4682 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4686 print_vma (section
->sh_size
, LONG_HEX
);
4689 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4690 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4694 print_vma (section
->sh_entsize
, LONG_HEX
);
4697 if (do_section_details
)
4698 fputs (" ", stdout
);
4700 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4702 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4704 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4705 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4708 print_vma (section
->sh_addralign
, DEC
);
4712 else if (do_section_details
)
4714 printf (" %-15.15s ",
4715 get_section_type_name (section
->sh_type
));
4716 print_vma (section
->sh_addr
, LONG_HEX
);
4717 if ((long) section
->sh_offset
== section
->sh_offset
)
4718 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4722 print_vma (section
->sh_offset
, LONG_HEX
);
4724 printf (" %u\n ", section
->sh_link
);
4725 print_vma (section
->sh_size
, LONG_HEX
);
4727 print_vma (section
->sh_entsize
, LONG_HEX
);
4729 printf (" %-16u %lu\n",
4731 (unsigned long) section
->sh_addralign
);
4736 print_vma (section
->sh_addr
, LONG_HEX
);
4737 if ((long) section
->sh_offset
== section
->sh_offset
)
4738 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4742 print_vma (section
->sh_offset
, LONG_HEX
);
4745 print_vma (section
->sh_size
, LONG_HEX
);
4747 print_vma (section
->sh_entsize
, LONG_HEX
);
4749 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4751 printf (" %2u %3u %lu\n",
4754 (unsigned long) section
->sh_addralign
);
4757 if (do_section_details
)
4758 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4761 if (!do_section_details
)
4762 printf (_("Key to Flags:\n\
4763 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4764 I (info), L (link order), G (group), x (unknown)\n\
4765 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4771 get_group_flags (unsigned int flags
)
4773 static char buff
[32];
4783 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4790 process_section_groups (FILE * file
)
4792 Elf_Internal_Shdr
* section
;
4794 struct group
* group
;
4795 Elf_Internal_Shdr
* symtab_sec
;
4796 Elf_Internal_Shdr
* strtab_sec
;
4797 Elf_Internal_Sym
* symtab
;
4801 /* Don't process section groups unless needed. */
4802 if (!do_unwind
&& !do_section_groups
)
4805 if (elf_header
.e_shnum
== 0)
4807 if (do_section_groups
)
4808 printf (_("\nThere are no sections in this file.\n"));
4813 if (section_headers
== NULL
)
4815 error (_("Section headers are not available!\n"));
4819 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4820 sizeof (struct group
*));
4822 if (section_headers_groups
== NULL
)
4824 error (_("Out of memory\n"));
4828 /* Scan the sections for the group section. */
4830 for (i
= 0, section
= section_headers
;
4831 i
< elf_header
.e_shnum
;
4833 if (section
->sh_type
== SHT_GROUP
)
4836 if (group_count
== 0)
4838 if (do_section_groups
)
4839 printf (_("\nThere are no section groups in this file.\n"));
4844 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4846 if (section_groups
== NULL
)
4848 error (_("Out of memory\n"));
4857 for (i
= 0, section
= section_headers
, group
= section_groups
;
4858 i
< elf_header
.e_shnum
;
4861 if (section
->sh_type
== SHT_GROUP
)
4863 char * name
= SECTION_NAME (section
);
4865 unsigned char * start
;
4866 unsigned char * indices
;
4867 unsigned int entry
, j
, size
;
4868 Elf_Internal_Shdr
* sec
;
4869 Elf_Internal_Sym
* sym
;
4871 /* Get the symbol table. */
4872 if (section
->sh_link
>= elf_header
.e_shnum
4873 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4876 error (_("Bad sh_link in group section `%s'\n"), name
);
4880 if (symtab_sec
!= sec
)
4885 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4888 sym
= symtab
+ section
->sh_info
;
4890 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4892 if (sym
->st_shndx
== 0
4893 || sym
->st_shndx
>= elf_header
.e_shnum
)
4895 error (_("Bad sh_info in group section `%s'\n"), name
);
4899 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4908 /* Get the string table. */
4909 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4918 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4923 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4924 1, strtab_sec
->sh_size
,
4926 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4928 group_name
= sym
->st_name
< strtab_size
4929 ? strtab
+ sym
->st_name
: _("<corrupt>");
4932 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4933 1, section
->sh_size
,
4937 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4938 entry
= byte_get (indices
, 4);
4941 if (do_section_groups
)
4943 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
4944 get_group_flags (entry
), i
, name
, group_name
, size
);
4946 printf (_(" [Index] Name\n"));
4949 group
->group_index
= i
;
4951 for (j
= 0; j
< size
; j
++)
4953 struct group_list
* g
;
4955 entry
= byte_get (indices
, 4);
4958 if (entry
>= elf_header
.e_shnum
)
4960 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4961 entry
, i
, elf_header
.e_shnum
- 1);
4965 if (section_headers_groups
[entry
] != NULL
)
4969 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4971 section_headers_groups
[entry
]->group_index
);
4976 /* Intel C/C++ compiler may put section 0 in a
4977 section group. We just warn it the first time
4978 and ignore it afterwards. */
4979 static int warned
= 0;
4982 error (_("section 0 in group section [%5u]\n"),
4983 section_headers_groups
[entry
]->group_index
);
4989 section_headers_groups
[entry
] = group
;
4991 if (do_section_groups
)
4993 sec
= section_headers
+ entry
;
4994 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4997 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4998 g
->section_index
= entry
;
4999 g
->next
= group
->root
;
5023 } dynamic_relocations
[] =
5025 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5026 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5027 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5030 /* Process the reloc section. */
5033 process_relocs (FILE * file
)
5035 unsigned long rel_size
;
5036 unsigned long rel_offset
;
5042 if (do_using_dynamic
)
5046 int has_dynamic_reloc
;
5049 has_dynamic_reloc
= 0;
5051 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5053 is_rela
= dynamic_relocations
[i
].rela
;
5054 name
= dynamic_relocations
[i
].name
;
5055 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5056 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5058 has_dynamic_reloc
|= rel_size
;
5060 if (is_rela
== UNKNOWN
)
5062 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5063 switch (dynamic_info
[DT_PLTREL
])
5077 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5078 name
, rel_offset
, rel_size
);
5080 dump_relocations (file
,
5081 offset_from_vma (file
, rel_offset
, rel_size
),
5083 dynamic_symbols
, num_dynamic_syms
,
5084 dynamic_strings
, dynamic_strings_length
, is_rela
);
5088 if (! has_dynamic_reloc
)
5089 printf (_("\nThere are no dynamic relocations in this file.\n"));
5093 Elf_Internal_Shdr
* section
;
5097 for (i
= 0, section
= section_headers
;
5098 i
< elf_header
.e_shnum
;
5101 if ( section
->sh_type
!= SHT_RELA
5102 && section
->sh_type
!= SHT_REL
)
5105 rel_offset
= section
->sh_offset
;
5106 rel_size
= section
->sh_size
;
5110 Elf_Internal_Shdr
* strsec
;
5113 printf (_("\nRelocation section "));
5115 if (string_table
== NULL
)
5116 printf ("%d", section
->sh_name
);
5118 printf (_("'%s'"), SECTION_NAME (section
));
5120 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5121 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5123 is_rela
= section
->sh_type
== SHT_RELA
;
5125 if (section
->sh_link
!= 0
5126 && section
->sh_link
< elf_header
.e_shnum
)
5128 Elf_Internal_Shdr
* symsec
;
5129 Elf_Internal_Sym
* symtab
;
5130 unsigned long nsyms
;
5131 unsigned long strtablen
= 0;
5132 char * strtab
= NULL
;
5134 symsec
= section_headers
+ section
->sh_link
;
5135 if (symsec
->sh_type
!= SHT_SYMTAB
5136 && symsec
->sh_type
!= SHT_DYNSYM
)
5139 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5140 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5145 if (symsec
->sh_link
!= 0
5146 && symsec
->sh_link
< elf_header
.e_shnum
)
5148 strsec
= section_headers
+ symsec
->sh_link
;
5150 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5153 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5156 dump_relocations (file
, rel_offset
, rel_size
,
5157 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5163 dump_relocations (file
, rel_offset
, rel_size
,
5164 NULL
, 0, NULL
, 0, is_rela
);
5171 printf (_("\nThere are no relocations in this file.\n"));
5177 /* Process the unwind section. */
5179 #include "unwind-ia64.h"
5181 /* An absolute address consists of a section and an offset. If the
5182 section is NULL, the offset itself is the address, otherwise, the
5183 address equals to LOAD_ADDRESS(section) + offset. */
5187 unsigned short section
;
5191 #define ABSADDR(a) \
5193 ? section_headers [(a).section].sh_addr + (a).offset \
5196 struct ia64_unw_table_entry
5198 struct absaddr start
;
5200 struct absaddr info
;
5203 struct ia64_unw_aux_info
5206 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5207 unsigned long table_len
; /* Length of unwind table. */
5208 unsigned char * info
; /* Unwind info. */
5209 unsigned long info_size
; /* Size of unwind info. */
5210 bfd_vma info_addr
; /* starting address of unwind info. */
5211 bfd_vma seg_base
; /* Starting address of segment. */
5212 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5213 unsigned long nsyms
; /* Number of symbols. */
5214 char * strtab
; /* The string table. */
5215 unsigned long strtab_size
; /* Size of string table. */
5219 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5220 unsigned long nsyms
,
5221 const char * strtab
,
5222 unsigned long strtab_size
,
5223 struct absaddr addr
,
5224 const char ** symname
,
5227 bfd_vma dist
= 0x100000;
5228 Elf_Internal_Sym
* sym
;
5229 Elf_Internal_Sym
* best
= NULL
;
5232 REMOVE_ARCH_BITS (addr
.offset
);
5234 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5236 bfd_vma value
= sym
->st_value
;
5238 REMOVE_ARCH_BITS (value
);
5240 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5241 && sym
->st_name
!= 0
5242 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5243 && addr
.offset
>= value
5244 && addr
.offset
- value
< dist
)
5247 dist
= addr
.offset
- value
;
5254 *symname
= (best
->st_name
>= strtab_size
5255 ? _("<corrupt>") : strtab
+ best
->st_name
);
5260 *offset
= addr
.offset
;
5264 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5266 struct ia64_unw_table_entry
* tp
;
5269 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5273 const unsigned char * dp
;
5274 const unsigned char * head
;
5275 const char * procname
;
5277 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5278 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5280 fputs ("\n<", stdout
);
5284 fputs (procname
, stdout
);
5287 printf ("+%lx", (unsigned long) offset
);
5290 fputs (">: [", stdout
);
5291 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5292 fputc ('-', stdout
);
5293 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5294 printf ("], info at +0x%lx\n",
5295 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5297 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5298 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5300 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5301 (unsigned) UNW_VER (stamp
),
5302 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5303 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5304 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5305 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5307 if (UNW_VER (stamp
) != 1)
5309 printf (_("\tUnknown version.\n"));
5314 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5315 dp
= unw_decode (dp
, in_body
, & in_body
);
5320 slurp_ia64_unwind_table (FILE * file
,
5321 struct ia64_unw_aux_info
* aux
,
5322 Elf_Internal_Shdr
* sec
)
5324 unsigned long size
, nrelas
, i
;
5325 Elf_Internal_Phdr
* seg
;
5326 struct ia64_unw_table_entry
* tep
;
5327 Elf_Internal_Shdr
* relsec
;
5328 Elf_Internal_Rela
* rela
;
5329 Elf_Internal_Rela
* rp
;
5330 unsigned char * table
;
5332 Elf_Internal_Sym
* sym
;
5333 const char * relname
;
5335 /* First, find the starting address of the segment that includes
5338 if (elf_header
.e_phnum
)
5340 if (! get_program_headers (file
))
5343 for (seg
= program_headers
;
5344 seg
< program_headers
+ elf_header
.e_phnum
;
5347 if (seg
->p_type
!= PT_LOAD
)
5350 if (sec
->sh_addr
>= seg
->p_vaddr
5351 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5353 aux
->seg_base
= seg
->p_vaddr
;
5359 /* Second, build the unwind table from the contents of the unwind section: */
5360 size
= sec
->sh_size
;
5361 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5366 aux
->table
= (struct ia64_unw_table_entry
*)
5367 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5369 for (tp
= table
; tp
< table
+ size
; ++tep
)
5371 tep
->start
.section
= SHN_UNDEF
;
5372 tep
->end
.section
= SHN_UNDEF
;
5373 tep
->info
.section
= SHN_UNDEF
;
5374 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5375 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5376 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5377 tep
->start
.offset
+= aux
->seg_base
;
5378 tep
->end
.offset
+= aux
->seg_base
;
5379 tep
->info
.offset
+= aux
->seg_base
;
5383 /* Third, apply any relocations to the unwind table: */
5384 for (relsec
= section_headers
;
5385 relsec
< section_headers
+ elf_header
.e_shnum
;
5388 if (relsec
->sh_type
!= SHT_RELA
5389 || relsec
->sh_info
>= elf_header
.e_shnum
5390 || section_headers
+ relsec
->sh_info
!= sec
)
5393 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5397 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5399 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5400 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5402 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5404 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5408 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5410 switch (rp
->r_offset
/eh_addr_size
% 3)
5413 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5414 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5417 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5418 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5421 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5422 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5432 aux
->table_len
= size
/ (3 * eh_addr_size
);
5437 ia64_process_unwind (FILE * file
)
5439 Elf_Internal_Shdr
* sec
;
5440 Elf_Internal_Shdr
* unwsec
= NULL
;
5441 Elf_Internal_Shdr
* strsec
;
5442 unsigned long i
, unwcount
= 0, unwstart
= 0;
5443 struct ia64_unw_aux_info aux
;
5445 memset (& aux
, 0, sizeof (aux
));
5447 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5449 if (sec
->sh_type
== SHT_SYMTAB
5450 && sec
->sh_link
< elf_header
.e_shnum
)
5452 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5453 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5455 strsec
= section_headers
+ sec
->sh_link
;
5456 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5459 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5461 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5466 printf (_("\nThere are no unwind sections in this file.\n"));
5468 while (unwcount
-- > 0)
5473 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5474 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5475 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5482 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5484 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5486 /* We need to find which section group it is in. */
5487 struct group_list
* g
= section_headers_groups
[i
]->root
;
5489 for (; g
!= NULL
; g
= g
->next
)
5491 sec
= section_headers
+ g
->section_index
;
5493 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5498 i
= elf_header
.e_shnum
;
5500 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5502 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5503 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5504 suffix
= SECTION_NAME (unwsec
) + len
;
5505 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5507 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5508 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5513 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5514 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5515 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5516 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5518 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5519 suffix
= SECTION_NAME (unwsec
) + len
;
5520 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5522 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5523 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5527 if (i
== elf_header
.e_shnum
)
5529 printf (_("\nCould not find unwind info section for "));
5531 if (string_table
== NULL
)
5532 printf ("%d", unwsec
->sh_name
);
5534 printf (_("'%s'"), SECTION_NAME (unwsec
));
5538 aux
.info_size
= sec
->sh_size
;
5539 aux
.info_addr
= sec
->sh_addr
;
5540 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5544 printf (_("\nUnwind section "));
5546 if (string_table
== NULL
)
5547 printf ("%d", unwsec
->sh_name
);
5549 printf (_("'%s'"), SECTION_NAME (unwsec
));
5551 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5552 (unsigned long) unwsec
->sh_offset
,
5553 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5555 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5557 if (aux
.table_len
> 0)
5558 dump_ia64_unwind (& aux
);
5561 free ((char *) aux
.table
);
5563 free ((char *) aux
.info
);
5572 free ((char *) aux
.strtab
);
5577 struct hppa_unw_table_entry
5579 struct absaddr start
;
5581 unsigned int Cannot_unwind
:1; /* 0 */
5582 unsigned int Millicode
:1; /* 1 */
5583 unsigned int Millicode_save_sr0
:1; /* 2 */
5584 unsigned int Region_description
:2; /* 3..4 */
5585 unsigned int reserved1
:1; /* 5 */
5586 unsigned int Entry_SR
:1; /* 6 */
5587 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5588 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5589 unsigned int Args_stored
:1; /* 16 */
5590 unsigned int Variable_Frame
:1; /* 17 */
5591 unsigned int Separate_Package_Body
:1; /* 18 */
5592 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5593 unsigned int Stack_Overflow_Check
:1; /* 20 */
5594 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5595 unsigned int Ada_Region
:1; /* 22 */
5596 unsigned int cxx_info
:1; /* 23 */
5597 unsigned int cxx_try_catch
:1; /* 24 */
5598 unsigned int sched_entry_seq
:1; /* 25 */
5599 unsigned int reserved2
:1; /* 26 */
5600 unsigned int Save_SP
:1; /* 27 */
5601 unsigned int Save_RP
:1; /* 28 */
5602 unsigned int Save_MRP_in_frame
:1; /* 29 */
5603 unsigned int extn_ptr_defined
:1; /* 30 */
5604 unsigned int Cleanup_defined
:1; /* 31 */
5606 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5607 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5608 unsigned int Large_frame
:1; /* 2 */
5609 unsigned int Pseudo_SP_Set
:1; /* 3 */
5610 unsigned int reserved4
:1; /* 4 */
5611 unsigned int Total_frame_size
:27; /* 5..31 */
5614 struct hppa_unw_aux_info
5616 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5617 unsigned long table_len
; /* Length of unwind table. */
5618 bfd_vma seg_base
; /* Starting address of segment. */
5619 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5620 unsigned long nsyms
; /* Number of symbols. */
5621 char * strtab
; /* The string table. */
5622 unsigned long strtab_size
; /* Size of string table. */
5626 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5628 struct hppa_unw_table_entry
* tp
;
5630 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5633 const char * procname
;
5635 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5636 aux
->strtab_size
, tp
->start
, &procname
,
5639 fputs ("\n<", stdout
);
5643 fputs (procname
, stdout
);
5646 printf ("+%lx", (unsigned long) offset
);
5649 fputs (">: [", stdout
);
5650 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5651 fputc ('-', stdout
);
5652 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5655 #define PF(_m) if (tp->_m) printf (#_m " ");
5656 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5659 PF(Millicode_save_sr0
);
5660 /* PV(Region_description); */
5666 PF(Separate_Package_Body
);
5667 PF(Frame_Extension_Millicode
);
5668 PF(Stack_Overflow_Check
);
5669 PF(Two_Instruction_SP_Increment
);
5673 PF(sched_entry_seq
);
5676 PF(Save_MRP_in_frame
);
5677 PF(extn_ptr_defined
);
5678 PF(Cleanup_defined
);
5679 PF(MPE_XL_interrupt_marker
);
5680 PF(HP_UX_interrupt_marker
);
5683 PV(Total_frame_size
);
5692 slurp_hppa_unwind_table (FILE * file
,
5693 struct hppa_unw_aux_info
* aux
,
5694 Elf_Internal_Shdr
* sec
)
5696 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5697 Elf_Internal_Phdr
* seg
;
5698 struct hppa_unw_table_entry
* tep
;
5699 Elf_Internal_Shdr
* relsec
;
5700 Elf_Internal_Rela
* rela
;
5701 Elf_Internal_Rela
* rp
;
5702 unsigned char * table
;
5704 Elf_Internal_Sym
* sym
;
5705 const char * relname
;
5707 /* First, find the starting address of the segment that includes
5710 if (elf_header
.e_phnum
)
5712 if (! get_program_headers (file
))
5715 for (seg
= program_headers
;
5716 seg
< program_headers
+ elf_header
.e_phnum
;
5719 if (seg
->p_type
!= PT_LOAD
)
5722 if (sec
->sh_addr
>= seg
->p_vaddr
5723 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5725 aux
->seg_base
= seg
->p_vaddr
;
5731 /* Second, build the unwind table from the contents of the unwind
5733 size
= sec
->sh_size
;
5734 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5740 nentries
= size
/ unw_ent_size
;
5741 size
= unw_ent_size
* nentries
;
5743 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5744 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5746 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5748 unsigned int tmp1
, tmp2
;
5750 tep
->start
.section
= SHN_UNDEF
;
5751 tep
->end
.section
= SHN_UNDEF
;
5753 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5754 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5755 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5756 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5758 tep
->start
.offset
+= aux
->seg_base
;
5759 tep
->end
.offset
+= aux
->seg_base
;
5761 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5762 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5763 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5764 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5765 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5766 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5767 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5768 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5769 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5770 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5771 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5772 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5773 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5774 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5775 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5776 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5777 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5778 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5779 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5780 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5781 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5782 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5783 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5784 tep
->Cleanup_defined
= tmp1
& 0x1;
5786 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5787 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5788 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5789 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5790 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5791 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5795 /* Third, apply any relocations to the unwind table. */
5796 for (relsec
= section_headers
;
5797 relsec
< section_headers
+ elf_header
.e_shnum
;
5800 if (relsec
->sh_type
!= SHT_RELA
5801 || relsec
->sh_info
>= elf_header
.e_shnum
5802 || section_headers
+ relsec
->sh_info
!= sec
)
5805 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5809 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5811 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5812 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5814 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5815 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5817 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5821 i
= rp
->r_offset
/ unw_ent_size
;
5823 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5826 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5827 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5830 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5831 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5841 aux
->table_len
= nentries
;
5847 hppa_process_unwind (FILE * file
)
5849 struct hppa_unw_aux_info aux
;
5850 Elf_Internal_Shdr
* unwsec
= NULL
;
5851 Elf_Internal_Shdr
* strsec
;
5852 Elf_Internal_Shdr
* sec
;
5855 memset (& aux
, 0, sizeof (aux
));
5857 if (string_table
== NULL
)
5860 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5862 if (sec
->sh_type
== SHT_SYMTAB
5863 && sec
->sh_link
< elf_header
.e_shnum
)
5865 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5866 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5868 strsec
= section_headers
+ sec
->sh_link
;
5869 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5872 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5874 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5879 printf (_("\nThere are no unwind sections in this file.\n"));
5881 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5883 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5885 printf (_("\nUnwind section "));
5886 printf (_("'%s'"), SECTION_NAME (sec
));
5888 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5889 (unsigned long) sec
->sh_offset
,
5890 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5892 slurp_hppa_unwind_table (file
, &aux
, sec
);
5893 if (aux
.table_len
> 0)
5894 dump_hppa_unwind (&aux
);
5897 free ((char *) aux
.table
);
5905 free ((char *) aux
.strtab
);
5912 unsigned char *data
;
5914 Elf_Internal_Shdr
*sec
;
5915 Elf_Internal_Rela
*rela
;
5916 unsigned long nrelas
;
5917 unsigned int rel_type
;
5919 Elf_Internal_Rela
*next_rela
;
5922 struct arm_unw_aux_info
5926 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5927 unsigned long nsyms
; /* Number of symbols. */
5928 char *strtab
; /* The string table. */
5929 unsigned long strtab_size
; /* Size of string table. */
5933 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
5934 bfd_vma fn
, struct absaddr addr
)
5936 const char *procname
;
5939 if (addr
.section
== SHN_UNDEF
)
5942 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5943 aux
->strtab_size
, addr
, &procname
,
5946 print_vma (fn
, PREFIX_HEX
);
5950 fputs (" <", stdout
);
5951 fputs (procname
, stdout
);
5954 printf ("+0x%lx", (unsigned long) sym_offset
);
5955 fputc ('>', stdout
);
5962 arm_free_section (struct arm_section
*arm_sec
)
5964 if (arm_sec
->data
!= NULL
)
5965 free (arm_sec
->data
);
5967 if (arm_sec
->rela
!= NULL
)
5968 free (arm_sec
->rela
);
5972 arm_section_get_word (struct arm_unw_aux_info
*aux
,
5973 struct arm_section
*arm_sec
,
5974 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
5975 unsigned int *wordp
, struct absaddr
*addr
)
5977 Elf_Internal_Rela
*rp
;
5978 Elf_Internal_Sym
*sym
;
5979 const char * relname
;
5981 bfd_boolean wrapped
;
5983 addr
->section
= SHN_UNDEF
;
5986 if (sec
!= arm_sec
->sec
)
5988 Elf_Internal_Shdr
*relsec
;
5990 arm_free_section (arm_sec
);
5993 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
5994 sec
->sh_size
, _("unwind data"));
5996 arm_sec
->rela
= NULL
;
5997 arm_sec
->nrelas
= 0;
5999 for (relsec
= section_headers
;
6000 relsec
< section_headers
+ elf_header
.e_shnum
;
6003 if (relsec
->sh_info
>= elf_header
.e_shnum
6004 || section_headers
+ relsec
->sh_info
!= sec
)
6007 if (relsec
->sh_type
== SHT_REL
)
6009 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6011 & arm_sec
->rela
, & arm_sec
->nrelas
))
6015 else if (relsec
->sh_type
== SHT_RELA
)
6017 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6019 & arm_sec
->rela
, & arm_sec
->nrelas
))
6025 arm_sec
->next_rela
= arm_sec
->rela
;
6028 if (arm_sec
->data
== NULL
)
6031 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6034 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6036 bfd_vma prelval
, offset
;
6038 if (rp
->r_offset
> word_offset
&& !wrapped
)
6043 if (rp
->r_offset
> word_offset
)
6046 if (rp
->r_offset
& 3)
6048 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6049 (unsigned long) rp
->r_offset
);
6053 if (rp
->r_offset
< word_offset
)
6056 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6058 if (streq (relname
, "R_ARM_NONE"))
6061 if (! streq (relname
, "R_ARM_PREL31"))
6063 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6067 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6069 if (arm_sec
->rel_type
== SHT_REL
)
6071 offset
= word
& 0x7fffffff;
6072 if (offset
& 0x40000000)
6073 offset
|= ~ (bfd_vma
) 0x7fffffff;
6076 offset
= rp
->r_addend
;
6078 offset
+= sym
->st_value
;
6079 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6081 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6082 addr
->section
= sym
->st_shndx
;
6083 addr
->offset
= offset
;
6088 arm_sec
->next_rela
= rp
;
6094 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6095 unsigned int word
, unsigned int remaining
,
6096 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6097 struct arm_section
*data_arm_sec
)
6100 unsigned int more_words
;
6101 struct absaddr addr
;
6104 if (remaining == 0 && more_words) \
6107 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6108 data_offset, &word, &addr)) \
6114 #define GET_OP(OP) \
6119 (OP) = word >> 24; \
6124 printf (_("[Truncated opcode]\n")); \
6127 printf (_("0x%02x "), OP)
6131 /* Fetch the first word. */
6132 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6138 if ((word
& 0x80000000) == 0)
6140 /* Expand prel31 for personality routine. */
6142 const char *procname
;
6145 if (fn
& 0x40000000)
6146 fn
|= ~ (bfd_vma
) 0x7fffffff;
6147 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6149 printf (_(" Personality routine: "));
6150 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6151 fputc ('\n', stdout
);
6153 /* The GCC personality routines use the standard compact
6154 encoding, starting with one byte giving the number of
6156 if (procname
!= NULL
6157 && (const_strneq (procname
, "__gcc_personality_v0")
6158 || const_strneq (procname
, "__gxx_personality_v0")
6159 || const_strneq (procname
, "__gcj_personality_v0")
6160 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6167 printf (_(" [Truncated data]\n"));
6170 more_words
= word
>> 24;
6180 per_index
= (word
>> 24) & 0x7f;
6181 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6183 printf (_(" [reserved compact index %d]\n"), per_index
);
6187 printf (_(" Compact model %d\n"), per_index
);
6196 more_words
= (word
>> 16) & 0xff;
6202 /* Decode the unwinding instructions. */
6205 unsigned int op
, op2
;
6214 printf (_(" 0x%02x "), op
);
6216 if ((op
& 0xc0) == 0x00)
6218 int offset
= ((op
& 0x3f) << 2) + 4;
6219 printf (_(" vsp = vsp + %d"), offset
);
6221 else if ((op
& 0xc0) == 0x40)
6223 int offset
= ((op
& 0x3f) << 2) + 4;
6224 printf (_(" vsp = vsp - %d"), offset
);
6226 else if ((op
& 0xf0) == 0x80)
6229 if (op
== 0x80 && op2
== 0)
6230 printf (_("Refuse to unwind"));
6233 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6238 for (i
= 0; i
< 12; i
++)
6239 if (mask
& (1 << i
))
6245 printf ("r%d", 4 + i
);
6250 else if ((op
& 0xf0) == 0x90)
6252 if (op
== 0x9d || op
== 0x9f)
6253 printf (_(" [Reserved]"));
6255 printf (_(" vsp = r%d"), op
& 0x0f);
6257 else if ((op
& 0xf0) == 0xa0)
6259 int end
= 4 + (op
& 0x07);
6263 for (i
= 4; i
<= end
; i
++)
6279 else if (op
== 0xb0)
6280 printf (_(" finish"));
6281 else if (op
== 0xb1)
6284 if (op2
== 0 || (op2
& 0xf0) != 0)
6285 printf (_("[Spare]"));
6288 unsigned int mask
= op2
& 0x0f;
6292 for (i
= 0; i
< 12; i
++)
6293 if (mask
& (1 << i
))
6304 else if (op
== 0xb2)
6306 unsigned char buf
[9];
6307 unsigned int i
, len
;
6308 unsigned long offset
;
6309 for (i
= 0; i
< sizeof (buf
); i
++)
6312 if ((buf
[i
] & 0x80) == 0)
6315 assert (i
< sizeof (buf
));
6316 offset
= read_uleb128 (buf
, &len
);
6317 assert (len
== i
+ 1);
6318 offset
= offset
* 4 + 0x204;
6319 printf (_("vsp = vsp + %ld"), offset
);
6323 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6326 printf (_("[unsupported two-byte opcode]"));
6330 printf (_(" [unsupported opcode]"));
6336 /* Decode the descriptors. Not implemented. */
6340 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6342 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6343 unsigned int i
, exidx_len
;
6345 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6346 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6347 exidx_len
= exidx_sec
->sh_size
/ 8;
6349 for (i
= 0; i
< exidx_len
; i
++)
6351 unsigned int exidx_fn
, exidx_entry
;
6352 struct absaddr fn_addr
, entry_addr
;
6355 fputc ('\n', stdout
);
6357 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6358 8 * i
, &exidx_fn
, &fn_addr
)
6359 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6360 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6362 arm_free_section (&exidx_arm_sec
);
6363 arm_free_section (&extab_arm_sec
);
6367 fn
= exidx_fn
& 0x7fffffff;
6368 if (fn
& 0x40000000)
6369 fn
|= ~ (bfd_vma
) 0x7fffffff;
6370 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6372 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6373 fputs (": ", stdout
);
6375 if (exidx_entry
== 1)
6377 print_vma (exidx_entry
, PREFIX_HEX
);
6378 fputs (" [cantunwind]\n", stdout
);
6380 else if (exidx_entry
& 0x80000000)
6382 print_vma (exidx_entry
, PREFIX_HEX
);
6383 fputc ('\n', stdout
);
6384 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6388 bfd_vma table
, table_offset
= 0;
6389 Elf_Internal_Shdr
*table_sec
;
6391 fputs ("@", stdout
);
6392 table
= exidx_entry
;
6393 if (table
& 0x40000000)
6394 table
|= ~ (bfd_vma
) 0x7fffffff;
6395 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6396 print_vma (table
, PREFIX_HEX
);
6399 /* Locate the matching .ARM.extab. */
6400 if (entry_addr
.section
!= SHN_UNDEF
6401 && entry_addr
.section
< elf_header
.e_shnum
)
6403 table_sec
= section_headers
+ entry_addr
.section
;
6404 table_offset
= entry_addr
.offset
;
6408 table_sec
= find_section_by_address (table
);
6409 if (table_sec
!= NULL
)
6410 table_offset
= table
- table_sec
->sh_addr
;
6412 if (table_sec
== NULL
)
6414 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6415 (unsigned long) table
);
6418 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6425 arm_free_section (&exidx_arm_sec
);
6426 arm_free_section (&extab_arm_sec
);
6430 arm_process_unwind (FILE *file
)
6432 struct arm_unw_aux_info aux
;
6433 Elf_Internal_Shdr
*unwsec
= NULL
;
6434 Elf_Internal_Shdr
*strsec
;
6435 Elf_Internal_Shdr
*sec
;
6438 memset (& aux
, 0, sizeof (aux
));
6441 if (string_table
== NULL
)
6444 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6446 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6448 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6449 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6451 strsec
= section_headers
+ sec
->sh_link
;
6452 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6453 1, strsec
->sh_size
, _("string table"));
6454 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6456 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6461 printf (_("\nThere are no unwind sections in this file.\n"));
6463 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6465 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6467 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6469 (unsigned long) sec
->sh_offset
,
6470 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6472 dump_arm_unwind (&aux
, sec
);
6479 free ((char *) aux
.strtab
);
6485 process_unwind (FILE * file
)
6487 struct unwind_handler
6490 int (* handler
)(FILE *);
6493 { EM_ARM
, arm_process_unwind
},
6494 { EM_IA_64
, ia64_process_unwind
},
6495 { EM_PARISC
, hppa_process_unwind
},
6503 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6504 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6505 return handlers
[i
].handler (file
);
6507 printf (_("\nThere are no unwind sections in this file.\n"));
6512 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6514 switch (entry
->d_tag
)
6517 if (entry
->d_un
.d_val
== 0)
6518 printf (_("NONE\n"));
6521 static const char * opts
[] =
6523 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6524 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6525 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6526 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6532 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6533 if (entry
->d_un
.d_val
& (1 << cnt
))
6535 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6542 case DT_MIPS_IVERSION
:
6543 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6544 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6546 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6549 case DT_MIPS_TIME_STAMP
:
6554 time_t atime
= entry
->d_un
.d_val
;
6555 tmp
= gmtime (&atime
);
6556 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6557 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6558 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6559 printf (_("Time Stamp: %s\n"), timebuf
);
6563 case DT_MIPS_RLD_VERSION
:
6564 case DT_MIPS_LOCAL_GOTNO
:
6565 case DT_MIPS_CONFLICTNO
:
6566 case DT_MIPS_LIBLISTNO
:
6567 case DT_MIPS_SYMTABNO
:
6568 case DT_MIPS_UNREFEXTNO
:
6569 case DT_MIPS_HIPAGENO
:
6570 case DT_MIPS_DELTA_CLASS_NO
:
6571 case DT_MIPS_DELTA_INSTANCE_NO
:
6572 case DT_MIPS_DELTA_RELOC_NO
:
6573 case DT_MIPS_DELTA_SYM_NO
:
6574 case DT_MIPS_DELTA_CLASSSYM_NO
:
6575 case DT_MIPS_COMPACT_SIZE
:
6576 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6580 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6585 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6587 switch (entry
->d_tag
)
6589 case DT_HP_DLD_FLAGS
:
6598 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6599 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6600 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6601 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6602 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6603 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6604 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6605 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6606 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6607 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6608 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6609 { DT_HP_GST
, "HP_GST" },
6610 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6611 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6612 { DT_HP_NODELETE
, "HP_NODELETE" },
6613 { DT_HP_GROUP
, "HP_GROUP" },
6614 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6618 bfd_vma val
= entry
->d_un
.d_val
;
6620 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6621 if (val
& flags
[cnt
].bit
)
6625 fputs (flags
[cnt
].str
, stdout
);
6627 val
^= flags
[cnt
].bit
;
6630 if (val
!= 0 || first
)
6634 print_vma (val
, HEX
);
6640 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6647 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6649 switch (entry
->d_tag
)
6651 case DT_IA_64_PLT_RESERVE
:
6652 /* First 3 slots reserved. */
6653 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6655 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6659 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6666 get_32bit_dynamic_section (FILE * file
)
6668 Elf32_External_Dyn
* edyn
;
6669 Elf32_External_Dyn
* ext
;
6670 Elf_Internal_Dyn
* entry
;
6672 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6673 dynamic_size
, _("dynamic section"));
6677 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6678 might not have the luxury of section headers. Look for the DT_NULL
6679 terminator to determine the number of entries. */
6680 for (ext
= edyn
, dynamic_nent
= 0;
6681 (char *) ext
< (char *) edyn
+ dynamic_size
;
6685 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6689 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6691 if (dynamic_section
== NULL
)
6693 error (_("Out of memory\n"));
6698 for (ext
= edyn
, entry
= dynamic_section
;
6699 entry
< dynamic_section
+ dynamic_nent
;
6702 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6703 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6712 get_64bit_dynamic_section (FILE * file
)
6714 Elf64_External_Dyn
* edyn
;
6715 Elf64_External_Dyn
* ext
;
6716 Elf_Internal_Dyn
* entry
;
6718 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6719 dynamic_size
, _("dynamic section"));
6723 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6724 might not have the luxury of section headers. Look for the DT_NULL
6725 terminator to determine the number of entries. */
6726 for (ext
= edyn
, dynamic_nent
= 0;
6727 (char *) ext
< (char *) edyn
+ dynamic_size
;
6731 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6735 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6737 if (dynamic_section
== NULL
)
6739 error (_("Out of memory\n"));
6744 for (ext
= edyn
, entry
= dynamic_section
;
6745 entry
< dynamic_section
+ dynamic_nent
;
6748 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6749 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6758 print_dynamic_flags (bfd_vma flags
)
6766 flag
= flags
& - flags
;
6776 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6777 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6778 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6779 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6780 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6781 default: fputs (_("unknown"), stdout
); break;
6787 /* Parse and display the contents of the dynamic section. */
6790 process_dynamic_section (FILE * file
)
6792 Elf_Internal_Dyn
* entry
;
6794 if (dynamic_size
== 0)
6797 printf (_("\nThere is no dynamic section in this file.\n"));
6804 if (! get_32bit_dynamic_section (file
))
6807 else if (! get_64bit_dynamic_section (file
))
6810 /* Find the appropriate symbol table. */
6811 if (dynamic_symbols
== NULL
)
6813 for (entry
= dynamic_section
;
6814 entry
< dynamic_section
+ dynamic_nent
;
6817 Elf_Internal_Shdr section
;
6819 if (entry
->d_tag
!= DT_SYMTAB
)
6822 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6824 /* Since we do not know how big the symbol table is,
6825 we default to reading in the entire file (!) and
6826 processing that. This is overkill, I know, but it
6828 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6830 if (archive_file_offset
!= 0)
6831 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6834 if (fseek (file
, 0, SEEK_END
))
6835 error (_("Unable to seek to end of file!\n"));
6837 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6841 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6843 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6845 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6846 if (num_dynamic_syms
< 1)
6848 error (_("Unable to determine the number of symbols to load\n"));
6852 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6856 /* Similarly find a string table. */
6857 if (dynamic_strings
== NULL
)
6859 for (entry
= dynamic_section
;
6860 entry
< dynamic_section
+ dynamic_nent
;
6863 unsigned long offset
;
6866 if (entry
->d_tag
!= DT_STRTAB
)
6869 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6871 /* Since we do not know how big the string table is,
6872 we default to reading in the entire file (!) and
6873 processing that. This is overkill, I know, but it
6876 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6878 if (archive_file_offset
!= 0)
6879 str_tab_len
= archive_file_size
- offset
;
6882 if (fseek (file
, 0, SEEK_END
))
6883 error (_("Unable to seek to end of file\n"));
6884 str_tab_len
= ftell (file
) - offset
;
6887 if (str_tab_len
< 1)
6890 (_("Unable to determine the length of the dynamic string table\n"));
6894 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6896 _("dynamic string table"));
6897 dynamic_strings_length
= str_tab_len
;
6902 /* And find the syminfo section if available. */
6903 if (dynamic_syminfo
== NULL
)
6905 unsigned long syminsz
= 0;
6907 for (entry
= dynamic_section
;
6908 entry
< dynamic_section
+ dynamic_nent
;
6911 if (entry
->d_tag
== DT_SYMINENT
)
6913 /* Note: these braces are necessary to avoid a syntax
6914 error from the SunOS4 C compiler. */
6915 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6917 else if (entry
->d_tag
== DT_SYMINSZ
)
6918 syminsz
= entry
->d_un
.d_val
;
6919 else if (entry
->d_tag
== DT_SYMINFO
)
6920 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6924 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6926 Elf_External_Syminfo
* extsyminfo
;
6927 Elf_External_Syminfo
* extsym
;
6928 Elf_Internal_Syminfo
* syminfo
;
6930 /* There is a syminfo section. Read the data. */
6931 extsyminfo
= (Elf_External_Syminfo
*)
6932 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6933 _("symbol information"));
6937 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6938 if (dynamic_syminfo
== NULL
)
6940 error (_("Out of memory\n"));
6944 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6945 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6946 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6947 ++syminfo
, ++extsym
)
6949 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6950 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6957 if (do_dynamic
&& dynamic_addr
)
6958 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6959 dynamic_addr
, dynamic_nent
);
6961 printf (_(" Tag Type Name/Value\n"));
6963 for (entry
= dynamic_section
;
6964 entry
< dynamic_section
+ dynamic_nent
;
6972 print_vma (entry
->d_tag
, FULL_HEX
);
6973 dtype
= get_dynamic_type (entry
->d_tag
);
6974 printf (" (%s)%*s", dtype
,
6975 ((is_32bit_elf
? 27 : 19)
6976 - (int) strlen (dtype
)),
6980 switch (entry
->d_tag
)
6984 print_dynamic_flags (entry
->d_un
.d_val
);
6994 switch (entry
->d_tag
)
6997 printf (_("Auxiliary library"));
7001 printf (_("Filter library"));
7005 printf (_("Configuration file"));
7009 printf (_("Dependency audit library"));
7013 printf (_("Audit library"));
7017 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7018 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7022 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7031 printf (_("Flags:"));
7033 if (entry
->d_un
.d_val
== 0)
7034 printf (_(" None\n"));
7037 unsigned long int val
= entry
->d_un
.d_val
;
7039 if (val
& DTF_1_PARINIT
)
7041 printf (" PARINIT");
7042 val
^= DTF_1_PARINIT
;
7044 if (val
& DTF_1_CONFEXP
)
7046 printf (" CONFEXP");
7047 val
^= DTF_1_CONFEXP
;
7050 printf (" %lx", val
);
7059 printf (_("Flags:"));
7061 if (entry
->d_un
.d_val
== 0)
7062 printf (_(" None\n"));
7065 unsigned long int val
= entry
->d_un
.d_val
;
7067 if (val
& DF_P1_LAZYLOAD
)
7069 printf (" LAZYLOAD");
7070 val
^= DF_P1_LAZYLOAD
;
7072 if (val
& DF_P1_GROUPPERM
)
7074 printf (" GROUPPERM");
7075 val
^= DF_P1_GROUPPERM
;
7078 printf (" %lx", val
);
7087 printf (_("Flags:"));
7088 if (entry
->d_un
.d_val
== 0)
7089 printf (_(" None\n"));
7092 unsigned long int val
= entry
->d_un
.d_val
;
7099 if (val
& DF_1_GLOBAL
)
7104 if (val
& DF_1_GROUP
)
7109 if (val
& DF_1_NODELETE
)
7111 printf (" NODELETE");
7112 val
^= DF_1_NODELETE
;
7114 if (val
& DF_1_LOADFLTR
)
7116 printf (" LOADFLTR");
7117 val
^= DF_1_LOADFLTR
;
7119 if (val
& DF_1_INITFIRST
)
7121 printf (" INITFIRST");
7122 val
^= DF_1_INITFIRST
;
7124 if (val
& DF_1_NOOPEN
)
7129 if (val
& DF_1_ORIGIN
)
7134 if (val
& DF_1_DIRECT
)
7139 if (val
& DF_1_TRANS
)
7144 if (val
& DF_1_INTERPOSE
)
7146 printf (" INTERPOSE");
7147 val
^= DF_1_INTERPOSE
;
7149 if (val
& DF_1_NODEFLIB
)
7151 printf (" NODEFLIB");
7152 val
^= DF_1_NODEFLIB
;
7154 if (val
& DF_1_NODUMP
)
7159 if (val
& DF_1_CONLFAT
)
7161 printf (" CONLFAT");
7162 val
^= DF_1_CONLFAT
;
7165 printf (" %lx", val
);
7172 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7174 puts (get_dynamic_type (entry
->d_un
.d_val
));
7194 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7200 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7201 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7207 switch (entry
->d_tag
)
7210 printf (_("Shared library: [%s]"), name
);
7212 if (streq (name
, program_interpreter
))
7213 printf (_(" program interpreter"));
7217 printf (_("Library soname: [%s]"), name
);
7221 printf (_("Library rpath: [%s]"), name
);
7225 printf (_("Library runpath: [%s]"), name
);
7229 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7234 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7247 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7251 case DT_INIT_ARRAYSZ
:
7252 case DT_FINI_ARRAYSZ
:
7253 case DT_GNU_CONFLICTSZ
:
7254 case DT_GNU_LIBLISTSZ
:
7257 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7258 printf (_(" (bytes)\n"));
7268 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7281 if (entry
->d_tag
== DT_USED
7282 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7284 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7288 printf (_("Not needed object: [%s]\n"), name
);
7293 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7299 /* The value of this entry is ignored. */
7304 case DT_GNU_PRELINKED
:
7308 time_t atime
= entry
->d_un
.d_val
;
7310 tmp
= gmtime (&atime
);
7311 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7312 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7313 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7319 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7322 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7328 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7329 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7334 switch (elf_header
.e_machine
)
7337 case EM_MIPS_RS3_LE
:
7338 dynamic_section_mips_val (entry
);
7341 dynamic_section_parisc_val (entry
);
7344 dynamic_section_ia64_val (entry
);
7347 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7359 get_ver_flags (unsigned int flags
)
7361 static char buff
[32];
7368 if (flags
& VER_FLG_BASE
)
7369 strcat (buff
, "BASE ");
7371 if (flags
& VER_FLG_WEAK
)
7373 if (flags
& VER_FLG_BASE
)
7374 strcat (buff
, "| ");
7376 strcat (buff
, "WEAK ");
7379 if (flags
& VER_FLG_INFO
)
7381 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7382 strcat (buff
, "| ");
7384 strcat (buff
, "INFO ");
7387 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7388 strcat (buff
, _("| <unknown>"));
7393 /* Display the contents of the version sections. */
7396 process_version_sections (FILE * file
)
7398 Elf_Internal_Shdr
* section
;
7405 for (i
= 0, section
= section_headers
;
7406 i
< elf_header
.e_shnum
;
7409 switch (section
->sh_type
)
7411 case SHT_GNU_verdef
:
7413 Elf_External_Verdef
* edefs
;
7421 (_("\nVersion definition section '%s' contains %u entries:\n"),
7422 SECTION_NAME (section
), section
->sh_info
);
7424 printf (_(" Addr: 0x"));
7425 printf_vma (section
->sh_addr
);
7426 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7427 (unsigned long) section
->sh_offset
, section
->sh_link
,
7428 section
->sh_link
< elf_header
.e_shnum
7429 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7432 edefs
= (Elf_External_Verdef
*)
7433 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7434 _("version definition section"));
7435 endbuf
= (char *) edefs
+ section
->sh_size
;
7439 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7442 Elf_External_Verdef
* edef
;
7443 Elf_Internal_Verdef ent
;
7444 Elf_External_Verdaux
* eaux
;
7445 Elf_Internal_Verdaux aux
;
7449 vstart
= ((char *) edefs
) + idx
;
7450 if (vstart
+ sizeof (*edef
) > endbuf
)
7453 edef
= (Elf_External_Verdef
*) vstart
;
7455 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7456 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7457 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7458 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7459 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7460 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7461 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7463 printf (_(" %#06x: Rev: %d Flags: %s"),
7464 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7466 printf (_(" Index: %d Cnt: %d "),
7467 ent
.vd_ndx
, ent
.vd_cnt
);
7469 vstart
+= ent
.vd_aux
;
7471 eaux
= (Elf_External_Verdaux
*) vstart
;
7473 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7474 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7476 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7477 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7479 printf (_("Name index: %ld\n"), aux
.vda_name
);
7481 isum
= idx
+ ent
.vd_aux
;
7483 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7485 isum
+= aux
.vda_next
;
7486 vstart
+= aux
.vda_next
;
7488 eaux
= (Elf_External_Verdaux
*) vstart
;
7489 if (vstart
+ sizeof (*eaux
) > endbuf
)
7492 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7493 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7495 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7496 printf (_(" %#06x: Parent %d: %s\n"),
7497 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7499 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7500 isum
, j
, aux
.vda_name
);
7503 printf (_(" Version def aux past end of section\n"));
7507 if (cnt
< section
->sh_info
)
7508 printf (_(" Version definition past end of section\n"));
7514 case SHT_GNU_verneed
:
7516 Elf_External_Verneed
* eneed
;
7523 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7524 SECTION_NAME (section
), section
->sh_info
);
7526 printf (_(" Addr: 0x"));
7527 printf_vma (section
->sh_addr
);
7528 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7529 (unsigned long) section
->sh_offset
, section
->sh_link
,
7530 section
->sh_link
< elf_header
.e_shnum
7531 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7534 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7535 section
->sh_offset
, 1,
7537 _("version need section"));
7538 endbuf
= (char *) eneed
+ section
->sh_size
;
7542 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7544 Elf_External_Verneed
* entry
;
7545 Elf_Internal_Verneed ent
;
7550 vstart
= ((char *) eneed
) + idx
;
7551 if (vstart
+ sizeof (*entry
) > endbuf
)
7554 entry
= (Elf_External_Verneed
*) vstart
;
7556 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7557 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7558 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7559 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7560 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7562 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7564 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7565 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7567 printf (_(" File: %lx"), ent
.vn_file
);
7569 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7571 vstart
+= ent
.vn_aux
;
7573 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7575 Elf_External_Vernaux
* eaux
;
7576 Elf_Internal_Vernaux aux
;
7578 if (vstart
+ sizeof (*eaux
) > endbuf
)
7580 eaux
= (Elf_External_Vernaux
*) vstart
;
7582 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7583 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7584 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7585 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7586 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7588 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7589 printf (_(" %#06x: Name: %s"),
7590 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7592 printf (_(" %#06x: Name index: %lx"),
7593 isum
, aux
.vna_name
);
7595 printf (_(" Flags: %s Version: %d\n"),
7596 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7598 isum
+= aux
.vna_next
;
7599 vstart
+= aux
.vna_next
;
7602 printf (_(" Version need aux past end of section\n"));
7606 if (cnt
< section
->sh_info
)
7607 printf (_(" Version need past end of section\n"));
7613 case SHT_GNU_versym
:
7615 Elf_Internal_Shdr
* link_section
;
7618 unsigned char * edata
;
7619 unsigned short * data
;
7621 Elf_Internal_Sym
* symbols
;
7622 Elf_Internal_Shdr
* string_sec
;
7625 if (section
->sh_link
>= elf_header
.e_shnum
)
7628 link_section
= section_headers
+ section
->sh_link
;
7629 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7631 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7636 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7638 string_sec
= section_headers
+ link_section
->sh_link
;
7640 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7641 string_sec
->sh_size
,
7642 _("version string table"));
7646 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7647 SECTION_NAME (section
), total
);
7649 printf (_(" Addr: "));
7650 printf_vma (section
->sh_addr
);
7651 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7652 (unsigned long) section
->sh_offset
, section
->sh_link
,
7653 SECTION_NAME (link_section
));
7655 off
= offset_from_vma (file
,
7656 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7657 total
* sizeof (short));
7658 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
7660 _("version symbol data"));
7667 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
7669 for (cnt
= total
; cnt
--;)
7670 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
7675 for (cnt
= 0; cnt
< total
; cnt
+= 4)
7678 int check_def
, check_need
;
7681 printf (" %03x:", cnt
);
7683 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
7684 switch (data
[cnt
+ j
])
7687 fputs (_(" 0 (*local*) "), stdout
);
7691 fputs (_(" 1 (*global*) "), stdout
);
7695 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
7696 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
7700 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
7701 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
7704 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
7711 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
7713 Elf_Internal_Verneed ivn
;
7714 unsigned long offset
;
7716 offset
= offset_from_vma
7717 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7718 sizeof (Elf_External_Verneed
));
7722 Elf_Internal_Vernaux ivna
;
7723 Elf_External_Verneed evn
;
7724 Elf_External_Vernaux evna
;
7725 unsigned long a_off
;
7727 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7730 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7731 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7733 a_off
= offset
+ ivn
.vn_aux
;
7737 get_data (&evna
, file
, a_off
, sizeof (evna
),
7738 1, _("version need aux (2)"));
7740 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7741 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7743 a_off
+= ivna
.vna_next
;
7745 while (ivna
.vna_other
!= data
[cnt
+ j
]
7746 && ivna
.vna_next
!= 0);
7748 if (ivna
.vna_other
== data
[cnt
+ j
])
7750 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7752 if (ivna
.vna_name
>= string_sec
->sh_size
)
7753 name
= _("*invalid*");
7755 name
= strtab
+ ivna
.vna_name
;
7756 nn
+= printf ("(%s%-*s",
7758 12 - (int) strlen (name
),
7764 offset
+= ivn
.vn_next
;
7766 while (ivn
.vn_next
);
7769 if (check_def
&& data
[cnt
+ j
] != 0x8001
7770 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7772 Elf_Internal_Verdef ivd
;
7773 Elf_External_Verdef evd
;
7774 unsigned long offset
;
7776 offset
= offset_from_vma
7777 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7782 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7785 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7786 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7788 offset
+= ivd
.vd_next
;
7790 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7791 && ivd
.vd_next
!= 0);
7793 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7795 Elf_External_Verdaux evda
;
7796 Elf_Internal_Verdaux ivda
;
7798 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7800 get_data (&evda
, file
,
7801 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7803 _("version def aux"));
7805 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7807 if (ivda
.vda_name
>= string_sec
->sh_size
)
7808 name
= _("*invalid*");
7810 name
= strtab
+ ivda
.vda_name
;
7811 nn
+= printf ("(%s%-*s",
7813 12 - (int) strlen (name
),
7819 printf ("%*c", 18 - nn
, ' ');
7837 printf (_("\nNo version information found in this file.\n"));
7843 get_symbol_binding (unsigned int binding
)
7845 static char buff
[32];
7849 case STB_LOCAL
: return "LOCAL";
7850 case STB_GLOBAL
: return "GLOBAL";
7851 case STB_WEAK
: return "WEAK";
7853 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7854 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7856 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7858 if (binding
== STB_GNU_UNIQUE
7859 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7860 /* GNU/Linux is still using the default value 0. */
7861 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7863 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7866 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7872 get_symbol_type (unsigned int type
)
7874 static char buff
[32];
7878 case STT_NOTYPE
: return "NOTYPE";
7879 case STT_OBJECT
: return "OBJECT";
7880 case STT_FUNC
: return "FUNC";
7881 case STT_SECTION
: return "SECTION";
7882 case STT_FILE
: return "FILE";
7883 case STT_COMMON
: return "COMMON";
7884 case STT_TLS
: return "TLS";
7885 case STT_RELC
: return "RELC";
7886 case STT_SRELC
: return "SRELC";
7888 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7890 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7891 return "THUMB_FUNC";
7893 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7896 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7897 return "PARISC_MILLI";
7899 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7901 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7903 if (elf_header
.e_machine
== EM_PARISC
)
7905 if (type
== STT_HP_OPAQUE
)
7907 if (type
== STT_HP_STUB
)
7911 if (type
== STT_GNU_IFUNC
7912 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7913 /* GNU/Linux is still using the default value 0. */
7914 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7917 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7920 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7926 get_symbol_visibility (unsigned int visibility
)
7930 case STV_DEFAULT
: return "DEFAULT";
7931 case STV_INTERNAL
: return "INTERNAL";
7932 case STV_HIDDEN
: return "HIDDEN";
7933 case STV_PROTECTED
: return "PROTECTED";
7939 get_mips_symbol_other (unsigned int other
)
7943 case STO_OPTIONAL
: return "OPTIONAL";
7944 case STO_MIPS16
: return "MIPS16";
7945 case STO_MIPS_PLT
: return "MIPS PLT";
7946 case STO_MIPS_PIC
: return "MIPS PIC";
7947 default: return NULL
;
7952 get_symbol_other (unsigned int other
)
7954 const char * result
= NULL
;
7955 static char buff
[32];
7960 switch (elf_header
.e_machine
)
7963 result
= get_mips_symbol_other (other
);
7971 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7976 get_symbol_index_type (unsigned int type
)
7978 static char buff
[32];
7982 case SHN_UNDEF
: return "UND";
7983 case SHN_ABS
: return "ABS";
7984 case SHN_COMMON
: return "COM";
7986 if (type
== SHN_IA_64_ANSI_COMMON
7987 && elf_header
.e_machine
== EM_IA_64
7988 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7990 else if ((elf_header
.e_machine
== EM_X86_64
7991 || elf_header
.e_machine
== EM_L1OM
)
7992 && type
== SHN_X86_64_LCOMMON
)
7994 else if (type
== SHN_MIPS_SCOMMON
7995 && elf_header
.e_machine
== EM_MIPS
)
7997 else if (type
== SHN_MIPS_SUNDEFINED
7998 && elf_header
.e_machine
== EM_MIPS
)
8000 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8001 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8002 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8003 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8004 else if (type
>= SHN_LORESERVE
)
8005 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8007 sprintf (buff
, "%3d", type
);
8015 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8017 unsigned char * e_data
;
8020 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8024 error (_("Out of memory\n"));
8028 if (fread (e_data
, ent_size
, number
, file
) != number
)
8030 error (_("Unable to read in dynamic data\n"));
8034 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8038 error (_("Out of memory\n"));
8044 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8052 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8054 Elf_Internal_Sym
* psym
;
8057 psym
= dynamic_symbols
+ si
;
8059 n
= print_vma (si
, DEC_5
);
8061 fputs (" " + n
, stdout
);
8062 printf (" %3lu: ", hn
);
8063 print_vma (psym
->st_value
, LONG_HEX
);
8065 print_vma (psym
->st_size
, DEC_5
);
8067 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8068 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8069 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8070 /* Check to see if any other bits in the st_other field are set.
8071 Note - displaying this information disrupts the layout of the
8072 table being generated, but for the moment this case is very
8074 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8075 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8076 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8077 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8078 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8080 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8084 /* Dump the symbol table. */
8086 process_symbol_table (FILE * file
)
8088 Elf_Internal_Shdr
* section
;
8089 bfd_vma nbuckets
= 0;
8090 bfd_vma nchains
= 0;
8091 bfd_vma
* buckets
= NULL
;
8092 bfd_vma
* chains
= NULL
;
8093 bfd_vma ngnubuckets
= 0;
8094 bfd_vma
* gnubuckets
= NULL
;
8095 bfd_vma
* gnuchains
= NULL
;
8096 bfd_vma gnusymidx
= 0;
8098 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8101 if (dynamic_info
[DT_HASH
]
8103 || (do_using_dynamic
8105 && dynamic_strings
!= NULL
)))
8107 unsigned char nb
[8];
8108 unsigned char nc
[8];
8109 int hash_ent_size
= 4;
8111 if ((elf_header
.e_machine
== EM_ALPHA
8112 || elf_header
.e_machine
== EM_S390
8113 || elf_header
.e_machine
== EM_S390_OLD
)
8114 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8118 (archive_file_offset
8119 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8120 sizeof nb
+ sizeof nc
)),
8123 error (_("Unable to seek to start of dynamic information\n"));
8127 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8129 error (_("Failed to read in number of buckets\n"));
8133 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8135 error (_("Failed to read in number of chains\n"));
8139 nbuckets
= byte_get (nb
, hash_ent_size
);
8140 nchains
= byte_get (nc
, hash_ent_size
);
8142 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8143 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8146 if (buckets
== NULL
|| chains
== NULL
)
8148 if (do_using_dynamic
)
8159 if (dynamic_info_DT_GNU_HASH
8161 || (do_using_dynamic
8163 && dynamic_strings
!= NULL
)))
8165 unsigned char nb
[16];
8166 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8167 bfd_vma buckets_vma
;
8170 (archive_file_offset
8171 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8175 error (_("Unable to seek to start of dynamic information\n"));
8179 if (fread (nb
, 16, 1, file
) != 1)
8181 error (_("Failed to read in number of buckets\n"));
8185 ngnubuckets
= byte_get (nb
, 4);
8186 gnusymidx
= byte_get (nb
+ 4, 4);
8187 bitmaskwords
= byte_get (nb
+ 8, 4);
8188 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8190 buckets_vma
+= bitmaskwords
* 4;
8192 buckets_vma
+= bitmaskwords
* 8;
8195 (archive_file_offset
8196 + offset_from_vma (file
, buckets_vma
, 4)),
8199 error (_("Unable to seek to start of dynamic information\n"));
8203 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8205 if (gnubuckets
== NULL
)
8208 for (i
= 0; i
< ngnubuckets
; i
++)
8209 if (gnubuckets
[i
] != 0)
8211 if (gnubuckets
[i
] < gnusymidx
)
8214 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8215 maxchain
= gnubuckets
[i
];
8218 if (maxchain
== 0xffffffff)
8221 maxchain
-= gnusymidx
;
8224 (archive_file_offset
8225 + offset_from_vma (file
, buckets_vma
8226 + 4 * (ngnubuckets
+ maxchain
), 4)),
8229 error (_("Unable to seek to start of dynamic information\n"));
8235 if (fread (nb
, 4, 1, file
) != 1)
8237 error (_("Failed to determine last chain length\n"));
8241 if (maxchain
+ 1 == 0)
8246 while ((byte_get (nb
, 4) & 1) == 0);
8249 (archive_file_offset
8250 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8253 error (_("Unable to seek to start of dynamic information\n"));
8257 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8260 if (gnuchains
== NULL
)
8265 if (do_using_dynamic
)
8270 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8273 && dynamic_strings
!= NULL
)
8277 if (dynamic_info
[DT_HASH
])
8281 printf (_("\nSymbol table for image:\n"));
8283 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8285 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8287 for (hn
= 0; hn
< nbuckets
; hn
++)
8292 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8293 print_dynamic_symbol (si
, hn
);
8297 if (dynamic_info_DT_GNU_HASH
)
8299 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8301 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8303 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8305 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8306 if (gnubuckets
[hn
] != 0)
8308 bfd_vma si
= gnubuckets
[hn
];
8309 bfd_vma off
= si
- gnusymidx
;
8313 print_dynamic_symbol (si
, hn
);
8316 while ((gnuchains
[off
++] & 1) == 0);
8320 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8324 for (i
= 0, section
= section_headers
;
8325 i
< elf_header
.e_shnum
;
8329 char * strtab
= NULL
;
8330 unsigned long int strtab_size
= 0;
8331 Elf_Internal_Sym
* symtab
;
8332 Elf_Internal_Sym
* psym
;
8334 if ((section
->sh_type
!= SHT_SYMTAB
8335 && section
->sh_type
!= SHT_DYNSYM
)
8337 && section
->sh_type
== SHT_SYMTAB
))
8340 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8341 SECTION_NAME (section
),
8342 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8344 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8346 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8348 symtab
= GET_ELF_SYMBOLS (file
, section
);
8352 if (section
->sh_link
== elf_header
.e_shstrndx
)
8354 strtab
= string_table
;
8355 strtab_size
= string_table_length
;
8357 else if (section
->sh_link
< elf_header
.e_shnum
)
8359 Elf_Internal_Shdr
* string_sec
;
8361 string_sec
= section_headers
+ section
->sh_link
;
8363 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8364 1, string_sec
->sh_size
,
8366 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8369 for (si
= 0, psym
= symtab
;
8370 si
< section
->sh_size
/ section
->sh_entsize
;
8373 printf ("%6d: ", si
);
8374 print_vma (psym
->st_value
, LONG_HEX
);
8376 print_vma (psym
->st_size
, DEC_5
);
8377 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8378 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8379 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8380 /* Check to see if any other bits in the st_other field are set.
8381 Note - displaying this information disrupts the layout of the
8382 table being generated, but for the moment this case is very rare. */
8383 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8384 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8385 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8386 print_symbol (25, psym
->st_name
< strtab_size
8387 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8389 if (section
->sh_type
== SHT_DYNSYM
&&
8390 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8392 unsigned char data
[2];
8393 unsigned short vers_data
;
8394 unsigned long offset
;
8398 offset
= offset_from_vma
8399 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8400 sizeof data
+ si
* sizeof (vers_data
));
8402 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8403 sizeof (data
), 1, _("version data"));
8405 vers_data
= byte_get (data
, 2);
8407 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8408 && section_headers
[psym
->st_shndx
].sh_type
8411 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8413 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8415 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8416 && (is_nobits
|| ! check_def
))
8418 Elf_External_Verneed evn
;
8419 Elf_Internal_Verneed ivn
;
8420 Elf_Internal_Vernaux ivna
;
8422 /* We must test both. */
8423 offset
= offset_from_vma
8424 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8429 unsigned long vna_off
;
8431 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8434 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8435 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8437 vna_off
= offset
+ ivn
.vn_aux
;
8441 Elf_External_Vernaux evna
;
8443 get_data (&evna
, file
, vna_off
,
8445 _("version need aux (3)"));
8447 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8448 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8449 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8451 vna_off
+= ivna
.vna_next
;
8453 while (ivna
.vna_other
!= vers_data
8454 && ivna
.vna_next
!= 0);
8456 if (ivna
.vna_other
== vers_data
)
8459 offset
+= ivn
.vn_next
;
8461 while (ivn
.vn_next
!= 0);
8463 if (ivna
.vna_other
== vers_data
)
8466 ivna
.vna_name
< strtab_size
8467 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8471 else if (! is_nobits
)
8472 error (_("bad dynamic symbol\n"));
8479 if (vers_data
!= 0x8001
8480 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8482 Elf_Internal_Verdef ivd
;
8483 Elf_Internal_Verdaux ivda
;
8484 Elf_External_Verdaux evda
;
8487 off
= offset_from_vma
8489 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8490 sizeof (Elf_External_Verdef
));
8494 Elf_External_Verdef evd
;
8496 get_data (&evd
, file
, off
, sizeof (evd
),
8497 1, _("version def"));
8499 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8500 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8501 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8505 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8506 && ivd
.vd_next
!= 0);
8511 get_data (&evda
, file
, off
, sizeof (evda
),
8512 1, _("version def aux"));
8514 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8516 if (psym
->st_name
!= ivda
.vda_name
)
8517 printf ((vers_data
& VERSYM_HIDDEN
)
8519 ivda
.vda_name
< strtab_size
8520 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8530 if (strtab
!= string_table
)
8536 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8538 if (do_histogram
&& buckets
!= NULL
)
8540 unsigned long * lengths
;
8541 unsigned long * counts
;
8544 unsigned long maxlength
= 0;
8545 unsigned long nzero_counts
= 0;
8546 unsigned long nsyms
= 0;
8548 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8549 (unsigned long) nbuckets
);
8550 printf (_(" Length Number %% of total Coverage\n"));
8552 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8553 if (lengths
== NULL
)
8555 error (_("Out of memory\n"));
8558 for (hn
= 0; hn
< nbuckets
; ++hn
)
8560 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8563 if (maxlength
< ++lengths
[hn
])
8568 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8571 error (_("Out of memory\n"));
8575 for (hn
= 0; hn
< nbuckets
; ++hn
)
8576 ++counts
[lengths
[hn
]];
8581 printf (" 0 %-10lu (%5.1f%%)\n",
8582 counts
[0], (counts
[0] * 100.0) / nbuckets
);
8583 for (i
= 1; i
<= maxlength
; ++i
)
8585 nzero_counts
+= counts
[i
] * i
;
8586 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8587 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
8588 (nzero_counts
* 100.0) / nsyms
);
8596 if (buckets
!= NULL
)
8602 if (do_histogram
&& gnubuckets
!= NULL
)
8604 unsigned long * lengths
;
8605 unsigned long * counts
;
8607 unsigned long maxlength
= 0;
8608 unsigned long nzero_counts
= 0;
8609 unsigned long nsyms
= 0;
8611 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
8612 if (lengths
== NULL
)
8614 error (_("Out of memory\n"));
8618 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8619 (unsigned long) ngnubuckets
);
8620 printf (_(" Length Number %% of total Coverage\n"));
8622 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8623 if (gnubuckets
[hn
] != 0)
8625 bfd_vma off
, length
= 1;
8627 for (off
= gnubuckets
[hn
] - gnusymidx
;
8628 (gnuchains
[off
] & 1) == 0; ++off
)
8630 lengths
[hn
] = length
;
8631 if (length
> maxlength
)
8636 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8639 error (_("Out of memory\n"));
8643 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8644 ++counts
[lengths
[hn
]];
8646 if (ngnubuckets
> 0)
8649 printf (" 0 %-10lu (%5.1f%%)\n",
8650 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
8651 for (j
= 1; j
<= maxlength
; ++j
)
8653 nzero_counts
+= counts
[j
] * j
;
8654 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8655 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
8656 (nzero_counts
* 100.0) / nsyms
);
8670 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
8674 if (dynamic_syminfo
== NULL
8676 /* No syminfo, this is ok. */
8679 /* There better should be a dynamic symbol section. */
8680 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
8684 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
8685 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
8687 printf (_(" Num: Name BoundTo Flags\n"));
8688 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
8690 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
8692 printf ("%4d: ", i
);
8693 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
8694 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
8696 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
8699 switch (dynamic_syminfo
[i
].si_boundto
)
8701 case SYMINFO_BT_SELF
:
8702 fputs ("SELF ", stdout
);
8704 case SYMINFO_BT_PARENT
:
8705 fputs ("PARENT ", stdout
);
8708 if (dynamic_syminfo
[i
].si_boundto
> 0
8709 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
8710 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
8712 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
8716 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
8720 if (flags
& SYMINFO_FLG_DIRECT
)
8722 if (flags
& SYMINFO_FLG_PASSTHRU
)
8723 printf (" PASSTHRU");
8724 if (flags
& SYMINFO_FLG_COPY
)
8726 if (flags
& SYMINFO_FLG_LAZYLOAD
)
8727 printf (" LAZYLOAD");
8735 /* Check to see if the given reloc needs to be handled in a target specific
8736 manner. If so then process the reloc and return TRUE otherwise return
8740 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
8741 unsigned char * start
,
8742 Elf_Internal_Sym
* symtab
)
8744 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8746 switch (elf_header
.e_machine
)
8749 case EM_CYGNUS_MN10300
:
8751 static Elf_Internal_Sym
* saved_sym
= NULL
;
8755 case 34: /* R_MN10300_ALIGN */
8757 case 33: /* R_MN10300_SYM_DIFF */
8758 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8760 case 1: /* R_MN10300_32 */
8761 case 2: /* R_MN10300_16 */
8762 if (saved_sym
!= NULL
)
8766 value
= reloc
->r_addend
8767 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8768 - saved_sym
->st_value
);
8770 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8777 if (saved_sym
!= NULL
)
8778 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8788 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8789 DWARF debug sections. This is a target specific test. Note - we do not
8790 go through the whole including-target-headers-multiple-times route, (as
8791 we have already done with <elf/h8.h>) because this would become very
8792 messy and even then this function would have to contain target specific
8793 information (the names of the relocs instead of their numeric values).
8794 FIXME: This is not the correct way to solve this problem. The proper way
8795 is to have target specific reloc sizing and typing functions created by
8796 the reloc-macros.h header, in the same way that it already creates the
8797 reloc naming functions. */
8800 is_32bit_abs_reloc (unsigned int reloc_type
)
8802 switch (elf_header
.e_machine
)
8806 return reloc_type
== 1; /* R_386_32. */
8808 return reloc_type
== 1; /* R_68K_32. */
8810 return reloc_type
== 1; /* R_860_32. */
8812 return reloc_type
== 1; /* XXX Is this right ? */
8814 return reloc_type
== 1; /* R_ARC_32. */
8816 return reloc_type
== 2; /* R_ARM_ABS32 */
8819 return reloc_type
== 1;
8821 return reloc_type
== 0x12; /* R_byte4_data. */
8823 return reloc_type
== 3; /* R_CRIS_32. */
8826 return reloc_type
== 3; /* R_CR16_NUM32. */
8828 return reloc_type
== 15; /* R_CRX_NUM32. */
8830 return reloc_type
== 1;
8831 case EM_CYGNUS_D10V
:
8833 return reloc_type
== 6; /* R_D10V_32. */
8834 case EM_CYGNUS_D30V
:
8836 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8838 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8839 case EM_CYGNUS_FR30
:
8841 return reloc_type
== 3; /* R_FR30_32. */
8845 return reloc_type
== 1; /* R_H8_DIR32. */
8847 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8850 return reloc_type
== 2; /* R_IP2K_32. */
8852 return reloc_type
== 2; /* R_IQ2000_32. */
8853 case EM_LATTICEMICO32
:
8854 return reloc_type
== 3; /* R_LM32_32. */
8857 return reloc_type
== 3; /* R_M32C_32. */
8859 return reloc_type
== 34; /* R_M32R_32_RELA. */
8861 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8863 return reloc_type
== 4; /* R_MEP_32. */
8865 return reloc_type
== 2; /* R_MIPS_32. */
8867 return reloc_type
== 4; /* R_MMIX_32. */
8868 case EM_CYGNUS_MN10200
:
8870 return reloc_type
== 1; /* R_MN10200_32. */
8871 case EM_CYGNUS_MN10300
:
8873 return reloc_type
== 1; /* R_MN10300_32. */
8876 return reloc_type
== 1; /* R_MSP43_32. */
8878 return reloc_type
== 2; /* R_MT_32. */
8879 case EM_ALTERA_NIOS2
:
8881 return reloc_type
== 1; /* R_NIOS_32. */
8884 return reloc_type
== 1; /* R_OR32_32. */
8886 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8887 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8890 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8892 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8894 return reloc_type
== 1; /* R_PPC_ADDR32. */
8896 return reloc_type
== 1; /* R_RX_DIR32. */
8898 return reloc_type
== 1; /* R_I370_ADDR31. */
8901 return reloc_type
== 4; /* R_S390_32. */
8903 return reloc_type
== 8; /* R_SCORE_ABS32. */
8905 return reloc_type
== 1; /* R_SH_DIR32. */
8906 case EM_SPARC32PLUS
:
8909 return reloc_type
== 3 /* R_SPARC_32. */
8910 || reloc_type
== 23; /* R_SPARC_UA32. */
8912 return reloc_type
== 6; /* R_SPU_ADDR32 */
8914 return reloc_type
== 1; /* R_C6000_ABS32. */
8915 case EM_CYGNUS_V850
:
8917 return reloc_type
== 6; /* R_V850_ABS32. */
8919 return reloc_type
== 1; /* R_VAX_32. */
8922 return reloc_type
== 10; /* R_X86_64_32. */
8925 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8927 return reloc_type
== 1; /* R_XSTROMY16_32. */
8930 return reloc_type
== 1; /* R_XTENSA_32. */
8932 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8933 elf_header
.e_machine
);
8938 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8939 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8942 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8944 switch (elf_header
.e_machine
)
8948 return reloc_type
== 2; /* R_386_PC32. */
8950 return reloc_type
== 4; /* R_68K_PC32. */
8952 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8954 return reloc_type
== 3; /* R_ARM_REL32 */
8956 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8958 return reloc_type
== 26; /* R_PPC_REL32. */
8960 return reloc_type
== 26; /* R_PPC64_REL32. */
8963 return reloc_type
== 5; /* R_390_PC32. */
8965 return reloc_type
== 2; /* R_SH_REL32. */
8966 case EM_SPARC32PLUS
:
8969 return reloc_type
== 6; /* R_SPARC_DISP32. */
8971 return reloc_type
== 13; /* R_SPU_REL32. */
8974 return reloc_type
== 2; /* R_X86_64_PC32. */
8977 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8979 /* Do not abort or issue an error message here. Not all targets use
8980 pc-relative 32-bit relocs in their DWARF debug information and we
8981 have already tested for target coverage in is_32bit_abs_reloc. A
8982 more helpful warning message will be generated by apply_relocations
8983 anyway, so just return. */
8988 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8989 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8992 is_64bit_abs_reloc (unsigned int reloc_type
)
8994 switch (elf_header
.e_machine
)
8997 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8999 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9001 return reloc_type
== 80; /* R_PARISC_DIR64. */
9003 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9004 case EM_SPARC32PLUS
:
9007 return reloc_type
== 54; /* R_SPARC_UA64. */
9010 return reloc_type
== 1; /* R_X86_64_64. */
9013 return reloc_type
== 22; /* R_S390_64 */
9015 return reloc_type
== 18; /* R_MIPS_64 */
9021 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9022 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9025 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9027 switch (elf_header
.e_machine
)
9030 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9032 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9034 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9036 return reloc_type
== 44; /* R_PPC64_REL64 */
9037 case EM_SPARC32PLUS
:
9040 return reloc_type
== 46; /* R_SPARC_DISP64 */
9043 return reloc_type
== 24; /* R_X86_64_PC64 */
9046 return reloc_type
== 23; /* R_S390_PC64 */
9052 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9053 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9056 is_24bit_abs_reloc (unsigned int reloc_type
)
9058 switch (elf_header
.e_machine
)
9060 case EM_CYGNUS_MN10200
:
9062 return reloc_type
== 4; /* R_MN10200_24. */
9068 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9069 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9072 is_16bit_abs_reloc (unsigned int reloc_type
)
9074 switch (elf_header
.e_machine
)
9078 return reloc_type
== 4; /* R_AVR_16. */
9079 case EM_CYGNUS_D10V
:
9081 return reloc_type
== 3; /* R_D10V_16. */
9085 return reloc_type
== R_H8_DIR16
;
9088 return reloc_type
== 1; /* R_IP2K_16. */
9091 return reloc_type
== 1; /* R_M32C_16 */
9094 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9095 case EM_ALTERA_NIOS2
:
9097 return reloc_type
== 9; /* R_NIOS_16. */
9099 return reloc_type
== 2; /* R_C6000_ABS16. */
9102 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9108 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9109 relocation entries (possibly formerly used for SHT_GROUP sections). */
9112 is_none_reloc (unsigned int reloc_type
)
9114 switch (elf_header
.e_machine
)
9116 case EM_68K
: /* R_68K_NONE. */
9117 case EM_386
: /* R_386_NONE. */
9118 case EM_SPARC32PLUS
:
9120 case EM_SPARC
: /* R_SPARC_NONE. */
9121 case EM_MIPS
: /* R_MIPS_NONE. */
9122 case EM_PARISC
: /* R_PARISC_NONE. */
9123 case EM_ALPHA
: /* R_ALPHA_NONE. */
9124 case EM_PPC
: /* R_PPC_NONE. */
9125 case EM_PPC64
: /* R_PPC64_NONE. */
9126 case EM_ARM
: /* R_ARM_NONE. */
9127 case EM_IA_64
: /* R_IA64_NONE. */
9128 case EM_SH
: /* R_SH_NONE. */
9130 case EM_S390
: /* R_390_NONE. */
9131 case EM_CRIS
: /* R_CRIS_NONE. */
9132 case EM_X86_64
: /* R_X86_64_NONE. */
9133 case EM_L1OM
: /* R_X86_64_NONE. */
9134 case EM_MN10300
: /* R_MN10300_NONE. */
9135 case EM_M32R
: /* R_M32R_NONE. */
9136 case EM_TI_C6000
:/* R_C6000_NONE. */
9138 case EM_C166
: /* R_XC16X_NONE. */
9139 return reloc_type
== 0;
9142 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9143 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9144 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9145 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9150 /* Apply relocations to a section.
9151 Note: So far support has been added only for those relocations
9152 which can be found in debug sections.
9153 FIXME: Add support for more relocations ? */
9156 apply_relocations (void * file
,
9157 Elf_Internal_Shdr
* section
,
9158 unsigned char * start
)
9160 Elf_Internal_Shdr
* relsec
;
9161 unsigned char * end
= start
+ section
->sh_size
;
9163 if (elf_header
.e_type
!= ET_REL
)
9166 /* Find the reloc section associated with the section. */
9167 for (relsec
= section_headers
;
9168 relsec
< section_headers
+ elf_header
.e_shnum
;
9171 bfd_boolean is_rela
;
9172 unsigned long num_relocs
;
9173 Elf_Internal_Rela
* relocs
;
9174 Elf_Internal_Rela
* rp
;
9175 Elf_Internal_Shdr
* symsec
;
9176 Elf_Internal_Sym
* symtab
;
9177 Elf_Internal_Sym
* sym
;
9179 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9180 || relsec
->sh_info
>= elf_header
.e_shnum
9181 || section_headers
+ relsec
->sh_info
!= section
9182 || relsec
->sh_size
== 0
9183 || relsec
->sh_link
>= elf_header
.e_shnum
)
9186 is_rela
= relsec
->sh_type
== SHT_RELA
;
9190 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9191 relsec
->sh_size
, & relocs
, & num_relocs
))
9196 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9197 relsec
->sh_size
, & relocs
, & num_relocs
))
9201 /* SH uses RELA but uses in place value instead of the addend field. */
9202 if (elf_header
.e_machine
== EM_SH
)
9205 symsec
= section_headers
+ relsec
->sh_link
;
9206 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9208 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9211 unsigned int reloc_type
;
9212 unsigned int reloc_size
;
9213 unsigned char * rloc
;
9215 reloc_type
= get_reloc_type (rp
->r_info
);
9217 if (target_specific_reloc_handling (rp
, start
, symtab
))
9219 else if (is_none_reloc (reloc_type
))
9221 else if (is_32bit_abs_reloc (reloc_type
)
9222 || is_32bit_pcrel_reloc (reloc_type
))
9224 else if (is_64bit_abs_reloc (reloc_type
)
9225 || is_64bit_pcrel_reloc (reloc_type
))
9227 else if (is_24bit_abs_reloc (reloc_type
))
9229 else if (is_16bit_abs_reloc (reloc_type
))
9233 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9234 reloc_type
, SECTION_NAME (section
));
9238 rloc
= start
+ rp
->r_offset
;
9239 if ((rloc
+ reloc_size
) > end
)
9241 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9242 (unsigned long) rp
->r_offset
,
9243 SECTION_NAME (section
));
9247 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9249 /* If the reloc has a symbol associated with it,
9250 make sure that it is of an appropriate type.
9252 Relocations against symbols without type can happen.
9253 Gcc -feliminate-dwarf2-dups may generate symbols
9254 without type for debug info.
9256 Icc generates relocations against function symbols
9257 instead of local labels.
9259 Relocations against object symbols can happen, eg when
9260 referencing a global array. For an example of this see
9261 the _clz.o binary in libgcc.a. */
9263 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9265 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9266 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9267 (long int)(rp
- relocs
),
9268 SECTION_NAME (relsec
));
9274 addend
+= rp
->r_addend
;
9275 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9277 || (elf_header
.e_machine
== EM_XTENSA
9279 || ((elf_header
.e_machine
== EM_PJ
9280 || elf_header
.e_machine
== EM_PJ_OLD
)
9281 && reloc_type
== 1))
9282 addend
+= byte_get (rloc
, reloc_size
);
9284 if (is_32bit_pcrel_reloc (reloc_type
)
9285 || is_64bit_pcrel_reloc (reloc_type
))
9287 /* On HPPA, all pc-relative relocations are biased by 8. */
9288 if (elf_header
.e_machine
== EM_PARISC
)
9290 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9294 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9303 #ifdef SUPPORT_DISASSEMBLY
9305 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9307 printf (_("\nAssembly dump of section %s\n"),
9308 SECTION_NAME (section
));
9310 /* XXX -- to be done --- XXX */
9316 /* Reads in the contents of SECTION from FILE, returning a pointer
9317 to a malloc'ed buffer or NULL if something went wrong. */
9320 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9322 bfd_size_type num_bytes
;
9324 num_bytes
= section
->sh_size
;
9326 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9328 printf (_("\nSection '%s' has no data to dump.\n"),
9329 SECTION_NAME (section
));
9333 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9334 _("section contents"));
9339 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9341 Elf_Internal_Shdr
* relsec
;
9342 bfd_size_type num_bytes
;
9346 char * name
= SECTION_NAME (section
);
9347 bfd_boolean some_strings_shown
;
9349 start
= get_section_contents (section
, file
);
9353 printf (_("\nString dump of section '%s':\n"), name
);
9355 /* If the section being dumped has relocations against it the user might
9356 be expecting these relocations to have been applied. Check for this
9357 case and issue a warning message in order to avoid confusion.
9358 FIXME: Maybe we ought to have an option that dumps a section with
9360 for (relsec
= section_headers
;
9361 relsec
< section_headers
+ elf_header
.e_shnum
;
9364 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9365 || relsec
->sh_info
>= elf_header
.e_shnum
9366 || section_headers
+ relsec
->sh_info
!= section
9367 || relsec
->sh_size
== 0
9368 || relsec
->sh_link
>= elf_header
.e_shnum
)
9371 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9375 num_bytes
= section
->sh_size
;
9377 end
= start
+ num_bytes
;
9378 some_strings_shown
= FALSE
;
9382 while (!ISPRINT (* data
))
9389 /* PR 11128: Use two separate invocations in order to work
9390 around bugs in the Solaris 8 implementation of printf. */
9391 printf (" [%6tx] ", data
- start
);
9392 printf ("%s\n", data
);
9394 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9396 data
+= strlen (data
);
9397 some_strings_shown
= TRUE
;
9401 if (! some_strings_shown
)
9402 printf (_(" No strings found in this section."));
9410 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9412 bfd_boolean relocate
)
9414 Elf_Internal_Shdr
* relsec
;
9415 bfd_size_type bytes
;
9417 unsigned char * data
;
9418 unsigned char * start
;
9420 start
= (unsigned char *) get_section_contents (section
, file
);
9424 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9428 apply_relocations (file
, section
, start
);
9432 /* If the section being dumped has relocations against it the user might
9433 be expecting these relocations to have been applied. Check for this
9434 case and issue a warning message in order to avoid confusion.
9435 FIXME: Maybe we ought to have an option that dumps a section with
9437 for (relsec
= section_headers
;
9438 relsec
< section_headers
+ elf_header
.e_shnum
;
9441 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9442 || relsec
->sh_info
>= elf_header
.e_shnum
9443 || section_headers
+ relsec
->sh_info
!= section
9444 || relsec
->sh_size
== 0
9445 || relsec
->sh_link
>= elf_header
.e_shnum
)
9448 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9453 addr
= section
->sh_addr
;
9454 bytes
= section
->sh_size
;
9463 lbytes
= (bytes
> 16 ? 16 : bytes
);
9465 printf (" 0x%8.8lx ", (unsigned long) addr
);
9467 for (j
= 0; j
< 16; j
++)
9470 printf ("%2.2x", data
[j
]);
9478 for (j
= 0; j
< lbytes
; j
++)
9481 if (k
>= ' ' && k
< 0x7f)
9499 /* Uncompresses a section that was compressed using zlib, in place.
9500 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9503 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
9506 /* These are just to quiet gcc. */
9511 dwarf_size_type compressed_size
= *size
;
9512 unsigned char * compressed_buffer
= *buffer
;
9513 dwarf_size_type uncompressed_size
;
9514 unsigned char * uncompressed_buffer
;
9517 dwarf_size_type header_size
= 12;
9519 /* Read the zlib header. In this case, it should be "ZLIB" followed
9520 by the uncompressed section size, 8 bytes in big-endian order. */
9521 if (compressed_size
< header_size
9522 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9525 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9526 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9527 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9528 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9529 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9530 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9531 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9532 uncompressed_size
+= compressed_buffer
[11];
9534 /* It is possible the section consists of several compressed
9535 buffers concatenated together, so we uncompress in a loop. */
9539 strm
.avail_in
= compressed_size
- header_size
;
9540 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9541 strm
.avail_out
= uncompressed_size
;
9542 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9544 rc
= inflateInit (& strm
);
9545 while (strm
.avail_in
> 0)
9549 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9550 + (uncompressed_size
- strm
.avail_out
));
9551 rc
= inflate (&strm
, Z_FINISH
);
9552 if (rc
!= Z_STREAM_END
)
9554 rc
= inflateReset (& strm
);
9556 rc
= inflateEnd (& strm
);
9558 || strm
.avail_out
!= 0)
9561 free (compressed_buffer
);
9562 *buffer
= uncompressed_buffer
;
9563 *size
= uncompressed_size
;
9567 free (uncompressed_buffer
);
9569 #endif /* HAVE_ZLIB_H */
9573 load_specific_debug_section (enum dwarf_section_display_enum debug
,
9574 Elf_Internal_Shdr
* sec
, void * file
)
9576 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9578 int section_is_compressed
;
9580 /* If it is already loaded, do nothing. */
9581 if (section
->start
!= NULL
)
9584 section_is_compressed
= section
->name
== section
->compressed_name
;
9586 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
9587 section
->address
= sec
->sh_addr
;
9588 section
->size
= sec
->sh_size
;
9589 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
9592 if (section
->start
== NULL
)
9595 if (section_is_compressed
)
9596 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
9599 if (debug_displays
[debug
].relocate
)
9600 apply_relocations ((FILE *) file
, sec
, section
->start
);
9606 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
9608 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9609 Elf_Internal_Shdr
* sec
;
9611 /* Locate the debug section. */
9612 sec
= find_section (section
->uncompressed_name
);
9614 section
->name
= section
->uncompressed_name
;
9617 sec
= find_section (section
->compressed_name
);
9619 section
->name
= section
->compressed_name
;
9624 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
9628 free_debug_section (enum dwarf_section_display_enum debug
)
9630 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9632 if (section
->start
== NULL
)
9635 free ((char *) section
->start
);
9636 section
->start
= NULL
;
9637 section
->address
= 0;
9642 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
9644 char * name
= SECTION_NAME (section
);
9645 bfd_size_type length
;
9649 length
= section
->sh_size
;
9652 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9655 if (section
->sh_type
== SHT_NOBITS
)
9657 /* There is no point in dumping the contents of a debugging section
9658 which has the NOBITS type - the bits in the file will be random.
9659 This can happen when a file containing a .eh_frame section is
9660 stripped with the --only-keep-debug command line option. */
9661 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
9665 if (const_strneq (name
, ".gnu.linkonce.wi."))
9666 name
= ".debug_info";
9668 /* See if we know how to display the contents of this section. */
9669 for (i
= 0; i
< max
; i
++)
9670 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
9671 || streq (debug_displays
[i
].section
.compressed_name
, name
))
9673 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
9674 int secondary
= (section
!= find_section (name
));
9677 free_debug_section ((enum dwarf_section_display_enum
) i
);
9679 if (streq (sec
->uncompressed_name
, name
))
9680 sec
->name
= sec
->uncompressed_name
;
9682 sec
->name
= sec
->compressed_name
;
9683 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
9686 result
&= debug_displays
[i
].display (sec
, file
);
9688 if (secondary
|| (i
!= info
&& i
!= abbrev
))
9689 free_debug_section ((enum dwarf_section_display_enum
) i
);
9697 printf (_("Unrecognized debug section: %s\n"), name
);
9704 /* Set DUMP_SECTS for all sections where dumps were requested
9705 based on section name. */
9708 initialise_dumps_byname (void)
9710 struct dump_list_entry
* cur
;
9712 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
9717 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
9718 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
9720 request_dump_bynumber (i
, cur
->type
);
9725 warn (_("Section '%s' was not dumped because it does not exist!\n"),
9731 process_section_contents (FILE * file
)
9733 Elf_Internal_Shdr
* section
;
9739 initialise_dumps_byname ();
9741 for (i
= 0, section
= section_headers
;
9742 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9745 #ifdef SUPPORT_DISASSEMBLY
9746 if (dump_sects
[i
] & DISASS_DUMP
)
9747 disassemble_section (section
, file
);
9749 if (dump_sects
[i
] & HEX_DUMP
)
9750 dump_section_as_bytes (section
, file
, FALSE
);
9752 if (dump_sects
[i
] & RELOC_DUMP
)
9753 dump_section_as_bytes (section
, file
, TRUE
);
9755 if (dump_sects
[i
] & STRING_DUMP
)
9756 dump_section_as_strings (section
, file
);
9758 if (dump_sects
[i
] & DEBUG_DUMP
)
9759 display_debug_section (section
, file
);
9762 /* Check to see if the user requested a
9763 dump of a section that does not exist. */
9764 while (i
++ < num_dump_sects
)
9766 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9770 process_mips_fpe_exception (int mask
)
9775 if (mask
& OEX_FPU_INEX
)
9776 fputs ("INEX", stdout
), first
= 0;
9777 if (mask
& OEX_FPU_UFLO
)
9778 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9779 if (mask
& OEX_FPU_OFLO
)
9780 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9781 if (mask
& OEX_FPU_DIV0
)
9782 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9783 if (mask
& OEX_FPU_INVAL
)
9784 printf ("%sINVAL", first
? "" : "|");
9787 fputs ("0", stdout
);
9790 /* ARM EABI attributes section. */
9795 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9797 const char ** table
;
9798 } arm_attr_public_tag
;
9800 static const char * arm_attr_tag_CPU_arch
[] =
9801 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9802 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9803 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9804 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9805 {"No", "Thumb-1", "Thumb-2"};
9806 static const char * arm_attr_tag_FP_arch
[] =
9807 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9808 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9809 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
9810 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
9811 static const char * arm_attr_tag_PCS_config
[] =
9812 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9813 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9814 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9815 {"V6", "SB", "TLS", "Unused"};
9816 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9817 {"Absolute", "PC-relative", "SB-relative", "None"};
9818 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9819 {"Absolute", "PC-relative", "None"};
9820 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9821 {"None", "direct", "GOT-indirect"};
9822 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9823 {"None", "??? 1", "2", "??? 3", "4"};
9824 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9825 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9826 {"Unused", "Needed", "Sign only"};
9827 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9828 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9829 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9830 {"Unused", "Finite", "RTABI", "IEEE 754"};
9831 static const char * arm_attr_tag_ABI_enum_size
[] =
9832 {"Unused", "small", "int", "forced to int"};
9833 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9834 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
9835 static const char * arm_attr_tag_ABI_VFP_args
[] =
9836 {"AAPCS", "VFP registers", "custom"};
9837 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9838 {"AAPCS", "WMMX registers", "custom"};
9839 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9840 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9841 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9842 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9843 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9844 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9845 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9846 static const char * arm_attr_tag_FP_HP_extension
[] =
9847 {"Not Allowed", "Allowed"};
9848 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9849 {"None", "IEEE 754", "Alternative Format"};
9850 static const char * arm_attr_tag_MPextension_use
[] =
9851 {"Not Allowed", "Allowed"};
9852 static const char * arm_attr_tag_DIV_use
[] =
9853 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
9854 "Allowed in v7-A with integer division extension"};
9855 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9856 static const char * arm_attr_tag_Virtualization_use
[] =
9857 {"Not Allowed", "TrustZone", "Virtualization Extensions",
9858 "TrustZone and Virtualization Extensions"};
9859 static const char * arm_attr_tag_MPextension_use_legacy
[] =
9860 {"Not Allowed", "Allowed"};
9862 #define LOOKUP(id, name) \
9863 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9864 static arm_attr_public_tag arm_attr_public_tags
[] =
9866 {4, "CPU_raw_name", 1, NULL
},
9867 {5, "CPU_name", 1, NULL
},
9868 LOOKUP(6, CPU_arch
),
9869 {7, "CPU_arch_profile", 0, NULL
},
9870 LOOKUP(8, ARM_ISA_use
),
9871 LOOKUP(9, THUMB_ISA_use
),
9872 LOOKUP(10, FP_arch
),
9873 LOOKUP(11, WMMX_arch
),
9874 LOOKUP(12, Advanced_SIMD_arch
),
9875 LOOKUP(13, PCS_config
),
9876 LOOKUP(14, ABI_PCS_R9_use
),
9877 LOOKUP(15, ABI_PCS_RW_data
),
9878 LOOKUP(16, ABI_PCS_RO_data
),
9879 LOOKUP(17, ABI_PCS_GOT_use
),
9880 LOOKUP(18, ABI_PCS_wchar_t
),
9881 LOOKUP(19, ABI_FP_rounding
),
9882 LOOKUP(20, ABI_FP_denormal
),
9883 LOOKUP(21, ABI_FP_exceptions
),
9884 LOOKUP(22, ABI_FP_user_exceptions
),
9885 LOOKUP(23, ABI_FP_number_model
),
9886 {24, "ABI_align_needed", 0, NULL
},
9887 {25, "ABI_align_preserved", 0, NULL
},
9888 LOOKUP(26, ABI_enum_size
),
9889 LOOKUP(27, ABI_HardFP_use
),
9890 LOOKUP(28, ABI_VFP_args
),
9891 LOOKUP(29, ABI_WMMX_args
),
9892 LOOKUP(30, ABI_optimization_goals
),
9893 LOOKUP(31, ABI_FP_optimization_goals
),
9894 {32, "compatibility", 0, NULL
},
9895 LOOKUP(34, CPU_unaligned_access
),
9896 LOOKUP(36, FP_HP_extension
),
9897 LOOKUP(38, ABI_FP_16bit_format
),
9898 LOOKUP(42, MPextension_use
),
9899 LOOKUP(44, DIV_use
),
9900 {64, "nodefaults", 0, NULL
},
9901 {65, "also_compatible_with", 0, NULL
},
9902 LOOKUP(66, T2EE_use
),
9903 {67, "conformance", 1, NULL
},
9904 LOOKUP(68, Virtualization_use
),
9905 LOOKUP(70, MPextension_use_legacy
)
9909 static unsigned char *
9910 display_arm_attribute (unsigned char * p
)
9915 arm_attr_public_tag
* attr
;
9919 tag
= read_uleb128 (p
, &len
);
9922 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9924 if (arm_attr_public_tags
[i
].tag
== tag
)
9926 attr
= &arm_attr_public_tags
[i
];
9933 printf (" Tag_%s: ", attr
->name
);
9939 case 7: /* Tag_CPU_arch_profile. */
9940 val
= read_uleb128 (p
, &len
);
9944 case 0: printf (_("None\n")); break;
9945 case 'A': printf (_("Application\n")); break;
9946 case 'R': printf (_("Realtime\n")); break;
9947 case 'M': printf (_("Microcontroller\n")); break;
9948 case 'S': printf (_("Application or Realtime\n")); break;
9949 default: printf ("??? (%d)\n", val
); break;
9953 case 24: /* Tag_align_needed. */
9954 val
= read_uleb128 (p
, &len
);
9958 case 0: printf (_("None\n")); break;
9959 case 1: printf (_("8-byte\n")); break;
9960 case 2: printf (_("4-byte\n")); break;
9961 case 3: printf ("??? 3\n"); break;
9964 printf (_("8-byte and up to %d-byte extended\n"),
9967 printf ("??? (%d)\n", val
);
9972 case 25: /* Tag_align_preserved. */
9973 val
= read_uleb128 (p
, &len
);
9977 case 0: printf (_("None\n")); break;
9978 case 1: printf (_("8-byte, except leaf SP\n")); break;
9979 case 2: printf (_("8-byte\n")); break;
9980 case 3: printf ("??? 3\n"); break;
9983 printf (_("8-byte and up to %d-byte extended\n"),
9986 printf ("??? (%d)\n", val
);
9991 case 32: /* Tag_compatibility. */
9992 val
= read_uleb128 (p
, &len
);
9994 printf (_("flag = %d, vendor = %s\n"), val
, p
);
9995 p
+= strlen ((char *) p
) + 1;
9998 case 64: /* Tag_nodefaults. */
10000 printf (_("True\n"));
10003 case 65: /* Tag_also_compatible_with. */
10004 val
= read_uleb128 (p
, &len
);
10006 if (val
== 6 /* Tag_CPU_arch. */)
10008 val
= read_uleb128 (p
, &len
);
10010 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10011 printf ("??? (%d)\n", val
);
10013 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10017 while (*(p
++) != '\0' /* NUL terminator. */);
10031 assert (attr
->type
& 0x80);
10032 val
= read_uleb128 (p
, &len
);
10034 type
= attr
->type
& 0x7f;
10036 printf ("??? (%d)\n", val
);
10038 printf ("%s\n", attr
->table
[val
]);
10045 type
= 1; /* String. */
10047 type
= 2; /* uleb128. */
10048 printf (" Tag_unknown_%d: ", tag
);
10053 printf ("\"%s\"\n", p
);
10054 p
+= strlen ((char *) p
) + 1;
10058 val
= read_uleb128 (p
, &len
);
10060 printf ("%d (0x%x)\n", val
, val
);
10066 static unsigned char *
10067 display_gnu_attribute (unsigned char * p
,
10068 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10075 tag
= read_uleb128 (p
, &len
);
10078 /* Tag_compatibility is the only generic GNU attribute defined at
10082 val
= read_uleb128 (p
, &len
);
10084 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10085 p
+= strlen ((char *) p
) + 1;
10089 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10090 return display_proc_gnu_attribute (p
, tag
);
10093 type
= 1; /* String. */
10095 type
= 2; /* uleb128. */
10096 printf (" Tag_unknown_%d: ", tag
);
10100 printf ("\"%s\"\n", p
);
10101 p
+= strlen ((char *) p
) + 1;
10105 val
= read_uleb128 (p
, &len
);
10107 printf ("%d (0x%x)\n", val
, val
);
10113 static unsigned char *
10114 display_power_gnu_attribute (unsigned char * p
, int tag
)
10120 if (tag
== Tag_GNU_Power_ABI_FP
)
10122 val
= read_uleb128 (p
, &len
);
10124 printf (" Tag_GNU_Power_ABI_FP: ");
10129 printf (_("Hard or soft float\n"));
10132 printf (_("Hard float\n"));
10135 printf (_("Soft float\n"));
10138 printf (_("Single-precision hard float\n"));
10141 printf ("??? (%d)\n", val
);
10147 if (tag
== Tag_GNU_Power_ABI_Vector
)
10149 val
= read_uleb128 (p
, &len
);
10151 printf (" Tag_GNU_Power_ABI_Vector: ");
10155 printf (_("Any\n"));
10158 printf (_("Generic\n"));
10161 printf ("AltiVec\n");
10167 printf ("??? (%d)\n", val
);
10173 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10175 val
= read_uleb128 (p
, &len
);
10177 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10181 printf (_("Any\n"));
10184 printf ("r3/r4\n");
10187 printf (_("Memory\n"));
10190 printf ("??? (%d)\n", val
);
10197 type
= 1; /* String. */
10199 type
= 2; /* uleb128. */
10200 printf (" Tag_unknown_%d: ", tag
);
10204 printf ("\"%s\"\n", p
);
10205 p
+= strlen ((char *) p
) + 1;
10209 val
= read_uleb128 (p
, &len
);
10211 printf ("%d (0x%x)\n", val
, val
);
10217 static unsigned char *
10218 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10224 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10226 val
= read_uleb128 (p
, &len
);
10228 printf (" Tag_GNU_MIPS_ABI_FP: ");
10233 printf (_("Hard or soft float\n"));
10236 printf (_("Hard float (double precision)\n"));
10239 printf (_("Hard float (single precision)\n"));
10242 printf (_("Soft float\n"));
10245 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10248 printf ("??? (%d)\n", val
);
10255 type
= 1; /* String. */
10257 type
= 2; /* uleb128. */
10258 printf (" Tag_unknown_%d: ", tag
);
10262 printf ("\"%s\"\n", p
);
10263 p
+= strlen ((char *) p
) + 1;
10267 val
= read_uleb128 (p
, &len
);
10269 printf ("%d (0x%x)\n", val
, val
);
10276 process_attributes (FILE * file
,
10277 const char * public_name
,
10278 unsigned int proc_type
,
10279 unsigned char * (* display_pub_attribute
) (unsigned char *),
10280 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10282 Elf_Internal_Shdr
* sect
;
10283 unsigned char * contents
;
10285 unsigned char * end
;
10286 bfd_vma section_len
;
10290 /* Find the section header so that we get the size. */
10291 for (i
= 0, sect
= section_headers
;
10292 i
< elf_header
.e_shnum
;
10295 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10298 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10299 sect
->sh_size
, _("attributes"));
10300 if (contents
== NULL
)
10306 len
= sect
->sh_size
- 1;
10312 bfd_boolean public_section
;
10313 bfd_boolean gnu_section
;
10315 section_len
= byte_get (p
, 4);
10318 if (section_len
> len
)
10320 printf (_("ERROR: Bad section length (%d > %d)\n"),
10321 (int) section_len
, (int) len
);
10325 len
-= section_len
;
10326 printf (_("Attribute Section: %s\n"), p
);
10328 if (public_name
&& streq ((char *) p
, public_name
))
10329 public_section
= TRUE
;
10331 public_section
= FALSE
;
10333 if (streq ((char *) p
, "gnu"))
10334 gnu_section
= TRUE
;
10336 gnu_section
= FALSE
;
10338 namelen
= strlen ((char *) p
) + 1;
10340 section_len
-= namelen
+ 4;
10342 while (section_len
> 0)
10348 size
= byte_get (p
, 4);
10349 if (size
> section_len
)
10351 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10352 (int) size
, (int) section_len
);
10353 size
= section_len
;
10356 section_len
-= size
;
10357 end
= p
+ size
- 1;
10363 printf (_("File Attributes\n"));
10366 printf (_("Section Attributes:"));
10369 printf (_("Symbol Attributes:"));
10375 val
= read_uleb128 (p
, &j
);
10379 printf (" %d", val
);
10384 printf (_("Unknown tag: %d\n"), tag
);
10385 public_section
= FALSE
;
10389 if (public_section
)
10392 p
= display_pub_attribute (p
);
10394 else if (gnu_section
)
10397 p
= display_gnu_attribute (p
,
10398 display_proc_gnu_attribute
);
10402 /* ??? Do something sensible, like dump hex. */
10403 printf (_(" Unknown section contexts\n"));
10410 printf (_("Unknown format '%c'\n"), *p
);
10418 process_arm_specific (FILE * file
)
10420 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
10421 display_arm_attribute
, NULL
);
10425 process_power_specific (FILE * file
)
10427 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10428 display_power_gnu_attribute
);
10431 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10432 Print the Address, Access and Initial fields of an entry at VMA ADDR
10433 and return the VMA of the next entry. */
10436 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10439 print_vma (addr
, LONG_HEX
);
10441 if (addr
< pltgot
+ 0xfff0)
10442 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
10444 printf ("%10s", "");
10447 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10452 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10453 print_vma (entry
, LONG_HEX
);
10455 return addr
+ (is_32bit_elf
? 4 : 8);
10458 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10459 PLTGOT. Print the Address and Initial fields of an entry at VMA
10460 ADDR and return the VMA of the next entry. */
10463 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10466 print_vma (addr
, LONG_HEX
);
10469 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10474 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10475 print_vma (entry
, LONG_HEX
);
10477 return addr
+ (is_32bit_elf
? 4 : 8);
10481 process_mips_specific (FILE * file
)
10483 Elf_Internal_Dyn
* entry
;
10484 size_t liblist_offset
= 0;
10485 size_t liblistno
= 0;
10486 size_t conflictsno
= 0;
10487 size_t options_offset
= 0;
10488 size_t conflicts_offset
= 0;
10489 size_t pltrelsz
= 0;
10491 bfd_vma pltgot
= 0;
10492 bfd_vma mips_pltgot
= 0;
10493 bfd_vma jmprel
= 0;
10494 bfd_vma local_gotno
= 0;
10495 bfd_vma gotsym
= 0;
10496 bfd_vma symtabno
= 0;
10498 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10499 display_mips_gnu_attribute
);
10501 /* We have a lot of special sections. Thanks SGI! */
10502 if (dynamic_section
== NULL
)
10503 /* No information available. */
10506 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10507 switch (entry
->d_tag
)
10509 case DT_MIPS_LIBLIST
:
10511 = offset_from_vma (file
, entry
->d_un
.d_val
,
10512 liblistno
* sizeof (Elf32_External_Lib
));
10514 case DT_MIPS_LIBLISTNO
:
10515 liblistno
= entry
->d_un
.d_val
;
10517 case DT_MIPS_OPTIONS
:
10518 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10520 case DT_MIPS_CONFLICT
:
10522 = offset_from_vma (file
, entry
->d_un
.d_val
,
10523 conflictsno
* sizeof (Elf32_External_Conflict
));
10525 case DT_MIPS_CONFLICTNO
:
10526 conflictsno
= entry
->d_un
.d_val
;
10529 pltgot
= entry
->d_un
.d_ptr
;
10531 case DT_MIPS_LOCAL_GOTNO
:
10532 local_gotno
= entry
->d_un
.d_val
;
10534 case DT_MIPS_GOTSYM
:
10535 gotsym
= entry
->d_un
.d_val
;
10537 case DT_MIPS_SYMTABNO
:
10538 symtabno
= entry
->d_un
.d_val
;
10540 case DT_MIPS_PLTGOT
:
10541 mips_pltgot
= entry
->d_un
.d_ptr
;
10544 pltrel
= entry
->d_un
.d_val
;
10547 pltrelsz
= entry
->d_un
.d_val
;
10550 jmprel
= entry
->d_un
.d_ptr
;
10556 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10558 Elf32_External_Lib
* elib
;
10561 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
10563 sizeof (Elf32_External_Lib
),
10567 printf (_("\nSection '.liblist' contains %lu entries:\n"),
10568 (unsigned long) liblistno
);
10569 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
10572 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10579 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10580 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10581 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10582 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10583 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10585 tmp
= gmtime (&atime
);
10586 snprintf (timebuf
, sizeof (timebuf
),
10587 "%04u-%02u-%02uT%02u:%02u:%02u",
10588 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10589 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10591 printf ("%3lu: ", (unsigned long) cnt
);
10592 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10593 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10595 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
10596 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10597 liblist
.l_version
);
10599 if (liblist
.l_flags
== 0)
10603 static const struct
10610 { " EXACT_MATCH", LL_EXACT_MATCH
},
10611 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10612 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10613 { " EXPORTS", LL_EXPORTS
},
10614 { " DELAY_LOAD", LL_DELAY_LOAD
},
10615 { " DELTA", LL_DELTA
}
10617 int flags
= liblist
.l_flags
;
10620 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
10621 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10623 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10624 flags
^= l_flags_vals
[fcnt
].bit
;
10627 printf (" %#x", (unsigned int) flags
);
10637 if (options_offset
!= 0)
10639 Elf_External_Options
* eopt
;
10640 Elf_Internal_Shdr
* sect
= section_headers
;
10641 Elf_Internal_Options
* iopt
;
10642 Elf_Internal_Options
* option
;
10646 /* Find the section header so that we get the size. */
10647 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10650 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
10651 sect
->sh_size
, _("options"));
10654 iopt
= (Elf_Internal_Options
*)
10655 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
10658 error (_("Out of memory\n"));
10665 while (offset
< sect
->sh_size
)
10667 Elf_External_Options
* eoption
;
10669 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10671 option
->kind
= BYTE_GET (eoption
->kind
);
10672 option
->size
= BYTE_GET (eoption
->size
);
10673 option
->section
= BYTE_GET (eoption
->section
);
10674 option
->info
= BYTE_GET (eoption
->info
);
10676 offset
+= option
->size
;
10682 printf (_("\nSection '%s' contains %d entries:\n"),
10683 SECTION_NAME (sect
), cnt
);
10691 switch (option
->kind
)
10694 /* This shouldn't happen. */
10695 printf (" NULL %d %lx", option
->section
, option
->info
);
10698 printf (" REGINFO ");
10699 if (elf_header
.e_machine
== EM_MIPS
)
10702 Elf32_External_RegInfo
* ereg
;
10703 Elf32_RegInfo reginfo
;
10705 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10706 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10707 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10708 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10709 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10710 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10711 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10713 printf ("GPR %08lx GP 0x%lx\n",
10714 reginfo
.ri_gprmask
,
10715 (unsigned long) reginfo
.ri_gp_value
);
10716 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10717 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10718 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10723 Elf64_External_RegInfo
* ereg
;
10724 Elf64_Internal_RegInfo reginfo
;
10726 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10727 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10728 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10729 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10730 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10731 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10732 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10734 printf ("GPR %08lx GP 0x",
10735 reginfo
.ri_gprmask
);
10736 printf_vma (reginfo
.ri_gp_value
);
10739 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10740 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10741 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10745 case ODK_EXCEPTIONS
:
10746 fputs (" EXCEPTIONS fpe_min(", stdout
);
10747 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10748 fputs (") fpe_max(", stdout
);
10749 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10750 fputs (")", stdout
);
10752 if (option
->info
& OEX_PAGE0
)
10753 fputs (" PAGE0", stdout
);
10754 if (option
->info
& OEX_SMM
)
10755 fputs (" SMM", stdout
);
10756 if (option
->info
& OEX_FPDBUG
)
10757 fputs (" FPDBUG", stdout
);
10758 if (option
->info
& OEX_DISMISS
)
10759 fputs (" DISMISS", stdout
);
10762 fputs (" PAD ", stdout
);
10763 if (option
->info
& OPAD_PREFIX
)
10764 fputs (" PREFIX", stdout
);
10765 if (option
->info
& OPAD_POSTFIX
)
10766 fputs (" POSTFIX", stdout
);
10767 if (option
->info
& OPAD_SYMBOL
)
10768 fputs (" SYMBOL", stdout
);
10771 fputs (" HWPATCH ", stdout
);
10772 if (option
->info
& OHW_R4KEOP
)
10773 fputs (" R4KEOP", stdout
);
10774 if (option
->info
& OHW_R8KPFETCH
)
10775 fputs (" R8KPFETCH", stdout
);
10776 if (option
->info
& OHW_R5KEOP
)
10777 fputs (" R5KEOP", stdout
);
10778 if (option
->info
& OHW_R5KCVTL
)
10779 fputs (" R5KCVTL", stdout
);
10782 fputs (" FILL ", stdout
);
10783 /* XXX Print content of info word? */
10786 fputs (" TAGS ", stdout
);
10787 /* XXX Print content of info word? */
10790 fputs (" HWAND ", stdout
);
10791 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10792 fputs (" R4KEOP_CHECKED", stdout
);
10793 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10794 fputs (" R4KEOP_CLEAN", stdout
);
10797 fputs (" HWOR ", stdout
);
10798 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10799 fputs (" R4KEOP_CHECKED", stdout
);
10800 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10801 fputs (" R4KEOP_CLEAN", stdout
);
10804 printf (" GP_GROUP %#06lx self-contained %#06lx",
10805 option
->info
& OGP_GROUP
,
10806 (option
->info
& OGP_SELF
) >> 16);
10809 printf (" IDENT %#06lx self-contained %#06lx",
10810 option
->info
& OGP_GROUP
,
10811 (option
->info
& OGP_SELF
) >> 16);
10814 /* This shouldn't happen. */
10815 printf (" %3d ??? %d %lx",
10816 option
->kind
, option
->section
, option
->info
);
10820 len
= sizeof (* eopt
);
10821 while (len
< option
->size
)
10822 if (((char *) option
)[len
] >= ' '
10823 && ((char *) option
)[len
] < 0x7f)
10824 printf ("%c", ((char *) option
)[len
++]);
10826 printf ("\\%03o", ((char *) option
)[len
++]);
10828 fputs ("\n", stdout
);
10836 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10838 Elf32_Conflict
* iconf
;
10841 if (dynamic_symbols
== NULL
)
10843 error (_("conflict list found without a dynamic symbol table\n"));
10847 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10850 error (_("Out of memory\n"));
10856 Elf32_External_Conflict
* econf32
;
10858 econf32
= (Elf32_External_Conflict
*)
10859 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10860 sizeof (* econf32
), _("conflict"));
10864 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10865 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10871 Elf64_External_Conflict
* econf64
;
10873 econf64
= (Elf64_External_Conflict
*)
10874 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10875 sizeof (* econf64
), _("conflict"));
10879 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10880 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10885 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10886 (unsigned long) conflictsno
);
10887 puts (_(" Num: Index Value Name"));
10889 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10891 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10893 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10894 print_vma (psym
->st_value
, FULL_HEX
);
10896 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10897 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10899 printf (_("<corrupt: %14ld>"), psym
->st_name
);
10906 if (pltgot
!= 0 && local_gotno
!= 0)
10908 bfd_vma ent
, local_end
, global_end
;
10910 unsigned char * data
;
10914 addr_size
= (is_32bit_elf
? 4 : 8);
10915 local_end
= pltgot
+ local_gotno
* addr_size
;
10916 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10918 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10919 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10920 global_end
- pltgot
, 1, _("GOT"));
10921 printf (_("\nPrimary GOT:\n"));
10922 printf (_(" Canonical gp value: "));
10923 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10926 printf (_(" Reserved entries:\n"));
10927 printf (_(" %*s %10s %*s Purpose\n"),
10928 addr_size
* 2, _("Address"), _("Access"),
10929 addr_size
* 2, _("Initial"));
10930 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10931 printf (_(" Lazy resolver\n"));
10933 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10934 >> (addr_size
* 8 - 1)) != 0)
10936 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10937 printf (_(" Module pointer (GNU extension)\n"));
10941 if (ent
< local_end
)
10943 printf (_(" Local entries:\n"));
10944 printf (_(" %*s %10s %*s\n"),
10945 addr_size
* 2, _("Address"), _("Access"),
10946 addr_size
* 2, _("Initial"));
10947 while (ent
< local_end
)
10949 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10955 if (gotsym
< symtabno
)
10959 printf (_(" Global entries:\n"));
10960 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10961 addr_size
* 2, _("Address"), _("Access"),
10962 addr_size
* 2, _("Initial"),
10963 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
10964 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10965 for (i
= gotsym
; i
< symtabno
; i
++)
10967 Elf_Internal_Sym
* psym
;
10969 psym
= dynamic_symbols
+ i
;
10970 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10972 print_vma (psym
->st_value
, LONG_HEX
);
10973 printf (" %-7s %3s ",
10974 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10975 get_symbol_index_type (psym
->st_shndx
));
10976 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10977 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10979 printf (_("<corrupt: %14ld>"), psym
->st_name
);
10989 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10992 size_t offset
, rel_offset
;
10993 unsigned long count
, i
;
10994 unsigned char * data
;
10995 int addr_size
, sym_width
;
10996 Elf_Internal_Rela
* rels
;
10998 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10999 if (pltrel
== DT_RELA
)
11001 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11006 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11011 addr_size
= (is_32bit_elf
? 4 : 8);
11012 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11014 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11015 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11017 printf (_("\nPLT GOT:\n\n"));
11018 printf (_(" Reserved entries:\n"));
11019 printf (_(" %*s %*s Purpose\n"),
11020 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11021 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11022 printf (_(" PLT lazy resolver\n"));
11023 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11024 printf (_(" Module pointer\n"));
11027 printf (_(" Entries:\n"));
11028 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11029 addr_size
* 2, _("Address"),
11030 addr_size
* 2, _("Initial"),
11031 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11032 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11033 for (i
= 0; i
< count
; i
++)
11035 Elf_Internal_Sym
* psym
;
11037 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11038 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11040 print_vma (psym
->st_value
, LONG_HEX
);
11041 printf (" %-7s %3s ",
11042 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11043 get_symbol_index_type (psym
->st_shndx
));
11044 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11045 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11047 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11061 process_gnu_liblist (FILE * file
)
11063 Elf_Internal_Shdr
* section
;
11064 Elf_Internal_Shdr
* string_sec
;
11065 Elf32_External_Lib
* elib
;
11067 size_t strtab_size
;
11074 for (i
= 0, section
= section_headers
;
11075 i
< elf_header
.e_shnum
;
11078 switch (section
->sh_type
)
11080 case SHT_GNU_LIBLIST
:
11081 if (section
->sh_link
>= elf_header
.e_shnum
)
11084 elib
= (Elf32_External_Lib
*)
11085 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11090 string_sec
= section_headers
+ section
->sh_link
;
11092 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11093 string_sec
->sh_size
,
11094 _("liblist string table"));
11095 strtab_size
= string_sec
->sh_size
;
11098 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11104 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11105 SECTION_NAME (section
),
11106 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11108 puts (_(" Library Time Stamp Checksum Version Flags"));
11110 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11118 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11119 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11120 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11121 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11122 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11124 tmp
= gmtime (&atime
);
11125 snprintf (timebuf
, sizeof (timebuf
),
11126 "%04u-%02u-%02uT%02u:%02u:%02u",
11127 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11128 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11130 printf ("%3lu: ", (unsigned long) cnt
);
11132 printf ("%-20s", liblist
.l_name
< strtab_size
11133 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11135 printf ("%-20.20s", liblist
.l_name
< strtab_size
11136 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11137 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11138 liblist
.l_version
, liblist
.l_flags
);
11148 static const char *
11149 get_note_type (unsigned e_type
)
11151 static char buff
[64];
11153 if (elf_header
.e_type
== ET_CORE
)
11157 return _("NT_AUXV (auxiliary vector)");
11159 return _("NT_PRSTATUS (prstatus structure)");
11161 return _("NT_FPREGSET (floating point registers)");
11163 return _("NT_PRPSINFO (prpsinfo structure)");
11164 case NT_TASKSTRUCT
:
11165 return _("NT_TASKSTRUCT (task structure)");
11167 return _("NT_PRXFPREG (user_xfpregs structure)");
11169 return _("NT_PPC_VMX (ppc Altivec registers)");
11171 return _("NT_PPC_VSX (ppc VSX registers)");
11172 case NT_X86_XSTATE
:
11173 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11174 case NT_S390_HIGH_GPRS
:
11175 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11176 case NT_S390_TIMER
:
11177 return _("NT_S390_TIMER (s390 timer register)");
11178 case NT_S390_TODCMP
:
11179 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11180 case NT_S390_TODPREG
:
11181 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11183 return _("NT_S390_CTRS (s390 control registers)");
11184 case NT_S390_PREFIX
:
11185 return _("NT_S390_PREFIX (s390 prefix register)");
11187 return _("NT_PSTATUS (pstatus structure)");
11189 return _("NT_FPREGS (floating point registers)");
11191 return _("NT_PSINFO (psinfo structure)");
11193 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11195 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11196 case NT_WIN32PSTATUS
:
11197 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11205 return _("NT_VERSION (version)");
11207 return _("NT_ARCH (architecture)");
11212 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11216 static const char *
11217 get_gnu_elf_note_type (unsigned e_type
)
11219 static char buff
[64];
11223 case NT_GNU_ABI_TAG
:
11224 return _("NT_GNU_ABI_TAG (ABI version tag)");
11226 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11227 case NT_GNU_BUILD_ID
:
11228 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11229 case NT_GNU_GOLD_VERSION
:
11230 return _("NT_GNU_GOLD_VERSION (gold version)");
11235 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11239 static const char *
11240 get_netbsd_elfcore_note_type (unsigned e_type
)
11242 static char buff
[64];
11244 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11246 /* NetBSD core "procinfo" structure. */
11247 return _("NetBSD procinfo structure");
11250 /* As of Jan 2002 there are no other machine-independent notes
11251 defined for NetBSD core files. If the note type is less
11252 than the start of the machine-dependent note types, we don't
11255 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11257 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11261 switch (elf_header
.e_machine
)
11263 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11264 and PT_GETFPREGS == mach+2. */
11269 case EM_SPARC32PLUS
:
11273 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11274 return _("PT_GETREGS (reg structure)");
11275 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11276 return _("PT_GETFPREGS (fpreg structure)");
11282 /* On all other arch's, PT_GETREGS == mach+1 and
11283 PT_GETFPREGS == mach+3. */
11287 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11288 return _("PT_GETREGS (reg structure)");
11289 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11290 return _("PT_GETFPREGS (fpreg structure)");
11296 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11297 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11301 /* Note that by the ELF standard, the name field is already null byte
11302 terminated, and namesz includes the terminating null byte.
11303 I.E. the value of namesz for the name "FSF" is 4.
11305 If the value of namesz is zero, there is no name present. */
11307 process_note (Elf_Internal_Note
* pnote
)
11309 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11312 if (pnote
->namesz
== 0)
11313 /* If there is no note name, then use the default set of
11314 note type strings. */
11315 nt
= get_note_type (pnote
->type
);
11317 else if (const_strneq (pnote
->namedata
, "GNU"))
11318 /* GNU-specific object file notes. */
11319 nt
= get_gnu_elf_note_type (pnote
->type
);
11321 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
11322 /* NetBSD-specific core file notes. */
11323 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11325 else if (strneq (pnote
->namedata
, "SPU/", 4))
11327 /* SPU-specific core file notes. */
11328 nt
= pnote
->namedata
+ 4;
11333 /* Don't recognize this note name; just use the default set of
11334 note type strings. */
11335 nt
= get_note_type (pnote
->type
);
11337 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
11343 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
11345 Elf_External_Note
* pnotes
;
11346 Elf_External_Note
* external
;
11352 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
11359 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11360 (unsigned long) offset
, (unsigned long) length
);
11361 printf (_(" Owner\t\tData size\tDescription\n"));
11363 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
11365 Elf_External_Note
* next
;
11366 Elf_Internal_Note inote
;
11367 char * temp
= NULL
;
11369 inote
.type
= BYTE_GET (external
->type
);
11370 inote
.namesz
= BYTE_GET (external
->namesz
);
11371 inote
.namedata
= external
->name
;
11372 inote
.descsz
= BYTE_GET (external
->descsz
);
11373 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11374 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11376 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
11378 if (((char *) next
) > (((char *) pnotes
) + length
))
11380 warn (_("corrupt note found at offset %lx into core notes\n"),
11381 (unsigned long) ((char *) external
- (char *) pnotes
));
11382 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11383 inote
.type
, inote
.namesz
, inote
.descsz
);
11389 /* Verify that name is null terminated. It appears that at least
11390 one version of Linux (RedHat 6.0) generates corefiles that don't
11391 comply with the ELF spec by failing to include the null byte in
11393 if (inote
.namedata
[inote
.namesz
] != '\0')
11395 temp
= (char *) malloc (inote
.namesz
+ 1);
11399 error (_("Out of memory\n"));
11404 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11405 temp
[inote
.namesz
] = 0;
11407 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11408 inote
.namedata
= temp
;
11411 res
&= process_note (& inote
);
11426 process_corefile_note_segments (FILE * file
)
11428 Elf_Internal_Phdr
* segment
;
11432 if (! get_program_headers (file
))
11435 for (i
= 0, segment
= program_headers
;
11436 i
< elf_header
.e_phnum
;
11439 if (segment
->p_type
== PT_NOTE
)
11440 res
&= process_corefile_note_segment (file
,
11441 (bfd_vma
) segment
->p_offset
,
11442 (bfd_vma
) segment
->p_filesz
);
11449 process_note_sections (FILE * file
)
11451 Elf_Internal_Shdr
* section
;
11455 for (i
= 0, section
= section_headers
;
11456 i
< elf_header
.e_shnum
;
11458 if (section
->sh_type
== SHT_NOTE
)
11459 res
&= process_corefile_note_segment (file
,
11460 (bfd_vma
) section
->sh_offset
,
11461 (bfd_vma
) section
->sh_size
);
11467 process_notes (FILE * file
)
11469 /* If we have not been asked to display the notes then do nothing. */
11473 if (elf_header
.e_type
!= ET_CORE
)
11474 return process_note_sections (file
);
11476 /* No program headers means no NOTE segment. */
11477 if (elf_header
.e_phnum
> 0)
11478 return process_corefile_note_segments (file
);
11480 printf (_("No note segments present in the core file.\n"));
11485 process_arch_specific (FILE * file
)
11490 switch (elf_header
.e_machine
)
11493 return process_arm_specific (file
);
11495 case EM_MIPS_RS3_LE
:
11496 return process_mips_specific (file
);
11499 return process_power_specific (file
);
11508 get_file_header (FILE * file
)
11510 /* Read in the identity array. */
11511 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11514 /* Determine how to read the rest of the header. */
11515 switch (elf_header
.e_ident
[EI_DATA
])
11517 default: /* fall through */
11518 case ELFDATANONE
: /* fall through */
11520 byte_get
= byte_get_little_endian
;
11521 byte_put
= byte_put_little_endian
;
11524 byte_get
= byte_get_big_endian
;
11525 byte_put
= byte_put_big_endian
;
11529 /* For now we only support 32 bit and 64 bit ELF files. */
11530 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11532 /* Read in the rest of the header. */
11535 Elf32_External_Ehdr ehdr32
;
11537 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11540 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11541 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11542 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11543 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11544 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11545 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11546 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11547 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11548 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11549 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11550 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11551 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11552 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11556 Elf64_External_Ehdr ehdr64
;
11558 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11559 we will not be able to cope with the 64bit data found in
11560 64 ELF files. Detect this now and abort before we start
11561 overwriting things. */
11562 if (sizeof (bfd_vma
) < 8)
11564 error (_("This instance of readelf has been built without support for a\n\
11565 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11569 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11572 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11573 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11574 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11575 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11576 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11577 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11578 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11579 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11580 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11581 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11582 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11583 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11584 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11587 if (elf_header
.e_shoff
)
11589 /* There may be some extensions in the first section header. Don't
11590 bomb if we can't read it. */
11592 get_32bit_section_headers (file
, 1);
11594 get_64bit_section_headers (file
, 1);
11600 /* Process one ELF object file according to the command line options.
11601 This file may actually be stored in an archive. The file is
11602 positioned at the start of the ELF object. */
11605 process_object (char * file_name
, FILE * file
)
11609 if (! get_file_header (file
))
11611 error (_("%s: Failed to read file header\n"), file_name
);
11615 /* Initialise per file variables. */
11616 for (i
= ARRAY_SIZE (version_info
); i
--;)
11617 version_info
[i
] = 0;
11619 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
11620 dynamic_info
[i
] = 0;
11622 /* Process the file. */
11624 printf (_("\nFile: %s\n"), file_name
);
11626 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11627 Note we do this even if cmdline_dump_sects is empty because we
11628 must make sure that the dump_sets array is zeroed out before each
11629 object file is processed. */
11630 if (num_dump_sects
> num_cmdline_dump_sects
)
11631 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
11633 if (num_cmdline_dump_sects
> 0)
11635 if (num_dump_sects
== 0)
11636 /* A sneaky way of allocating the dump_sects array. */
11637 request_dump_bynumber (num_cmdline_dump_sects
, 0);
11639 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11640 memcpy (dump_sects
, cmdline_dump_sects
,
11641 num_cmdline_dump_sects
* sizeof (* dump_sects
));
11644 if (! process_file_header ())
11647 if (! process_section_headers (file
))
11649 /* Without loaded section headers we cannot process lots of
11651 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11653 if (! do_using_dynamic
)
11654 do_syms
= do_dyn_syms
= do_reloc
= 0;
11657 if (! process_section_groups (file
))
11659 /* Without loaded section groups we cannot process unwind. */
11663 if (process_program_headers (file
))
11664 process_dynamic_section (file
);
11666 process_relocs (file
);
11668 process_unwind (file
);
11670 process_symbol_table (file
);
11672 process_syminfo (file
);
11674 process_version_sections (file
);
11676 process_section_contents (file
);
11678 process_notes (file
);
11680 process_gnu_liblist (file
);
11682 process_arch_specific (file
);
11684 if (program_headers
)
11686 free (program_headers
);
11687 program_headers
= NULL
;
11690 if (section_headers
)
11692 free (section_headers
);
11693 section_headers
= NULL
;
11698 free (string_table
);
11699 string_table
= NULL
;
11700 string_table_length
= 0;
11703 if (dynamic_strings
)
11705 free (dynamic_strings
);
11706 dynamic_strings
= NULL
;
11707 dynamic_strings_length
= 0;
11710 if (dynamic_symbols
)
11712 free (dynamic_symbols
);
11713 dynamic_symbols
= NULL
;
11714 num_dynamic_syms
= 0;
11717 if (dynamic_syminfo
)
11719 free (dynamic_syminfo
);
11720 dynamic_syminfo
= NULL
;
11723 if (section_headers_groups
)
11725 free (section_headers_groups
);
11726 section_headers_groups
= NULL
;
11729 if (section_groups
)
11731 struct group_list
* g
;
11732 struct group_list
* next
;
11734 for (i
= 0; i
< group_count
; i
++)
11736 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11743 free (section_groups
);
11744 section_groups
= NULL
;
11747 free_debug_memory ();
11752 /* Return the path name for a proxy entry in a thin archive, adjusted relative
11753 to the path name of the thin archive itself if necessary. Always returns
11754 a pointer to malloc'ed memory. */
11757 adjust_relative_path (char * file_name
, char * name
, int name_len
)
11759 char * member_file_name
;
11760 const char * base_name
= lbasename (file_name
);
11762 /* This is a proxy entry for a thin archive member.
11763 If the extended name table contains an absolute path
11764 name, or if the archive is in the current directory,
11765 use the path name as given. Otherwise, we need to
11766 find the member relative to the directory where the
11767 archive is located. */
11768 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
11770 member_file_name
= (char *) malloc (name_len
+ 1);
11771 if (member_file_name
== NULL
)
11773 error (_("Out of memory\n"));
11776 memcpy (member_file_name
, name
, name_len
);
11777 member_file_name
[name_len
] = '\0';
11781 /* Concatenate the path components of the archive file name
11782 to the relative path name from the extended name table. */
11783 size_t prefix_len
= base_name
- file_name
;
11784 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
11785 if (member_file_name
== NULL
)
11787 error (_("Out of memory\n"));
11790 memcpy (member_file_name
, file_name
, prefix_len
);
11791 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11792 member_file_name
[prefix_len
+ name_len
] = '\0';
11794 return member_file_name
;
11797 /* Structure to hold information about an archive file. */
11799 struct archive_info
11801 char * file_name
; /* Archive file name. */
11802 FILE * file
; /* Open file descriptor. */
11803 unsigned long index_num
; /* Number of symbols in table. */
11804 unsigned long * index_array
; /* The array of member offsets. */
11805 char * sym_table
; /* The symbol table. */
11806 unsigned long sym_size
; /* Size of the symbol table. */
11807 char * longnames
; /* The long file names table. */
11808 unsigned long longnames_size
; /* Size of the long file names table. */
11809 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11810 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11811 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11812 struct ar_hdr arhdr
; /* Current archive header. */
11815 /* Read the symbol table and long-name table from an archive. */
11818 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11819 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11822 unsigned long size
;
11824 arch
->file_name
= strdup (file_name
);
11826 arch
->index_num
= 0;
11827 arch
->index_array
= NULL
;
11828 arch
->sym_table
= NULL
;
11829 arch
->sym_size
= 0;
11830 arch
->longnames
= NULL
;
11831 arch
->longnames_size
= 0;
11832 arch
->nested_member_origin
= 0;
11833 arch
->is_thin_archive
= is_thin_archive
;
11834 arch
->next_arhdr_offset
= SARMAG
;
11836 /* Read the first archive member header. */
11837 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11839 error (_("%s: failed to seek to first archive header\n"), file_name
);
11842 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11843 if (got
!= sizeof arch
->arhdr
)
11848 error (_("%s: failed to read archive header\n"), file_name
);
11852 /* See if this is the archive symbol table. */
11853 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11854 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11856 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11857 size
= size
+ (size
& 1);
11859 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11864 /* A buffer used to hold numbers read in from an archive index.
11865 These are always 4 bytes long and stored in big-endian format. */
11866 #define SIZEOF_AR_INDEX_NUMBERS 4
11867 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11868 unsigned char * index_buffer
;
11870 /* Check the size of the archive index. */
11871 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11873 error (_("%s: the archive index is empty\n"), file_name
);
11877 /* Read the numer of entries in the archive index. */
11878 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11879 if (got
!= sizeof (integer_buffer
))
11881 error (_("%s: failed to read archive index\n"), file_name
);
11884 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11885 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11887 /* Read in the archive index. */
11888 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11890 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11891 file_name
, arch
->index_num
);
11894 index_buffer
= (unsigned char *)
11895 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11896 if (index_buffer
== NULL
)
11898 error (_("Out of memory whilst trying to read archive symbol index\n"));
11901 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11902 if (got
!= arch
->index_num
)
11904 free (index_buffer
);
11905 error (_("%s: failed to read archive index\n"), file_name
);
11908 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11910 /* Convert the index numbers into the host's numeric format. */
11911 arch
->index_array
= (long unsigned int *)
11912 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11913 if (arch
->index_array
== NULL
)
11915 free (index_buffer
);
11916 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11920 for (i
= 0; i
< arch
->index_num
; i
++)
11921 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11922 SIZEOF_AR_INDEX_NUMBERS
);
11923 free (index_buffer
);
11925 /* The remaining space in the header is taken up by the symbol table. */
11928 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11931 arch
->sym_table
= (char *) malloc (size
);
11932 arch
->sym_size
= size
;
11933 if (arch
->sym_table
== NULL
)
11935 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11938 got
= fread (arch
->sym_table
, 1, size
, file
);
11941 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11947 if (fseek (file
, size
, SEEK_CUR
) != 0)
11949 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11954 /* Read the next archive header. */
11955 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11956 if (got
!= sizeof arch
->arhdr
)
11960 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11964 else if (read_symbols
)
11965 printf (_("%s has no archive index\n"), file_name
);
11967 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11969 /* This is the archive string table holding long member names. */
11970 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11971 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11973 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11974 if (arch
->longnames
== NULL
)
11976 error (_("Out of memory reading long symbol names in archive\n"));
11980 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11982 free (arch
->longnames
);
11983 arch
->longnames
= NULL
;
11984 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11988 if ((arch
->longnames_size
& 1) != 0)
11995 /* Release the memory used for the archive information. */
11998 release_archive (struct archive_info
* arch
)
12000 if (arch
->file_name
!= NULL
)
12001 free (arch
->file_name
);
12002 if (arch
->index_array
!= NULL
)
12003 free (arch
->index_array
);
12004 if (arch
->sym_table
!= NULL
)
12005 free (arch
->sym_table
);
12006 if (arch
->longnames
!= NULL
)
12007 free (arch
->longnames
);
12010 /* Open and setup a nested archive, if not already open. */
12013 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12015 FILE * member_file
;
12017 /* Have we already setup this archive? */
12018 if (nested_arch
->file_name
!= NULL
12019 && streq (nested_arch
->file_name
, member_file_name
))
12022 /* Close previous file and discard cached information. */
12023 if (nested_arch
->file
!= NULL
)
12024 fclose (nested_arch
->file
);
12025 release_archive (nested_arch
);
12027 member_file
= fopen (member_file_name
, "rb");
12028 if (member_file
== NULL
)
12030 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12034 get_archive_member_name_at (struct archive_info
* arch
,
12035 unsigned long offset
,
12036 struct archive_info
* nested_arch
);
12038 /* Get the name of an archive member from the current archive header.
12039 For simple names, this will modify the ar_name field of the current
12040 archive header. For long names, it will return a pointer to the
12041 longnames table. For nested archives, it will open the nested archive
12042 and get the name recursively. NESTED_ARCH is a single-entry cache so
12043 we don't keep rereading the same information from a nested archive. */
12046 get_archive_member_name (struct archive_info
* arch
,
12047 struct archive_info
* nested_arch
)
12049 unsigned long j
, k
;
12051 if (arch
->arhdr
.ar_name
[0] == '/')
12053 /* We have a long name. */
12055 char * member_file_name
;
12056 char * member_name
;
12058 arch
->nested_member_origin
= 0;
12059 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12060 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12061 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12063 while ((j
< arch
->longnames_size
)
12064 && (arch
->longnames
[j
] != '\n')
12065 && (arch
->longnames
[j
] != '\0'))
12067 if (arch
->longnames
[j
-1] == '/')
12069 arch
->longnames
[j
] = '\0';
12071 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12072 return arch
->longnames
+ k
;
12074 /* This is a proxy for a member of a nested archive.
12075 Find the name of the member in that archive. */
12076 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12077 if (member_file_name
!= NULL
12078 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12079 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12081 free (member_file_name
);
12082 return member_name
;
12084 free (member_file_name
);
12086 /* Last resort: just return the name of the nested archive. */
12087 return arch
->longnames
+ k
;
12090 /* We have a normal (short) name. */
12092 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
12094 arch
->arhdr
.ar_name
[j
] = '\0';
12095 return arch
->arhdr
.ar_name
;
12098 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12101 get_archive_member_name_at (struct archive_info
* arch
,
12102 unsigned long offset
,
12103 struct archive_info
* nested_arch
)
12107 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12109 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12112 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12113 if (got
!= sizeof arch
->arhdr
)
12115 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12118 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12120 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12124 return get_archive_member_name (arch
, nested_arch
);
12127 /* Construct a string showing the name of the archive member, qualified
12128 with the name of the containing archive file. For thin archives, we
12129 use square brackets to denote the indirection. For nested archives,
12130 we show the qualified name of the external member inside the square
12131 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12134 make_qualified_name (struct archive_info
* arch
,
12135 struct archive_info
* nested_arch
,
12136 char * member_name
)
12141 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12142 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12143 len
+= strlen (nested_arch
->file_name
) + 2;
12145 name
= (char *) malloc (len
);
12148 error (_("Out of memory\n"));
12152 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12153 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12154 else if (arch
->is_thin_archive
)
12155 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12157 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12162 /* Process an ELF archive.
12163 On entry the file is positioned just after the ARMAG string. */
12166 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12168 struct archive_info arch
;
12169 struct archive_info nested_arch
;
12175 /* The ARCH structure is used to hold information about this archive. */
12176 arch
.file_name
= NULL
;
12178 arch
.index_array
= NULL
;
12179 arch
.sym_table
= NULL
;
12180 arch
.longnames
= NULL
;
12182 /* The NESTED_ARCH structure is used as a single-item cache of information
12183 about a nested archive (when members of a thin archive reside within
12184 another regular archive file). */
12185 nested_arch
.file_name
= NULL
;
12186 nested_arch
.file
= NULL
;
12187 nested_arch
.index_array
= NULL
;
12188 nested_arch
.sym_table
= NULL
;
12189 nested_arch
.longnames
= NULL
;
12191 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12197 if (do_archive_index
)
12199 if (arch
.sym_table
== NULL
)
12200 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12204 unsigned long current_pos
;
12206 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12207 file_name
, arch
.index_num
, arch
.sym_size
);
12208 current_pos
= ftell (file
);
12210 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12212 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12214 char * member_name
;
12216 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12218 if (member_name
!= NULL
)
12220 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12222 if (qualified_name
!= NULL
)
12224 printf (_("Binary %s contains:\n"), qualified_name
);
12225 free (qualified_name
);
12230 if (l
>= arch
.sym_size
)
12232 error (_("%s: end of the symbol table reached before the end of the index\n"),
12236 printf ("\t%s\n", arch
.sym_table
+ l
);
12237 l
+= strlen (arch
.sym_table
+ l
) + 1;
12242 if (l
< arch
.sym_size
)
12243 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12246 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12248 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12254 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12255 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12256 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12257 && !do_section_groups
&& !do_dyn_syms
)
12259 ret
= 0; /* Archive index only. */
12270 char * qualified_name
;
12272 /* Read the next archive header. */
12273 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12275 error (_("%s: failed to seek to next archive header\n"), file_name
);
12278 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12279 if (got
!= sizeof arch
.arhdr
)
12283 error (_("%s: failed to read archive header\n"), file_name
);
12287 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12289 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12294 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12296 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12297 if (archive_file_size
& 01)
12298 ++archive_file_size
;
12300 name
= get_archive_member_name (&arch
, &nested_arch
);
12303 error (_("%s: bad archive file name\n"), file_name
);
12307 namelen
= strlen (name
);
12309 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12310 if (qualified_name
== NULL
)
12312 error (_("%s: bad archive file name\n"), file_name
);
12317 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12319 /* This is a proxy for an external member of a thin archive. */
12320 FILE * member_file
;
12321 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12322 if (member_file_name
== NULL
)
12328 member_file
= fopen (member_file_name
, "rb");
12329 if (member_file
== NULL
)
12331 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12332 free (member_file_name
);
12337 archive_file_offset
= arch
.nested_member_origin
;
12339 ret
|= process_object (qualified_name
, member_file
);
12341 fclose (member_file
);
12342 free (member_file_name
);
12344 else if (is_thin_archive
)
12346 /* This is a proxy for a member of a nested archive. */
12347 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12349 /* The nested archive file will have been opened and setup by
12350 get_archive_member_name. */
12351 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12353 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12358 ret
|= process_object (qualified_name
, nested_arch
.file
);
12362 archive_file_offset
= arch
.next_arhdr_offset
;
12363 arch
.next_arhdr_offset
+= archive_file_size
;
12365 ret
|= process_object (qualified_name
, file
);
12368 free (qualified_name
);
12372 if (nested_arch
.file
!= NULL
)
12373 fclose (nested_arch
.file
);
12374 release_archive (&nested_arch
);
12375 release_archive (&arch
);
12381 process_file (char * file_name
)
12384 struct stat statbuf
;
12385 char armag
[SARMAG
];
12388 if (stat (file_name
, &statbuf
) < 0)
12390 if (errno
== ENOENT
)
12391 error (_("'%s': No such file\n"), file_name
);
12393 error (_("Could not locate '%s'. System error message: %s\n"),
12394 file_name
, strerror (errno
));
12398 if (! S_ISREG (statbuf
.st_mode
))
12400 error (_("'%s' is not an ordinary file\n"), file_name
);
12404 file
= fopen (file_name
, "rb");
12407 error (_("Input file '%s' is not readable.\n"), file_name
);
12411 if (fread (armag
, SARMAG
, 1, file
) != 1)
12413 error (_("%s: Failed to read file's magic number\n"), file_name
);
12418 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12419 ret
= process_archive (file_name
, file
, FALSE
);
12420 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12421 ret
= process_archive (file_name
, file
, TRUE
);
12424 if (do_archive_index
)
12425 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12429 archive_file_size
= archive_file_offset
= 0;
12430 ret
= process_object (file_name
, file
);
12438 #ifdef SUPPORT_DISASSEMBLY
12439 /* Needed by the i386 disassembler. For extra credit, someone could
12440 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12444 print_address (unsigned int addr
, FILE * outfile
)
12446 fprintf (outfile
,"0x%8.8x", addr
);
12449 /* Needed by the i386 disassembler. */
12451 db_task_printsym (unsigned int addr
)
12453 print_address (addr
, stderr
);
12458 main (int argc
, char ** argv
)
12462 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12463 setlocale (LC_MESSAGES
, "");
12465 #if defined (HAVE_SETLOCALE)
12466 setlocale (LC_CTYPE
, "");
12468 bindtextdomain (PACKAGE
, LOCALEDIR
);
12469 textdomain (PACKAGE
);
12471 expandargv (&argc
, &argv
);
12473 parse_args (argc
, argv
);
12475 if (num_dump_sects
> 0)
12477 /* Make a copy of the dump_sects array. */
12478 cmdline_dump_sects
= (dump_type
*)
12479 malloc (num_dump_sects
* sizeof (* dump_sects
));
12480 if (cmdline_dump_sects
== NULL
)
12481 error (_("Out of memory allocating dump request table.\n"));
12484 memcpy (cmdline_dump_sects
, dump_sects
,
12485 num_dump_sects
* sizeof (* dump_sects
));
12486 num_cmdline_dump_sects
= num_dump_sects
;
12490 if (optind
< (argc
- 1))
12494 while (optind
< argc
)
12495 err
|= process_file (argv
[optind
++]);
12497 if (dump_sects
!= NULL
)
12499 if (cmdline_dump_sects
!= NULL
)
12500 free (cmdline_dump_sects
);