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. */
67 #include "elf/common.h"
68 #include "elf/external.h"
69 #include "elf/internal.h"
72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
80 /* Undo the effects of #including reloc-macros.h. */
82 #undef START_RELOC_NUMBERS
86 #undef END_RELOC_NUMBERS
87 #undef _RELOC_MACROS_H
89 /* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
93 #define RELOC_MACROS_GEN_FUNC
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/fr30.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/microblaze.h"
125 #include "elf/mips.h"
126 #include "elf/mmix.h"
127 #include "elf/mn10200.h"
128 #include "elf/mn10300.h"
129 #include "elf/moxie.h"
131 #include "elf/msp430.h"
132 #include "elf/or32.h"
135 #include "elf/ppc64.h"
137 #include "elf/s390.h"
138 #include "elf/score.h"
140 #include "elf/sparc.h"
142 #include "elf/tic6x.h"
143 #include "elf/v850.h"
145 #include "elf/x86-64.h"
146 #include "elf/xc16x.h"
147 #include "elf/xstormy16.h"
148 #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
264 #define SECTION_NAME(X) \
265 ((X) == NULL ? _("<none>") \
266 : string_table == NULL ? _("<no-name>") \
267 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
268 : string_table + (X)->sh_name))
270 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
272 #define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
276 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
281 #define REMOVE_ARCH_BITS(ADDR) do { \
282 if (elf_header.e_machine == EM_ARM) \
287 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
292 if (size
== 0 || nmemb
== 0)
295 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
297 error (_("Unable to seek to 0x%lx for %s\n"),
298 (unsigned long) archive_file_offset
+ offset
, reason
);
305 /* Check for overflow. */
306 if (nmemb
< (~(size_t) 0 - 1) / size
)
307 /* + 1 so that we can '\0' terminate invalid string table sections. */
308 mvar
= malloc (size
* nmemb
+ 1);
312 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
313 (unsigned long)(size
* nmemb
), reason
);
317 ((char *) mvar
)[size
* nmemb
] = '\0';
320 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
322 error (_("Unable to read in 0x%lx bytes of %s\n"),
323 (unsigned long)(size
* nmemb
), reason
);
332 /* Print a VMA value. */
335 print_vma (bfd_vma vma
, print_mode mode
)
348 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
355 return printf ("%5" BFD_VMA_FMT
"d", vma
);
363 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
366 return printf ("%" BFD_VMA_FMT
"d", vma
);
369 return printf ("%" BFD_VMA_FMT
"u", vma
);
374 /* Display a symbol on stdout. Handles the display of non-printing characters.
376 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
377 truncating as necessary. If WIDTH is negative then format the string to be
378 exactly - WIDTH characters, truncating or padding as necessary.
380 Returns the number of emitted characters. */
383 print_symbol (int width
, const char *symbol
)
386 bfd_boolean extra_padding
= FALSE
;
387 unsigned int num_printed
= 0;
391 /* Set the width to a very large value. This simplifies the
397 /* Keep the width positive. This also helps. */
399 extra_padding
= TRUE
;
408 /* Look for non-printing symbols inside the symbol's name.
409 This test is triggered in particular by the names generated
410 by the assembler for local labels. */
421 printf ("%.*s", len
, symbol
);
427 if (*c
== 0 || width
== 0)
430 /* Now display the non-printing character, if
431 there is room left in which to dipslay it. */
432 if ((unsigned char) *c
< 32)
437 printf ("^%c", *c
+ 0x40);
447 printf ("<0x%.2x>", (unsigned char) *c
);
456 if (extra_padding
&& width
> 0)
458 /* Fill in the remaining spaces. */
459 printf ("%-*s", width
, " ");
466 /* Return a pointer to section NAME, or NULL if no such section exists. */
468 static Elf_Internal_Shdr
*
469 find_section (const char * name
)
473 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
474 if (streq (SECTION_NAME (section_headers
+ i
), name
))
475 return section_headers
+ i
;
480 /* Return a pointer to a section containing ADDR, or NULL if no such
483 static Elf_Internal_Shdr
*
484 find_section_by_address (bfd_vma addr
)
488 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
490 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
491 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
498 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
502 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
504 return read_leb128 (data
, length_return
, 0);
507 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
508 This OS has so many departures from the ELF standard that we test it at
514 return elf_header
.e_machine
== EM_IA_64
515 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
518 /* Guess the relocation size commonly used by the specific machines. */
521 guess_is_rela (unsigned int e_machine
)
525 /* Targets that use REL relocations. */
541 /* Targets that use RELA relocations. */
545 case EM_ALTERA_NIOS2
:
565 case EM_LATTICEMICO32
:
573 case EM_CYGNUS_MN10200
:
575 case EM_CYGNUS_MN10300
:
601 case EM_MICROBLAZE_OLD
:
622 warn (_("Don't know about relocations on this machine architecture\n"));
628 slurp_rela_relocs (FILE * file
,
629 unsigned long rel_offset
,
630 unsigned long rel_size
,
631 Elf_Internal_Rela
** relasp
,
632 unsigned long * nrelasp
)
634 Elf_Internal_Rela
* relas
;
635 unsigned long nrelas
;
640 Elf32_External_Rela
* erelas
;
642 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
643 rel_size
, _("relocs"));
647 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
649 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
650 sizeof (Elf_Internal_Rela
));
655 error (_("out of memory parsing relocs\n"));
659 for (i
= 0; i
< nrelas
; i
++)
661 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
662 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
663 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
670 Elf64_External_Rela
* erelas
;
672 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
673 rel_size
, _("relocs"));
677 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
679 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
680 sizeof (Elf_Internal_Rela
));
685 error (_("out of memory parsing relocs\n"));
689 for (i
= 0; i
< nrelas
; i
++)
691 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
692 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
693 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
695 /* The #ifdef BFD64 below is to prevent a compile time
696 warning. We know that if we do not have a 64 bit data
697 type that we will never execute this code anyway. */
699 if (elf_header
.e_machine
== EM_MIPS
700 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
702 /* In little-endian objects, r_info isn't really a
703 64-bit little-endian value: it has a 32-bit
704 little-endian symbol index followed by four
705 individual byte fields. Reorder INFO
707 bfd_vma inf
= relas
[i
].r_info
;
708 inf
= (((inf
& 0xffffffff) << 32)
709 | ((inf
>> 56) & 0xff)
710 | ((inf
>> 40) & 0xff00)
711 | ((inf
>> 24) & 0xff0000)
712 | ((inf
>> 8) & 0xff000000));
713 relas
[i
].r_info
= inf
;
726 slurp_rel_relocs (FILE * file
,
727 unsigned long rel_offset
,
728 unsigned long rel_size
,
729 Elf_Internal_Rela
** relsp
,
730 unsigned long * nrelsp
)
732 Elf_Internal_Rela
* rels
;
738 Elf32_External_Rel
* erels
;
740 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
741 rel_size
, _("relocs"));
745 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
747 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
752 error (_("out of memory parsing relocs\n"));
756 for (i
= 0; i
< nrels
; i
++)
758 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
759 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
760 rels
[i
].r_addend
= 0;
767 Elf64_External_Rel
* erels
;
769 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
770 rel_size
, _("relocs"));
774 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
776 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
781 error (_("out of memory parsing relocs\n"));
785 for (i
= 0; i
< nrels
; i
++)
787 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
788 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
789 rels
[i
].r_addend
= 0;
791 /* The #ifdef BFD64 below is to prevent a compile time
792 warning. We know that if we do not have a 64 bit data
793 type that we will never execute this code anyway. */
795 if (elf_header
.e_machine
== EM_MIPS
796 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
798 /* In little-endian objects, r_info isn't really a
799 64-bit little-endian value: it has a 32-bit
800 little-endian symbol index followed by four
801 individual byte fields. Reorder INFO
803 bfd_vma inf
= rels
[i
].r_info
;
804 inf
= (((inf
& 0xffffffff) << 32)
805 | ((inf
>> 56) & 0xff)
806 | ((inf
>> 40) & 0xff00)
807 | ((inf
>> 24) & 0xff0000)
808 | ((inf
>> 8) & 0xff000000));
809 rels
[i
].r_info
= inf
;
821 /* Returns the reloc type extracted from the reloc info field. */
824 get_reloc_type (bfd_vma reloc_info
)
827 return ELF32_R_TYPE (reloc_info
);
829 switch (elf_header
.e_machine
)
832 /* Note: We assume that reloc_info has already been adjusted for us. */
833 return ELF64_MIPS_R_TYPE (reloc_info
);
836 return ELF64_R_TYPE_ID (reloc_info
);
839 return ELF64_R_TYPE (reloc_info
);
843 /* Return the symbol index extracted from the reloc info field. */
846 get_reloc_symindex (bfd_vma reloc_info
)
848 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
851 /* Display the contents of the relocation data found at the specified
855 dump_relocations (FILE * file
,
856 unsigned long rel_offset
,
857 unsigned long rel_size
,
858 Elf_Internal_Sym
* symtab
,
861 unsigned long strtablen
,
865 Elf_Internal_Rela
* rels
;
867 if (is_rela
== UNKNOWN
)
868 is_rela
= guess_is_rela (elf_header
.e_machine
);
872 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
877 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
886 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
888 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
893 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
895 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
903 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
905 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
910 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
912 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
916 for (i
= 0; i
< rel_size
; i
++)
921 bfd_vma symtab_index
;
924 offset
= rels
[i
].r_offset
;
925 inf
= rels
[i
].r_info
;
927 type
= get_reloc_type (inf
);
928 symtab_index
= get_reloc_symindex (inf
);
932 printf ("%8.8lx %8.8lx ",
933 (unsigned long) offset
& 0xffffffff,
934 (unsigned long) inf
& 0xffffffff);
938 #if BFD_HOST_64BIT_LONG
940 ? "%16.16lx %16.16lx "
941 : "%12.12lx %12.12lx ",
943 #elif BFD_HOST_64BIT_LONG_LONG
946 ? "%16.16llx %16.16llx "
947 : "%12.12llx %12.12llx ",
951 ? "%16.16I64x %16.16I64x "
952 : "%12.12I64x %12.12I64x ",
957 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
958 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
959 _bfd_int64_high (offset
),
960 _bfd_int64_low (offset
),
961 _bfd_int64_high (inf
),
962 _bfd_int64_low (inf
));
966 switch (elf_header
.e_machine
)
974 rtype
= elf_m32r_reloc_type (type
);
979 rtype
= elf_i386_reloc_type (type
);
984 rtype
= elf_m68hc11_reloc_type (type
);
988 rtype
= elf_m68k_reloc_type (type
);
992 rtype
= elf_i960_reloc_type (type
);
997 rtype
= elf_avr_reloc_type (type
);
1000 case EM_OLD_SPARCV9
:
1001 case EM_SPARC32PLUS
:
1004 rtype
= elf_sparc_reloc_type (type
);
1008 rtype
= elf_spu_reloc_type (type
);
1012 case EM_CYGNUS_V850
:
1013 rtype
= v850_reloc_type (type
);
1017 case EM_CYGNUS_D10V
:
1018 rtype
= elf_d10v_reloc_type (type
);
1022 case EM_CYGNUS_D30V
:
1023 rtype
= elf_d30v_reloc_type (type
);
1027 rtype
= elf_dlx_reloc_type (type
);
1031 rtype
= elf_sh_reloc_type (type
);
1035 case EM_CYGNUS_MN10300
:
1036 rtype
= elf_mn10300_reloc_type (type
);
1040 case EM_CYGNUS_MN10200
:
1041 rtype
= elf_mn10200_reloc_type (type
);
1045 case EM_CYGNUS_FR30
:
1046 rtype
= elf_fr30_reloc_type (type
);
1050 rtype
= elf_frv_reloc_type (type
);
1054 rtype
= elf_mcore_reloc_type (type
);
1058 rtype
= elf_mmix_reloc_type (type
);
1062 rtype
= elf_moxie_reloc_type (type
);
1067 rtype
= elf_msp430_reloc_type (type
);
1071 rtype
= elf_ppc_reloc_type (type
);
1075 rtype
= elf_ppc64_reloc_type (type
);
1079 case EM_MIPS_RS3_LE
:
1080 rtype
= elf_mips_reloc_type (type
);
1084 rtype
= elf_alpha_reloc_type (type
);
1088 rtype
= elf_arm_reloc_type (type
);
1092 rtype
= elf_arc_reloc_type (type
);
1096 rtype
= elf_hppa_reloc_type (type
);
1102 rtype
= elf_h8_reloc_type (type
);
1107 rtype
= elf_or32_reloc_type (type
);
1112 rtype
= elf_pj_reloc_type (type
);
1115 rtype
= elf_ia64_reloc_type (type
);
1119 rtype
= elf_cris_reloc_type (type
);
1123 rtype
= elf_i860_reloc_type (type
);
1128 rtype
= elf_x86_64_reloc_type (type
);
1132 rtype
= i370_reloc_type (type
);
1137 rtype
= elf_s390_reloc_type (type
);
1141 rtype
= elf_score_reloc_type (type
);
1145 rtype
= elf_xstormy16_reloc_type (type
);
1149 rtype
= elf_crx_reloc_type (type
);
1153 rtype
= elf_vax_reloc_type (type
);
1158 rtype
= elf_ip2k_reloc_type (type
);
1162 rtype
= elf_iq2000_reloc_type (type
);
1167 rtype
= elf_xtensa_reloc_type (type
);
1170 case EM_LATTICEMICO32
:
1171 rtype
= elf_lm32_reloc_type (type
);
1176 rtype
= elf_m32c_reloc_type (type
);
1180 rtype
= elf_mt_reloc_type (type
);
1184 rtype
= elf_bfin_reloc_type (type
);
1188 rtype
= elf_mep_reloc_type (type
);
1193 rtype
= elf_cr16_reloc_type (type
);
1197 case EM_MICROBLAZE_OLD
:
1198 rtype
= elf_microblaze_reloc_type (type
);
1202 rtype
= elf_rx_reloc_type (type
);
1207 rtype
= elf_xc16x_reloc_type (type
);
1211 rtype
= elf_tic6x_reloc_type (type
);
1216 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1218 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1220 if (elf_header
.e_machine
== EM_ALPHA
1222 && streq (rtype
, "R_ALPHA_LITUSE")
1225 switch (rels
[i
].r_addend
)
1227 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1228 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1229 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1230 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1231 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1232 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1233 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1234 default: rtype
= NULL
;
1237 printf (" (%s)", rtype
);
1241 printf (_("<unknown addend: %lx>"),
1242 (unsigned long) rels
[i
].r_addend
);
1245 else if (symtab_index
)
1247 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1248 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1251 Elf_Internal_Sym
* psym
;
1253 psym
= symtab
+ symtab_index
;
1257 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1261 unsigned int width
= is_32bit_elf
? 8 : 14;
1263 /* Relocations against GNU_IFUNC symbols do not use the value
1264 of the symbol as the address to relocate against. Instead
1265 they invoke the function named by the symbol and use its
1266 result as the address for relocation.
1268 To indicate this to the user, do not display the value of
1269 the symbol in the "Symbols's Value" field. Instead show
1270 its name followed by () as a hint that the symbol is
1274 || psym
->st_name
== 0
1275 || psym
->st_name
>= strtablen
)
1278 name
= strtab
+ psym
->st_name
;
1280 len
= print_symbol (width
, name
);
1281 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1285 print_vma (psym
->st_value
, LONG_HEX
);
1287 printf (is_32bit_elf
? " " : " ");
1290 if (psym
->st_name
== 0)
1292 const char * sec_name
= "<null>";
1295 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1297 if (psym
->st_shndx
< elf_header
.e_shnum
)
1299 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1300 else if (psym
->st_shndx
== SHN_ABS
)
1302 else if (psym
->st_shndx
== SHN_COMMON
)
1303 sec_name
= "COMMON";
1304 else if (elf_header
.e_machine
== EM_MIPS
1305 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1306 sec_name
= "SCOMMON";
1307 else if (elf_header
.e_machine
== EM_MIPS
1308 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1309 sec_name
= "SUNDEF";
1310 else if ((elf_header
.e_machine
== EM_X86_64
1311 || elf_header
.e_machine
== EM_L1OM
)
1312 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1313 sec_name
= "LARGE_COMMON";
1314 else if (elf_header
.e_machine
== EM_IA_64
1315 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1316 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1317 sec_name
= "ANSI_COM";
1318 else if (is_ia64_vms ()
1319 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1320 sec_name
= "VMS_SYMVEC";
1323 sprintf (name_buf
, "<section 0x%x>",
1324 (unsigned int) psym
->st_shndx
);
1325 sec_name
= name_buf
;
1328 print_symbol (22, sec_name
);
1330 else if (strtab
== NULL
)
1331 printf (_("<string table index: %3ld>"), psym
->st_name
);
1332 else if (psym
->st_name
>= strtablen
)
1333 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1335 print_symbol (22, strtab
+ psym
->st_name
);
1339 bfd_signed_vma off
= rels
[i
].r_addend
;
1342 printf (" - %" BFD_VMA_FMT
"x", - off
);
1344 printf (" + %" BFD_VMA_FMT
"x", off
);
1350 printf ("%*c", is_32bit_elf
?
1351 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1352 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1355 if (elf_header
.e_machine
== EM_SPARCV9
1357 && streq (rtype
, "R_SPARC_OLO10"))
1358 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1363 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1365 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1366 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1367 const char * rtype2
= elf_mips_reloc_type (type2
);
1368 const char * rtype3
= elf_mips_reloc_type (type3
);
1370 printf (" Type2: ");
1373 printf (_("unrecognized: %-7lx"),
1374 (unsigned long) type2
& 0xffffffff);
1376 printf ("%-17.17s", rtype2
);
1378 printf ("\n Type3: ");
1381 printf (_("unrecognized: %-7lx"),
1382 (unsigned long) type3
& 0xffffffff);
1384 printf ("%-17.17s", rtype3
);
1395 get_mips_dynamic_type (unsigned long type
)
1399 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1400 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1401 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1402 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1403 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1404 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1405 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1406 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1407 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1408 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1409 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1410 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1411 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1412 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1413 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1414 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1415 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1416 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1417 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1418 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1419 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1420 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1421 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1422 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1423 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1424 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1425 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1426 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1427 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1428 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1429 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1430 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1431 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1432 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1433 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1434 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1435 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1436 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1437 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1438 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1439 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1440 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1441 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1442 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1443 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1450 get_sparc64_dynamic_type (unsigned long type
)
1454 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1461 get_ppc_dynamic_type (unsigned long type
)
1465 case DT_PPC_GOT
: return "PPC_GOT";
1466 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1473 get_ppc64_dynamic_type (unsigned long type
)
1477 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1478 case DT_PPC64_OPD
: return "PPC64_OPD";
1479 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1480 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1487 get_parisc_dynamic_type (unsigned long type
)
1491 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1492 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1493 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1494 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1495 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1496 case DT_HP_PREINIT
: return "HP_PREINIT";
1497 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1498 case DT_HP_NEEDED
: return "HP_NEEDED";
1499 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1500 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1501 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1502 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1503 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1504 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1505 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1506 case DT_HP_FILTERED
: return "HP_FILTERED";
1507 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1508 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1509 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1510 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1511 case DT_PLT
: return "PLT";
1512 case DT_PLT_SIZE
: return "PLT_SIZE";
1513 case DT_DLT
: return "DLT";
1514 case DT_DLT_SIZE
: return "DLT_SIZE";
1521 get_ia64_dynamic_type (unsigned long type
)
1525 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1526 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1527 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1528 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1529 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1530 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1531 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1532 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1533 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1534 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1535 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1536 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1537 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1538 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1539 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1540 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1541 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1542 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1543 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1544 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1545 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1546 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1547 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1548 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1549 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1550 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1551 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1552 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1553 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1554 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1555 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1562 get_alpha_dynamic_type (unsigned long type
)
1566 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1573 get_score_dynamic_type (unsigned long type
)
1577 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1578 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1579 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1580 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1581 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1582 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1589 get_tic6x_dynamic_type (unsigned long type
)
1593 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1594 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1595 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1596 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1597 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1598 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1605 get_dynamic_type (unsigned long type
)
1607 static char buff
[64];
1611 case DT_NULL
: return "NULL";
1612 case DT_NEEDED
: return "NEEDED";
1613 case DT_PLTRELSZ
: return "PLTRELSZ";
1614 case DT_PLTGOT
: return "PLTGOT";
1615 case DT_HASH
: return "HASH";
1616 case DT_STRTAB
: return "STRTAB";
1617 case DT_SYMTAB
: return "SYMTAB";
1618 case DT_RELA
: return "RELA";
1619 case DT_RELASZ
: return "RELASZ";
1620 case DT_RELAENT
: return "RELAENT";
1621 case DT_STRSZ
: return "STRSZ";
1622 case DT_SYMENT
: return "SYMENT";
1623 case DT_INIT
: return "INIT";
1624 case DT_FINI
: return "FINI";
1625 case DT_SONAME
: return "SONAME";
1626 case DT_RPATH
: return "RPATH";
1627 case DT_SYMBOLIC
: return "SYMBOLIC";
1628 case DT_REL
: return "REL";
1629 case DT_RELSZ
: return "RELSZ";
1630 case DT_RELENT
: return "RELENT";
1631 case DT_PLTREL
: return "PLTREL";
1632 case DT_DEBUG
: return "DEBUG";
1633 case DT_TEXTREL
: return "TEXTREL";
1634 case DT_JMPREL
: return "JMPREL";
1635 case DT_BIND_NOW
: return "BIND_NOW";
1636 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1637 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1638 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1639 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1640 case DT_RUNPATH
: return "RUNPATH";
1641 case DT_FLAGS
: return "FLAGS";
1643 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1644 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1646 case DT_CHECKSUM
: return "CHECKSUM";
1647 case DT_PLTPADSZ
: return "PLTPADSZ";
1648 case DT_MOVEENT
: return "MOVEENT";
1649 case DT_MOVESZ
: return "MOVESZ";
1650 case DT_FEATURE
: return "FEATURE";
1651 case DT_POSFLAG_1
: return "POSFLAG_1";
1652 case DT_SYMINSZ
: return "SYMINSZ";
1653 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1655 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1656 case DT_CONFIG
: return "CONFIG";
1657 case DT_DEPAUDIT
: return "DEPAUDIT";
1658 case DT_AUDIT
: return "AUDIT";
1659 case DT_PLTPAD
: return "PLTPAD";
1660 case DT_MOVETAB
: return "MOVETAB";
1661 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1663 case DT_VERSYM
: return "VERSYM";
1665 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1666 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1667 case DT_RELACOUNT
: return "RELACOUNT";
1668 case DT_RELCOUNT
: return "RELCOUNT";
1669 case DT_FLAGS_1
: return "FLAGS_1";
1670 case DT_VERDEF
: return "VERDEF";
1671 case DT_VERDEFNUM
: return "VERDEFNUM";
1672 case DT_VERNEED
: return "VERNEED";
1673 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1675 case DT_AUXILIARY
: return "AUXILIARY";
1676 case DT_USED
: return "USED";
1677 case DT_FILTER
: return "FILTER";
1679 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1680 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1681 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1682 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1683 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1684 case DT_GNU_HASH
: return "GNU_HASH";
1687 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1689 const char * result
;
1691 switch (elf_header
.e_machine
)
1694 case EM_MIPS_RS3_LE
:
1695 result
= get_mips_dynamic_type (type
);
1698 result
= get_sparc64_dynamic_type (type
);
1701 result
= get_ppc_dynamic_type (type
);
1704 result
= get_ppc64_dynamic_type (type
);
1707 result
= get_ia64_dynamic_type (type
);
1710 result
= get_alpha_dynamic_type (type
);
1713 result
= get_score_dynamic_type (type
);
1716 result
= get_tic6x_dynamic_type (type
);
1726 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1728 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1729 || (elf_header
.e_machine
== EM_PARISC
1730 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1732 const char * result
;
1734 switch (elf_header
.e_machine
)
1737 result
= get_parisc_dynamic_type (type
);
1740 result
= get_ia64_dynamic_type (type
);
1750 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1754 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1761 get_file_type (unsigned e_type
)
1763 static char buff
[32];
1767 case ET_NONE
: return _("NONE (None)");
1768 case ET_REL
: return _("REL (Relocatable file)");
1769 case ET_EXEC
: return _("EXEC (Executable file)");
1770 case ET_DYN
: return _("DYN (Shared object file)");
1771 case ET_CORE
: return _("CORE (Core file)");
1774 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1775 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1776 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1777 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1779 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1785 get_machine_name (unsigned e_machine
)
1787 static char buff
[64]; /* XXX */
1791 case EM_NONE
: return _("None");
1792 case EM_M32
: return "WE32100";
1793 case EM_SPARC
: return "Sparc";
1794 case EM_SPU
: return "SPU";
1795 case EM_386
: return "Intel 80386";
1796 case EM_68K
: return "MC68000";
1797 case EM_88K
: return "MC88000";
1798 case EM_486
: return "Intel 80486";
1799 case EM_860
: return "Intel 80860";
1800 case EM_MIPS
: return "MIPS R3000";
1801 case EM_S370
: return "IBM System/370";
1802 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1803 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1804 case EM_PARISC
: return "HPPA";
1805 case EM_PPC_OLD
: return "Power PC (old)";
1806 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1807 case EM_960
: return "Intel 90860";
1808 case EM_PPC
: return "PowerPC";
1809 case EM_PPC64
: return "PowerPC64";
1810 case EM_V800
: return "NEC V800";
1811 case EM_FR20
: return "Fujitsu FR20";
1812 case EM_RH32
: return "TRW RH32";
1813 case EM_MCORE
: return "MCORE";
1814 case EM_ARM
: return "ARM";
1815 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1816 case EM_SH
: return "Renesas / SuperH SH";
1817 case EM_SPARCV9
: return "Sparc v9";
1818 case EM_TRICORE
: return "Siemens Tricore";
1819 case EM_ARC
: return "ARC";
1820 case EM_H8_300
: return "Renesas H8/300";
1821 case EM_H8_300H
: return "Renesas H8/300H";
1822 case EM_H8S
: return "Renesas H8S";
1823 case EM_H8_500
: return "Renesas H8/500";
1824 case EM_IA_64
: return "Intel IA-64";
1825 case EM_MIPS_X
: return "Stanford MIPS-X";
1826 case EM_COLDFIRE
: return "Motorola Coldfire";
1827 case EM_68HC12
: return "Motorola M68HC12";
1828 case EM_ALPHA
: return "Alpha";
1829 case EM_CYGNUS_D10V
:
1830 case EM_D10V
: return "d10v";
1831 case EM_CYGNUS_D30V
:
1832 case EM_D30V
: return "d30v";
1833 case EM_CYGNUS_M32R
:
1834 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1835 case EM_CYGNUS_V850
:
1836 case EM_V850
: return "NEC v850";
1837 case EM_CYGNUS_MN10300
:
1838 case EM_MN10300
: return "mn10300";
1839 case EM_CYGNUS_MN10200
:
1840 case EM_MN10200
: return "mn10200";
1841 case EM_MOXIE
: return "Moxie";
1842 case EM_CYGNUS_FR30
:
1843 case EM_FR30
: return "Fujitsu FR30";
1844 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1846 case EM_PJ
: return "picoJava";
1847 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1848 case EM_PCP
: return "Siemens PCP";
1849 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1850 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1851 case EM_STARCORE
: return "Motorola Star*Core processor";
1852 case EM_ME16
: return "Toyota ME16 processor";
1853 case EM_ST100
: return "STMicroelectronics ST100 processor";
1854 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1855 case EM_PDSP
: return "Sony DSP processor";
1856 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1857 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1858 case EM_FX66
: return "Siemens FX66 microcontroller";
1859 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1860 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1861 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1862 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1863 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1864 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1865 case EM_SVX
: return "Silicon Graphics SVx";
1866 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1867 case EM_VAX
: return "Digital VAX";
1869 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1870 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1871 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1872 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1873 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1874 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1875 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1876 case EM_PRISM
: return "Vitesse Prism";
1877 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1878 case EM_L1OM
: return "Intel L1OM";
1880 case EM_S390
: return "IBM S/390";
1881 case EM_SCORE
: return "SUNPLUS S+Core";
1882 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1884 case EM_OR32
: return "OpenRISC";
1885 case EM_ARC_A5
: return "ARC International ARCompact processor";
1886 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1887 case EM_DLX
: return "OpenDLX";
1889 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1890 case EM_IQ2000
: return "Vitesse IQ2000";
1892 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1893 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1894 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1895 case EM_NS32K
: return "National Semiconductor 32000 series";
1896 case EM_TPC
: return "Tenor Network TPC processor";
1897 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1898 case EM_MAX
: return "MAX Processor";
1899 case EM_CR
: return "National Semiconductor CompactRISC";
1900 case EM_F2MC16
: return "Fujitsu F2MC16";
1901 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1902 case EM_LATTICEMICO32
: return "Lattice Mico32";
1904 case EM_M32C
: return "Renesas M32c";
1905 case EM_MT
: return "Morpho Techologies MT processor";
1906 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1907 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1908 case EM_SEP
: return "Sharp embedded microprocessor";
1909 case EM_ARCA
: return "Arca RISC microprocessor";
1910 case EM_UNICORE
: return "Unicore";
1911 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1912 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1913 case EM_NIOS32
: return "Altera Nios";
1914 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1916 case EM_XC16X
: return "Infineon Technologies xc16x";
1917 case EM_M16C
: return "Renesas M16C series microprocessors";
1918 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1919 case EM_CE
: return "Freescale Communication Engine RISC core";
1920 case EM_TSK3000
: return "Altium TSK3000 core";
1921 case EM_RS08
: return "Freescale RS08 embedded processor";
1922 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1923 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1924 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1925 case EM_SE_C17
: return "Seiko Epson C17 family";
1926 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1927 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1928 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1929 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1930 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1931 case EM_R32C
: return "Renesas R32C series microprocessors";
1932 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1933 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1934 case EM_8051
: return "Intel 8051 and variants";
1935 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1936 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1937 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1938 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1939 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1940 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1941 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
1942 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1944 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1945 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1946 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1947 case EM_RX
: return "Renesas RX";
1948 case EM_METAG
: return "Imagination Technologies META processor architecture";
1949 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
1950 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
1951 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
1952 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
1953 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
1954 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
1955 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
1956 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
1957 case EM_CUDA
: return "NVIDIA CUDA architecture";
1959 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1965 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1970 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1971 e_flags
&= ~ EF_ARM_EABIMASK
;
1973 /* Handle "generic" ARM flags. */
1974 if (e_flags
& EF_ARM_RELEXEC
)
1976 strcat (buf
, ", relocatable executable");
1977 e_flags
&= ~ EF_ARM_RELEXEC
;
1980 if (e_flags
& EF_ARM_HASENTRY
)
1982 strcat (buf
, ", has entry point");
1983 e_flags
&= ~ EF_ARM_HASENTRY
;
1986 /* Now handle EABI specific flags. */
1990 strcat (buf
, ", <unrecognized EABI>");
1995 case EF_ARM_EABI_VER1
:
1996 strcat (buf
, ", Version1 EABI");
2001 /* Process flags one bit at a time. */
2002 flag
= e_flags
& - e_flags
;
2007 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2008 strcat (buf
, ", sorted symbol tables");
2018 case EF_ARM_EABI_VER2
:
2019 strcat (buf
, ", Version2 EABI");
2024 /* Process flags one bit at a time. */
2025 flag
= e_flags
& - e_flags
;
2030 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2031 strcat (buf
, ", sorted symbol tables");
2034 case EF_ARM_DYNSYMSUSESEGIDX
:
2035 strcat (buf
, ", dynamic symbols use segment index");
2038 case EF_ARM_MAPSYMSFIRST
:
2039 strcat (buf
, ", mapping symbols precede others");
2049 case EF_ARM_EABI_VER3
:
2050 strcat (buf
, ", Version3 EABI");
2053 case EF_ARM_EABI_VER4
:
2054 strcat (buf
, ", Version4 EABI");
2057 case EF_ARM_EABI_VER5
:
2058 strcat (buf
, ", Version5 EABI");
2064 /* Process flags one bit at a time. */
2065 flag
= e_flags
& - e_flags
;
2071 strcat (buf
, ", BE8");
2075 strcat (buf
, ", LE8");
2085 case EF_ARM_EABI_UNKNOWN
:
2086 strcat (buf
, ", GNU EABI");
2091 /* Process flags one bit at a time. */
2092 flag
= e_flags
& - e_flags
;
2097 case EF_ARM_INTERWORK
:
2098 strcat (buf
, ", interworking enabled");
2101 case EF_ARM_APCS_26
:
2102 strcat (buf
, ", uses APCS/26");
2105 case EF_ARM_APCS_FLOAT
:
2106 strcat (buf
, ", uses APCS/float");
2110 strcat (buf
, ", position independent");
2114 strcat (buf
, ", 8 bit structure alignment");
2117 case EF_ARM_NEW_ABI
:
2118 strcat (buf
, ", uses new ABI");
2121 case EF_ARM_OLD_ABI
:
2122 strcat (buf
, ", uses old ABI");
2125 case EF_ARM_SOFT_FLOAT
:
2126 strcat (buf
, ", software FP");
2129 case EF_ARM_VFP_FLOAT
:
2130 strcat (buf
, ", VFP");
2133 case EF_ARM_MAVERICK_FLOAT
:
2134 strcat (buf
, ", Maverick FP");
2145 strcat (buf
,_(", <unknown>"));
2149 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2151 static char buf
[1024];
2163 decode_ARM_machine_flags (e_flags
, buf
);
2167 if (e_flags
& EF_BFIN_PIC
)
2168 strcat (buf
, ", PIC");
2170 if (e_flags
& EF_BFIN_FDPIC
)
2171 strcat (buf
, ", FDPIC");
2173 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2174 strcat (buf
, ", code in L1");
2176 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2177 strcat (buf
, ", data in L1");
2182 switch (e_flags
& EF_FRV_CPU_MASK
)
2184 case EF_FRV_CPU_GENERIC
:
2188 strcat (buf
, ", fr???");
2191 case EF_FRV_CPU_FR300
:
2192 strcat (buf
, ", fr300");
2195 case EF_FRV_CPU_FR400
:
2196 strcat (buf
, ", fr400");
2198 case EF_FRV_CPU_FR405
:
2199 strcat (buf
, ", fr405");
2202 case EF_FRV_CPU_FR450
:
2203 strcat (buf
, ", fr450");
2206 case EF_FRV_CPU_FR500
:
2207 strcat (buf
, ", fr500");
2209 case EF_FRV_CPU_FR550
:
2210 strcat (buf
, ", fr550");
2213 case EF_FRV_CPU_SIMPLE
:
2214 strcat (buf
, ", simple");
2216 case EF_FRV_CPU_TOMCAT
:
2217 strcat (buf
, ", tomcat");
2223 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2224 strcat (buf
, ", m68000");
2225 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2226 strcat (buf
, ", cpu32");
2227 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2228 strcat (buf
, ", fido_a");
2231 char const * isa
= _("unknown");
2232 char const * mac
= _("unknown mac");
2233 char const * additional
= NULL
;
2235 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2237 case EF_M68K_CF_ISA_A_NODIV
:
2239 additional
= ", nodiv";
2241 case EF_M68K_CF_ISA_A
:
2244 case EF_M68K_CF_ISA_A_PLUS
:
2247 case EF_M68K_CF_ISA_B_NOUSP
:
2249 additional
= ", nousp";
2251 case EF_M68K_CF_ISA_B
:
2254 case EF_M68K_CF_ISA_C
:
2257 case EF_M68K_CF_ISA_C_NODIV
:
2259 additional
= ", nodiv";
2262 strcat (buf
, ", cf, isa ");
2265 strcat (buf
, additional
);
2266 if (e_flags
& EF_M68K_CF_FLOAT
)
2267 strcat (buf
, ", float");
2268 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2273 case EF_M68K_CF_MAC
:
2276 case EF_M68K_CF_EMAC
:
2279 case EF_M68K_CF_EMAC_B
:
2292 if (e_flags
& EF_PPC_EMB
)
2293 strcat (buf
, ", emb");
2295 if (e_flags
& EF_PPC_RELOCATABLE
)
2296 strcat (buf
, _(", relocatable"));
2298 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2299 strcat (buf
, _(", relocatable-lib"));
2303 case EM_CYGNUS_V850
:
2304 switch (e_flags
& EF_V850_ARCH
)
2306 case E_V850E2V3_ARCH
:
2307 strcat (buf
, ", v850e2v3");
2310 strcat (buf
, ", v850e2");
2313 strcat (buf
, ", v850e1");
2316 strcat (buf
, ", v850e");
2319 strcat (buf
, ", v850");
2322 strcat (buf
, _(", unknown v850 architecture variant"));
2328 case EM_CYGNUS_M32R
:
2329 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2330 strcat (buf
, ", m32r");
2334 case EM_MIPS_RS3_LE
:
2335 if (e_flags
& EF_MIPS_NOREORDER
)
2336 strcat (buf
, ", noreorder");
2338 if (e_flags
& EF_MIPS_PIC
)
2339 strcat (buf
, ", pic");
2341 if (e_flags
& EF_MIPS_CPIC
)
2342 strcat (buf
, ", cpic");
2344 if (e_flags
& EF_MIPS_UCODE
)
2345 strcat (buf
, ", ugen_reserved");
2347 if (e_flags
& EF_MIPS_ABI2
)
2348 strcat (buf
, ", abi2");
2350 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2351 strcat (buf
, ", odk first");
2353 if (e_flags
& EF_MIPS_32BITMODE
)
2354 strcat (buf
, ", 32bitmode");
2356 switch ((e_flags
& EF_MIPS_MACH
))
2358 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2359 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2360 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2361 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2362 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2363 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2364 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2365 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2366 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2367 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2368 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2369 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2370 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2371 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2372 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2373 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2375 /* We simply ignore the field in this case to avoid confusion:
2376 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2379 default: strcat (buf
, _(", unknown CPU")); break;
2382 switch ((e_flags
& EF_MIPS_ABI
))
2384 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2385 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2386 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2387 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2389 /* We simply ignore the field in this case to avoid confusion:
2390 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2391 This means it is likely to be an o32 file, but not for
2394 default: strcat (buf
, _(", unknown ABI")); break;
2397 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2398 strcat (buf
, ", mdmx");
2400 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2401 strcat (buf
, ", mips16");
2403 switch ((e_flags
& EF_MIPS_ARCH
))
2405 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2406 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2407 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2408 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2409 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2410 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2411 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2412 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2413 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2414 default: strcat (buf
, _(", unknown ISA")); break;
2417 if (e_flags
& EF_SH_PIC
)
2418 strcat (buf
, ", pic");
2420 if (e_flags
& EF_SH_FDPIC
)
2421 strcat (buf
, ", fdpic");
2425 switch ((e_flags
& EF_SH_MACH_MASK
))
2427 case EF_SH1
: strcat (buf
, ", sh1"); break;
2428 case EF_SH2
: strcat (buf
, ", sh2"); break;
2429 case EF_SH3
: strcat (buf
, ", sh3"); break;
2430 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2431 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2432 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2433 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2434 case EF_SH4
: strcat (buf
, ", sh4"); break;
2435 case EF_SH5
: strcat (buf
, ", sh5"); break;
2436 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2437 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2438 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2439 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2440 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2441 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2442 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2443 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2444 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2445 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2446 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2447 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2448 default: strcat (buf
, _(", unknown ISA")); break;
2454 if (e_flags
& EF_SPARC_32PLUS
)
2455 strcat (buf
, ", v8+");
2457 if (e_flags
& EF_SPARC_SUN_US1
)
2458 strcat (buf
, ", ultrasparcI");
2460 if (e_flags
& EF_SPARC_SUN_US3
)
2461 strcat (buf
, ", ultrasparcIII");
2463 if (e_flags
& EF_SPARC_HAL_R1
)
2464 strcat (buf
, ", halr1");
2466 if (e_flags
& EF_SPARC_LEDATA
)
2467 strcat (buf
, ", ledata");
2469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2470 strcat (buf
, ", tso");
2472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2473 strcat (buf
, ", pso");
2475 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2476 strcat (buf
, ", rmo");
2480 switch (e_flags
& EF_PARISC_ARCH
)
2482 case EFA_PARISC_1_0
:
2483 strcpy (buf
, ", PA-RISC 1.0");
2485 case EFA_PARISC_1_1
:
2486 strcpy (buf
, ", PA-RISC 1.1");
2488 case EFA_PARISC_2_0
:
2489 strcpy (buf
, ", PA-RISC 2.0");
2494 if (e_flags
& EF_PARISC_TRAPNIL
)
2495 strcat (buf
, ", trapnil");
2496 if (e_flags
& EF_PARISC_EXT
)
2497 strcat (buf
, ", ext");
2498 if (e_flags
& EF_PARISC_LSB
)
2499 strcat (buf
, ", lsb");
2500 if (e_flags
& EF_PARISC_WIDE
)
2501 strcat (buf
, ", wide");
2502 if (e_flags
& EF_PARISC_NO_KABP
)
2503 strcat (buf
, ", no kabp");
2504 if (e_flags
& EF_PARISC_LAZYSWAP
)
2505 strcat (buf
, ", lazyswap");
2510 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2511 strcat (buf
, ", new calling convention");
2513 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2514 strcat (buf
, ", gnu calling convention");
2518 if ((e_flags
& EF_IA_64_ABI64
))
2519 strcat (buf
, ", 64-bit");
2521 strcat (buf
, ", 32-bit");
2522 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2523 strcat (buf
, ", reduced fp model");
2524 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2525 strcat (buf
, ", no function descriptors, constant gp");
2526 else if ((e_flags
& EF_IA_64_CONS_GP
))
2527 strcat (buf
, ", constant gp");
2528 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2529 strcat (buf
, ", absolute");
2530 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2532 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2533 strcat (buf
, ", vms_linkages");
2534 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2536 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2538 case EF_IA_64_VMS_COMCOD_WARNING
:
2539 strcat (buf
, ", warning");
2541 case EF_IA_64_VMS_COMCOD_ERROR
:
2542 strcat (buf
, ", error");
2544 case EF_IA_64_VMS_COMCOD_ABORT
:
2545 strcat (buf
, ", abort");
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 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3146 Display the contents of DWARF2 debug sections\n"));
3147 #ifdef SUPPORT_DISASSEMBLY
3148 fprintf (stream
, _("\
3149 -i --instruction-dump=<number|name>\n\
3150 Disassemble the contents of section <number|name>\n"));
3152 fprintf (stream
, _("\
3153 -I --histogram Display histogram of bucket list lengths\n\
3154 -W --wide Allow output width to exceed 80 characters\n\
3155 @<file> Read options from <file>\n\
3156 -H --help Display this information\n\
3157 -v --version Display the version number of readelf\n"));
3159 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3160 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3162 exit (stream
== stdout
? 0 : 1);
3165 /* Record the fact that the user wants the contents of section number
3166 SECTION to be displayed using the method(s) encoded as flags bits
3167 in TYPE. Note, TYPE can be zero if we are creating the array for
3171 request_dump_bynumber (unsigned int section
, dump_type type
)
3173 if (section
>= num_dump_sects
)
3175 dump_type
* new_dump_sects
;
3177 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3178 sizeof (* dump_sects
));
3180 if (new_dump_sects
== NULL
)
3181 error (_("Out of memory allocating dump request table.\n"));
3184 /* Copy current flag settings. */
3185 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3189 dump_sects
= new_dump_sects
;
3190 num_dump_sects
= section
+ 1;
3195 dump_sects
[section
] |= type
;
3200 /* Request a dump by section name. */
3203 request_dump_byname (const char * section
, dump_type type
)
3205 struct dump_list_entry
* new_request
;
3207 new_request
= (struct dump_list_entry
*)
3208 malloc (sizeof (struct dump_list_entry
));
3210 error (_("Out of memory allocating dump request table.\n"));
3212 new_request
->name
= strdup (section
);
3213 if (!new_request
->name
)
3214 error (_("Out of memory allocating dump request table.\n"));
3216 new_request
->type
= type
;
3218 new_request
->next
= dump_sects_byname
;
3219 dump_sects_byname
= new_request
;
3223 request_dump (dump_type type
)
3229 section
= strtoul (optarg
, & cp
, 0);
3231 if (! *cp
&& section
>= 0)
3232 request_dump_bynumber (section
, type
);
3234 request_dump_byname (optarg
, type
);
3239 parse_args (int argc
, char ** argv
)
3246 while ((c
= getopt_long
3247 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3265 do_section_groups
++;
3273 do_section_groups
++;
3278 do_section_details
++;
3322 request_dump (HEX_DUMP
);
3325 request_dump (STRING_DUMP
);
3328 request_dump (RELOC_DUMP
);
3335 dwarf_select_sections_all ();
3340 dwarf_select_sections_by_letters (optarg
);
3343 case OPTION_DEBUG_DUMP
:
3350 dwarf_select_sections_by_names (optarg
);
3353 case OPTION_DYN_SYMS
:
3356 #ifdef SUPPORT_DISASSEMBLY
3358 request_dump (DISASS_DUMP
);
3362 print_version (program_name
);
3371 /* xgettext:c-format */
3372 error (_("Invalid option '-%c'\n"), c
);
3379 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3380 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3381 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3382 && !do_section_groups
&& !do_archive_index
3387 warn (_("Nothing to do.\n"));
3393 get_elf_class (unsigned int elf_class
)
3395 static char buff
[32];
3399 case ELFCLASSNONE
: return _("none");
3400 case ELFCLASS32
: return "ELF32";
3401 case ELFCLASS64
: return "ELF64";
3403 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3409 get_data_encoding (unsigned int encoding
)
3411 static char buff
[32];
3415 case ELFDATANONE
: return _("none");
3416 case ELFDATA2LSB
: return _("2's complement, little endian");
3417 case ELFDATA2MSB
: return _("2's complement, big endian");
3419 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3424 /* Decode the data held in 'elf_header'. */
3427 process_file_header (void)
3429 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3430 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3431 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3432 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3435 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3439 init_dwarf_regnames (elf_header
.e_machine
);
3445 printf (_("ELF Header:\n"));
3446 printf (_(" Magic: "));
3447 for (i
= 0; i
< EI_NIDENT
; i
++)
3448 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3450 printf (_(" Class: %s\n"),
3451 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3452 printf (_(" Data: %s\n"),
3453 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3454 printf (_(" Version: %d %s\n"),
3455 elf_header
.e_ident
[EI_VERSION
],
3456 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3458 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3459 ? _("<unknown: %lx>")
3461 printf (_(" OS/ABI: %s\n"),
3462 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3463 printf (_(" ABI Version: %d\n"),
3464 elf_header
.e_ident
[EI_ABIVERSION
]);
3465 printf (_(" Type: %s\n"),
3466 get_file_type (elf_header
.e_type
));
3467 printf (_(" Machine: %s\n"),
3468 get_machine_name (elf_header
.e_machine
));
3469 printf (_(" Version: 0x%lx\n"),
3470 (unsigned long) elf_header
.e_version
);
3472 printf (_(" Entry point address: "));
3473 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3474 printf (_("\n Start of program headers: "));
3475 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3476 printf (_(" (bytes into file)\n Start of section headers: "));
3477 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3478 printf (_(" (bytes into file)\n"));
3480 printf (_(" Flags: 0x%lx%s\n"),
3481 (unsigned long) elf_header
.e_flags
,
3482 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3483 printf (_(" Size of this header: %ld (bytes)\n"),
3484 (long) elf_header
.e_ehsize
);
3485 printf (_(" Size of program headers: %ld (bytes)\n"),
3486 (long) elf_header
.e_phentsize
);
3487 printf (_(" Number of program headers: %ld"),
3488 (long) elf_header
.e_phnum
);
3489 if (section_headers
!= NULL
3490 && elf_header
.e_phnum
== PN_XNUM
3491 && section_headers
[0].sh_info
!= 0)
3492 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3493 putc ('\n', stdout
);
3494 printf (_(" Size of section headers: %ld (bytes)\n"),
3495 (long) elf_header
.e_shentsize
);
3496 printf (_(" Number of section headers: %ld"),
3497 (long) elf_header
.e_shnum
);
3498 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3499 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3500 putc ('\n', stdout
);
3501 printf (_(" Section header string table index: %ld"),
3502 (long) elf_header
.e_shstrndx
);
3503 if (section_headers
!= NULL
3504 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3505 printf (" (%u)", section_headers
[0].sh_link
);
3506 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3507 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3508 printf (_(" <corrupt: out of range>"));
3509 putc ('\n', stdout
);
3512 if (section_headers
!= NULL
)
3514 if (elf_header
.e_phnum
== PN_XNUM
3515 && section_headers
[0].sh_info
!= 0)
3516 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3517 if (elf_header
.e_shnum
== SHN_UNDEF
)
3518 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3519 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3520 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3521 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3522 elf_header
.e_shstrndx
= SHN_UNDEF
;
3523 free (section_headers
);
3524 section_headers
= NULL
;
3532 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3534 Elf32_External_Phdr
* phdrs
;
3535 Elf32_External_Phdr
* external
;
3536 Elf_Internal_Phdr
* internal
;
3539 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3540 elf_header
.e_phentsize
,
3542 _("program headers"));
3546 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3547 i
< elf_header
.e_phnum
;
3548 i
++, internal
++, external
++)
3550 internal
->p_type
= BYTE_GET (external
->p_type
);
3551 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3552 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3553 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3554 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3555 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3556 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3557 internal
->p_align
= BYTE_GET (external
->p_align
);
3566 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3568 Elf64_External_Phdr
* phdrs
;
3569 Elf64_External_Phdr
* external
;
3570 Elf_Internal_Phdr
* internal
;
3573 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3574 elf_header
.e_phentsize
,
3576 _("program headers"));
3580 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3581 i
< elf_header
.e_phnum
;
3582 i
++, internal
++, external
++)
3584 internal
->p_type
= BYTE_GET (external
->p_type
);
3585 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3586 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3587 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3588 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3589 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3590 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3591 internal
->p_align
= BYTE_GET (external
->p_align
);
3599 /* Returns 1 if the program headers were read into `program_headers'. */
3602 get_program_headers (FILE * file
)
3604 Elf_Internal_Phdr
* phdrs
;
3606 /* Check cache of prior read. */
3607 if (program_headers
!= NULL
)
3610 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3611 sizeof (Elf_Internal_Phdr
));
3615 error (_("Out of memory\n"));
3620 ? get_32bit_program_headers (file
, phdrs
)
3621 : get_64bit_program_headers (file
, phdrs
))
3623 program_headers
= phdrs
;
3631 /* Returns 1 if the program headers were loaded. */
3634 process_program_headers (FILE * file
)
3636 Elf_Internal_Phdr
* segment
;
3639 if (elf_header
.e_phnum
== 0)
3641 /* PR binutils/12467. */
3642 if (elf_header
.e_phoff
!= 0)
3643 warn (_("possibly corrupt ELF header - it has a non-zero program"
3644 " header offset, but no program headers"));
3645 else if (do_segments
)
3646 printf (_("\nThere are no program headers in this file.\n"));
3650 if (do_segments
&& !do_header
)
3652 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3653 printf (_("Entry point "));
3654 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3655 printf (_("\nThere are %d program headers, starting at offset "),
3656 elf_header
.e_phnum
);
3657 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3661 if (! get_program_headers (file
))
3666 if (elf_header
.e_phnum
> 1)
3667 printf (_("\nProgram Headers:\n"));
3669 printf (_("\nProgram Headers:\n"));
3673 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3676 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3680 (_(" Type Offset VirtAddr PhysAddr\n"));
3682 (_(" FileSiz MemSiz Flags Align\n"));
3689 for (i
= 0, segment
= program_headers
;
3690 i
< elf_header
.e_phnum
;
3695 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3699 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3700 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3701 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3702 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3703 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3705 (segment
->p_flags
& PF_R
? 'R' : ' '),
3706 (segment
->p_flags
& PF_W
? 'W' : ' '),
3707 (segment
->p_flags
& PF_X
? 'E' : ' '));
3708 printf ("%#lx", (unsigned long) segment
->p_align
);
3712 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3713 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3716 print_vma (segment
->p_offset
, FULL_HEX
);
3720 print_vma (segment
->p_vaddr
, FULL_HEX
);
3722 print_vma (segment
->p_paddr
, FULL_HEX
);
3725 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3726 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3729 print_vma (segment
->p_filesz
, FULL_HEX
);
3733 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3734 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3737 print_vma (segment
->p_offset
, FULL_HEX
);
3741 (segment
->p_flags
& PF_R
? 'R' : ' '),
3742 (segment
->p_flags
& PF_W
? 'W' : ' '),
3743 (segment
->p_flags
& PF_X
? 'E' : ' '));
3745 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3746 printf ("%#lx", (unsigned long) segment
->p_align
);
3749 print_vma (segment
->p_align
, PREFIX_HEX
);
3754 print_vma (segment
->p_offset
, FULL_HEX
);
3756 print_vma (segment
->p_vaddr
, FULL_HEX
);
3758 print_vma (segment
->p_paddr
, FULL_HEX
);
3760 print_vma (segment
->p_filesz
, FULL_HEX
);
3762 print_vma (segment
->p_memsz
, FULL_HEX
);
3764 (segment
->p_flags
& PF_R
? 'R' : ' '),
3765 (segment
->p_flags
& PF_W
? 'W' : ' '),
3766 (segment
->p_flags
& PF_X
? 'E' : ' '));
3767 print_vma (segment
->p_align
, HEX
);
3771 switch (segment
->p_type
)
3775 error (_("more than one dynamic segment\n"));
3777 /* By default, assume that the .dynamic section is the first
3778 section in the DYNAMIC segment. */
3779 dynamic_addr
= segment
->p_offset
;
3780 dynamic_size
= segment
->p_filesz
;
3782 /* Try to locate the .dynamic section. If there is
3783 a section header table, we can easily locate it. */
3784 if (section_headers
!= NULL
)
3786 Elf_Internal_Shdr
* sec
;
3788 sec
= find_section (".dynamic");
3789 if (sec
== NULL
|| sec
->sh_size
== 0)
3791 /* A corresponding .dynamic section is expected, but on
3792 IA-64/OpenVMS it is OK for it to be missing. */
3793 if (!is_ia64_vms ())
3794 error (_("no .dynamic section in the dynamic segment\n"));
3798 if (sec
->sh_type
== SHT_NOBITS
)
3804 dynamic_addr
= sec
->sh_offset
;
3805 dynamic_size
= sec
->sh_size
;
3807 if (dynamic_addr
< segment
->p_offset
3808 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3809 warn (_("the .dynamic section is not contained"
3810 " within the dynamic segment\n"));
3811 else if (dynamic_addr
> segment
->p_offset
)
3812 warn (_("the .dynamic section is not the first section"
3813 " in the dynamic segment.\n"));
3818 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3820 error (_("Unable to find program interpreter name\n"));
3824 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3826 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3827 error (_("Internal error: failed to create format string to display program interpreter\n"));
3829 program_interpreter
[0] = 0;
3830 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3831 error (_("Unable to read program interpreter name\n"));
3834 printf (_("\n [Requesting program interpreter: %s]"),
3835 program_interpreter
);
3841 putc ('\n', stdout
);
3844 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3846 printf (_("\n Section to Segment mapping:\n"));
3847 printf (_(" Segment Sections...\n"));
3849 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3852 Elf_Internal_Shdr
* section
;
3854 segment
= program_headers
+ i
;
3855 section
= section_headers
+ 1;
3857 printf (" %2.2d ", i
);
3859 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3861 if (!ELF_TBSS_SPECIAL (section
, segment
)
3862 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
3863 printf ("%s ", SECTION_NAME (section
));
3874 /* Find the file offset corresponding to VMA by using the program headers. */
3877 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3879 Elf_Internal_Phdr
* seg
;
3881 if (! get_program_headers (file
))
3883 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3887 for (seg
= program_headers
;
3888 seg
< program_headers
+ elf_header
.e_phnum
;
3891 if (seg
->p_type
!= PT_LOAD
)
3894 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3895 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3896 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3899 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3900 (unsigned long) vma
);
3906 get_32bit_section_headers (FILE * file
, unsigned int num
)
3908 Elf32_External_Shdr
* shdrs
;
3909 Elf_Internal_Shdr
* internal
;
3912 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3913 elf_header
.e_shentsize
, num
,
3914 _("section headers"));
3918 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3919 sizeof (Elf_Internal_Shdr
));
3921 if (section_headers
== NULL
)
3923 error (_("Out of memory\n"));
3927 for (i
= 0, internal
= section_headers
;
3931 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3932 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3933 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3934 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3935 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3936 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3937 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3938 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3939 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3940 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3949 get_64bit_section_headers (FILE * file
, unsigned int num
)
3951 Elf64_External_Shdr
* shdrs
;
3952 Elf_Internal_Shdr
* internal
;
3955 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3956 elf_header
.e_shentsize
, num
,
3957 _("section headers"));
3961 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3962 sizeof (Elf_Internal_Shdr
));
3964 if (section_headers
== NULL
)
3966 error (_("Out of memory\n"));
3970 for (i
= 0, internal
= section_headers
;
3974 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3975 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3976 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3977 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3978 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3979 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3980 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3981 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3982 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3983 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3991 static Elf_Internal_Sym
*
3992 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3994 unsigned long number
;
3995 Elf32_External_Sym
* esyms
= NULL
;
3996 Elf_External_Sym_Shndx
* shndx
;
3997 Elf_Internal_Sym
* isyms
= NULL
;
3998 Elf_Internal_Sym
* psym
;
4001 /* Run some sanity checks first. */
4002 if (section
->sh_entsize
== 0)
4004 error (_("sh_entsize is zero\n"));
4008 number
= section
->sh_size
/ section
->sh_entsize
;
4010 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4012 error (_("Invalid sh_entsize\n"));
4016 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4017 section
->sh_size
, _("symbols"));
4022 if (symtab_shndx_hdr
!= NULL
4023 && (symtab_shndx_hdr
->sh_link
4024 == (unsigned long) (section
- section_headers
)))
4026 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4027 symtab_shndx_hdr
->sh_offset
,
4028 1, symtab_shndx_hdr
->sh_size
,
4034 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4038 error (_("Out of memory\n"));
4042 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4044 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4045 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4046 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4047 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4048 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4050 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4051 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4052 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4053 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4054 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4066 static Elf_Internal_Sym
*
4067 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4069 unsigned long number
;
4070 Elf64_External_Sym
* esyms
;
4071 Elf_External_Sym_Shndx
* shndx
;
4072 Elf_Internal_Sym
* isyms
;
4073 Elf_Internal_Sym
* psym
;
4076 /* Run some sanity checks first. */
4077 if (section
->sh_entsize
== 0)
4079 error (_("sh_entsize is zero\n"));
4083 number
= section
->sh_size
/ section
->sh_entsize
;
4085 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4087 error (_("Invalid sh_entsize\n"));
4091 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4092 section
->sh_size
, _("symbols"));
4097 if (symtab_shndx_hdr
!= NULL
4098 && (symtab_shndx_hdr
->sh_link
4099 == (unsigned long) (section
- section_headers
)))
4101 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4102 symtab_shndx_hdr
->sh_offset
,
4103 1, symtab_shndx_hdr
->sh_size
,
4112 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4116 error (_("Out of memory\n"));
4123 for (j
= 0, psym
= isyms
;
4127 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4128 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4129 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4130 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4131 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4133 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4134 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4135 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4136 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4137 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4148 get_elf_section_flags (bfd_vma sh_flags
)
4150 static char buff
[1024];
4152 int field_size
= is_32bit_elf
? 8 : 16;
4154 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4155 bfd_vma os_flags
= 0;
4156 bfd_vma proc_flags
= 0;
4157 bfd_vma unknown_flags
= 0;
4165 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4166 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4167 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4168 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4169 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4170 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4171 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4172 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4173 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4174 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4175 /* IA-64 specific. */
4176 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4177 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4178 /* IA-64 OpenVMS specific. */
4179 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4180 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4181 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4182 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4183 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4184 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4186 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4187 /* SPARC specific. */
4188 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4191 if (do_section_details
)
4193 sprintf (buff
, "[%*.*lx]: ",
4194 field_size
, field_size
, (unsigned long) sh_flags
);
4195 p
+= field_size
+ 4;
4202 flag
= sh_flags
& - sh_flags
;
4205 if (do_section_details
)
4209 case SHF_WRITE
: sindex
= 0; break;
4210 case SHF_ALLOC
: sindex
= 1; break;
4211 case SHF_EXECINSTR
: sindex
= 2; break;
4212 case SHF_MERGE
: sindex
= 3; break;
4213 case SHF_STRINGS
: sindex
= 4; break;
4214 case SHF_INFO_LINK
: sindex
= 5; break;
4215 case SHF_LINK_ORDER
: sindex
= 6; break;
4216 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4217 case SHF_GROUP
: sindex
= 8; break;
4218 case SHF_TLS
: sindex
= 9; break;
4219 case SHF_EXCLUDE
: sindex
= 18; break;
4223 switch (elf_header
.e_machine
)
4226 if (flag
== SHF_IA_64_SHORT
)
4228 else if (flag
== SHF_IA_64_NORECOV
)
4231 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4234 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4235 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4236 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4237 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4238 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4239 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4249 case EM_OLD_SPARCV9
:
4250 case EM_SPARC32PLUS
:
4253 if (flag
== SHF_ORDERED
)
4263 if (p
!= buff
+ field_size
+ 4)
4265 if (size
< (10 + 2))
4272 size
-= flags
[sindex
].len
;
4273 p
= stpcpy (p
, flags
[sindex
].str
);
4275 else if (flag
& SHF_MASKOS
)
4277 else if (flag
& SHF_MASKPROC
)
4280 unknown_flags
|= flag
;
4286 case SHF_WRITE
: *p
= 'W'; break;
4287 case SHF_ALLOC
: *p
= 'A'; break;
4288 case SHF_EXECINSTR
: *p
= 'X'; break;
4289 case SHF_MERGE
: *p
= 'M'; break;
4290 case SHF_STRINGS
: *p
= 'S'; break;
4291 case SHF_INFO_LINK
: *p
= 'I'; break;
4292 case SHF_LINK_ORDER
: *p
= 'L'; break;
4293 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4294 case SHF_GROUP
: *p
= 'G'; break;
4295 case SHF_TLS
: *p
= 'T'; break;
4296 case SHF_EXCLUDE
: *p
= 'E'; break;
4299 if ((elf_header
.e_machine
== EM_X86_64
4300 || elf_header
.e_machine
== EM_L1OM
)
4301 && flag
== SHF_X86_64_LARGE
)
4303 else if (flag
& SHF_MASKOS
)
4306 sh_flags
&= ~ SHF_MASKOS
;
4308 else if (flag
& SHF_MASKPROC
)
4311 sh_flags
&= ~ SHF_MASKPROC
;
4321 if (do_section_details
)
4325 size
-= 5 + field_size
;
4326 if (p
!= buff
+ field_size
+ 4)
4334 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4335 (unsigned long) os_flags
);
4336 p
+= 5 + field_size
;
4340 size
-= 7 + field_size
;
4341 if (p
!= buff
+ field_size
+ 4)
4349 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4350 (unsigned long) proc_flags
);
4351 p
+= 7 + field_size
;
4355 size
-= 10 + field_size
;
4356 if (p
!= buff
+ field_size
+ 4)
4364 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4365 (unsigned long) unknown_flags
);
4366 p
+= 10 + field_size
;
4375 process_section_headers (FILE * file
)
4377 Elf_Internal_Shdr
* section
;
4380 section_headers
= NULL
;
4382 if (elf_header
.e_shnum
== 0)
4384 /* PR binutils/12467. */
4385 if (elf_header
.e_shoff
!= 0)
4386 warn (_("possibly corrupt ELF file header - it has a non-zero"
4387 " section header offset, but no section headers\n"));
4388 else if (do_sections
)
4389 printf (_("\nThere are no sections in this file.\n"));
4394 if (do_sections
&& !do_header
)
4395 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4396 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4400 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4403 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4406 /* Read in the string table, so that we have names to display. */
4407 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4408 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4410 section
= section_headers
+ elf_header
.e_shstrndx
;
4412 if (section
->sh_size
!= 0)
4414 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4415 1, section
->sh_size
,
4418 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4422 /* Scan the sections for the dynamic symbol table
4423 and dynamic string table and debug sections. */
4424 dynamic_symbols
= NULL
;
4425 dynamic_strings
= NULL
;
4426 dynamic_syminfo
= NULL
;
4427 symtab_shndx_hdr
= NULL
;
4429 eh_addr_size
= is_32bit_elf
? 4 : 8;
4430 switch (elf_header
.e_machine
)
4433 case EM_MIPS_RS3_LE
:
4434 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4435 FDE addresses. However, the ABI also has a semi-official ILP32
4436 variant for which the normal FDE address size rules apply.
4438 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4439 section, where XX is the size of longs in bits. Unfortunately,
4440 earlier compilers provided no way of distinguishing ILP32 objects
4441 from LP64 objects, so if there's any doubt, we should assume that
4442 the official LP64 form is being used. */
4443 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4444 && find_section (".gcc_compiled_long32") == NULL
)
4450 switch (elf_header
.e_flags
& EF_H8_MACH
)
4452 case E_H8_MACH_H8300
:
4453 case E_H8_MACH_H8300HN
:
4454 case E_H8_MACH_H8300SN
:
4455 case E_H8_MACH_H8300SXN
:
4458 case E_H8_MACH_H8300H
:
4459 case E_H8_MACH_H8300S
:
4460 case E_H8_MACH_H8300SX
:
4468 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4470 case EF_M32C_CPU_M16C
:
4477 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4480 size_t expected_entsize \
4481 = is_32bit_elf ? size32 : size64; \
4482 if (section->sh_entsize != expected_entsize) \
4483 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4484 i, (unsigned long int) section->sh_entsize, \
4485 (unsigned long int) expected_entsize); \
4486 section->sh_entsize = expected_entsize; \
4489 #define CHECK_ENTSIZE(section, i, type) \
4490 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4491 sizeof (Elf64_External_##type))
4493 for (i
= 0, section
= section_headers
;
4494 i
< elf_header
.e_shnum
;
4497 char * name
= SECTION_NAME (section
);
4499 if (section
->sh_type
== SHT_DYNSYM
)
4501 if (dynamic_symbols
!= NULL
)
4503 error (_("File contains multiple dynamic symbol tables\n"));
4507 CHECK_ENTSIZE (section
, i
, Sym
);
4508 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4509 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4511 else if (section
->sh_type
== SHT_STRTAB
4512 && streq (name
, ".dynstr"))
4514 if (dynamic_strings
!= NULL
)
4516 error (_("File contains multiple dynamic string tables\n"));
4520 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4521 1, section
->sh_size
,
4522 _("dynamic strings"));
4523 dynamic_strings_length
= section
->sh_size
;
4525 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4527 if (symtab_shndx_hdr
!= NULL
)
4529 error (_("File contains multiple symtab shndx tables\n"));
4532 symtab_shndx_hdr
= section
;
4534 else if (section
->sh_type
== SHT_SYMTAB
)
4535 CHECK_ENTSIZE (section
, i
, Sym
);
4536 else if (section
->sh_type
== SHT_GROUP
)
4537 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4538 else if (section
->sh_type
== SHT_REL
)
4539 CHECK_ENTSIZE (section
, i
, Rel
);
4540 else if (section
->sh_type
== SHT_RELA
)
4541 CHECK_ENTSIZE (section
, i
, Rela
);
4542 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4543 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4544 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4545 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4546 && (const_strneq (name
, ".debug_")
4547 || const_strneq (name
, ".zdebug_")))
4550 name
+= sizeof (".zdebug_") - 1;
4552 name
+= sizeof (".debug_") - 1;
4555 || (do_debug_info
&& streq (name
, "info"))
4556 || (do_debug_info
&& streq (name
, "types"))
4557 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4558 || (do_debug_lines
&& streq (name
, "line"))
4559 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4560 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4561 || (do_debug_aranges
&& streq (name
, "aranges"))
4562 || (do_debug_ranges
&& streq (name
, "ranges"))
4563 || (do_debug_frames
&& streq (name
, "frame"))
4564 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4565 || (do_debug_str
&& streq (name
, "str"))
4566 || (do_debug_loc
&& streq (name
, "loc"))
4568 request_dump_bynumber (i
, DEBUG_DUMP
);
4570 /* Linkonce section to be combined with .debug_info at link time. */
4571 else if ((do_debugging
|| do_debug_info
)
4572 && const_strneq (name
, ".gnu.linkonce.wi."))
4573 request_dump_bynumber (i
, DEBUG_DUMP
);
4574 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4575 request_dump_bynumber (i
, DEBUG_DUMP
);
4576 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4577 request_dump_bynumber (i
, DEBUG_DUMP
);
4578 /* Trace sections for Itanium VMS. */
4579 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4580 || do_trace_aranges
)
4581 && const_strneq (name
, ".trace_"))
4583 name
+= sizeof (".trace_") - 1;
4586 || (do_trace_info
&& streq (name
, "info"))
4587 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4588 || (do_trace_aranges
&& streq (name
, "aranges"))
4590 request_dump_bynumber (i
, DEBUG_DUMP
);
4598 if (elf_header
.e_shnum
> 1)
4599 printf (_("\nSection Headers:\n"));
4601 printf (_("\nSection Header:\n"));
4605 if (do_section_details
)
4607 printf (_(" [Nr] Name\n"));
4608 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4612 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4616 if (do_section_details
)
4618 printf (_(" [Nr] Name\n"));
4619 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4623 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4627 if (do_section_details
)
4629 printf (_(" [Nr] Name\n"));
4630 printf (_(" Type Address Offset Link\n"));
4631 printf (_(" Size EntSize Info Align\n"));
4635 printf (_(" [Nr] Name Type Address Offset\n"));
4636 printf (_(" Size EntSize Flags Link Info Align\n"));
4640 if (do_section_details
)
4641 printf (_(" Flags\n"));
4643 for (i
= 0, section
= section_headers
;
4644 i
< elf_header
.e_shnum
;
4647 if (do_section_details
)
4649 printf (" [%2u] %s\n",
4651 SECTION_NAME (section
));
4652 if (is_32bit_elf
|| do_wide
)
4653 printf (" %-15.15s ",
4654 get_section_type_name (section
->sh_type
));
4657 printf ((do_wide
? " [%2u] %-17s %-15s "
4658 : " [%2u] %-17.17s %-15.15s "),
4660 SECTION_NAME (section
),
4661 get_section_type_name (section
->sh_type
));
4665 const char * link_too_big
= NULL
;
4667 print_vma (section
->sh_addr
, LONG_HEX
);
4669 printf ( " %6.6lx %6.6lx %2.2lx",
4670 (unsigned long) section
->sh_offset
,
4671 (unsigned long) section
->sh_size
,
4672 (unsigned long) section
->sh_entsize
);
4674 if (do_section_details
)
4675 fputs (" ", stdout
);
4677 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4679 if (section
->sh_link
>= elf_header
.e_shnum
)
4682 /* The sh_link value is out of range. Normally this indicates
4683 an error but it can have special values in Solaris binaries. */
4684 switch (elf_header
.e_machine
)
4690 case EM_OLD_SPARCV9
:
4691 case EM_SPARC32PLUS
:
4694 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4695 link_too_big
= "BEFORE";
4696 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4697 link_too_big
= "AFTER";
4704 if (do_section_details
)
4706 if (link_too_big
!= NULL
&& * link_too_big
)
4707 printf ("<%s> ", link_too_big
);
4709 printf ("%2u ", section
->sh_link
);
4710 printf ("%3u %2lu\n", section
->sh_info
,
4711 (unsigned long) section
->sh_addralign
);
4714 printf ("%2u %3u %2lu\n",
4717 (unsigned long) section
->sh_addralign
);
4719 if (link_too_big
&& ! * link_too_big
)
4720 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4721 i
, section
->sh_link
);
4725 print_vma (section
->sh_addr
, LONG_HEX
);
4727 if ((long) section
->sh_offset
== section
->sh_offset
)
4728 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4732 print_vma (section
->sh_offset
, LONG_HEX
);
4735 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4736 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4740 print_vma (section
->sh_size
, LONG_HEX
);
4743 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4744 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4748 print_vma (section
->sh_entsize
, LONG_HEX
);
4751 if (do_section_details
)
4752 fputs (" ", stdout
);
4754 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4756 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4758 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4759 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4762 print_vma (section
->sh_addralign
, DEC
);
4766 else if (do_section_details
)
4768 printf (" %-15.15s ",
4769 get_section_type_name (section
->sh_type
));
4770 print_vma (section
->sh_addr
, LONG_HEX
);
4771 if ((long) section
->sh_offset
== section
->sh_offset
)
4772 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4776 print_vma (section
->sh_offset
, LONG_HEX
);
4778 printf (" %u\n ", section
->sh_link
);
4779 print_vma (section
->sh_size
, LONG_HEX
);
4781 print_vma (section
->sh_entsize
, LONG_HEX
);
4783 printf (" %-16u %lu\n",
4785 (unsigned long) section
->sh_addralign
);
4790 print_vma (section
->sh_addr
, LONG_HEX
);
4791 if ((long) section
->sh_offset
== section
->sh_offset
)
4792 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4796 print_vma (section
->sh_offset
, LONG_HEX
);
4799 print_vma (section
->sh_size
, LONG_HEX
);
4801 print_vma (section
->sh_entsize
, LONG_HEX
);
4803 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4805 printf (" %2u %3u %lu\n",
4808 (unsigned long) section
->sh_addralign
);
4811 if (do_section_details
)
4812 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4815 if (!do_section_details
)
4817 if (elf_header
.e_machine
== EM_X86_64
4818 || elf_header
.e_machine
== EM_L1OM
)
4819 printf (_("Key to Flags:\n\
4820 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4821 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4822 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4824 printf (_("Key to Flags:\n\
4825 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4826 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4827 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4834 get_group_flags (unsigned int flags
)
4836 static char buff
[32];
4846 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4853 process_section_groups (FILE * file
)
4855 Elf_Internal_Shdr
* section
;
4857 struct group
* group
;
4858 Elf_Internal_Shdr
* symtab_sec
;
4859 Elf_Internal_Shdr
* strtab_sec
;
4860 Elf_Internal_Sym
* symtab
;
4864 /* Don't process section groups unless needed. */
4865 if (!do_unwind
&& !do_section_groups
)
4868 if (elf_header
.e_shnum
== 0)
4870 if (do_section_groups
)
4871 printf (_("\nThere are no sections to group in this file.\n"));
4876 if (section_headers
== NULL
)
4878 error (_("Section headers are not available!\n"));
4882 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4883 sizeof (struct group
*));
4885 if (section_headers_groups
== NULL
)
4887 error (_("Out of memory\n"));
4891 /* Scan the sections for the group section. */
4893 for (i
= 0, section
= section_headers
;
4894 i
< elf_header
.e_shnum
;
4896 if (section
->sh_type
== SHT_GROUP
)
4899 if (group_count
== 0)
4901 if (do_section_groups
)
4902 printf (_("\nThere are no section groups in this file.\n"));
4907 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4909 if (section_groups
== NULL
)
4911 error (_("Out of memory\n"));
4920 for (i
= 0, section
= section_headers
, group
= section_groups
;
4921 i
< elf_header
.e_shnum
;
4924 if (section
->sh_type
== SHT_GROUP
)
4926 char * name
= SECTION_NAME (section
);
4928 unsigned char * start
;
4929 unsigned char * indices
;
4930 unsigned int entry
, j
, size
;
4931 Elf_Internal_Shdr
* sec
;
4932 Elf_Internal_Sym
* sym
;
4934 /* Get the symbol table. */
4935 if (section
->sh_link
>= elf_header
.e_shnum
4936 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4939 error (_("Bad sh_link in group section `%s'\n"), name
);
4943 if (symtab_sec
!= sec
)
4948 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4953 error (_("Corrupt header in group section `%s'\n"), name
);
4957 sym
= symtab
+ section
->sh_info
;
4959 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4961 if (sym
->st_shndx
== 0
4962 || sym
->st_shndx
>= elf_header
.e_shnum
)
4964 error (_("Bad sh_info in group section `%s'\n"), name
);
4968 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4977 /* Get the string table. */
4978 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4987 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4992 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4993 1, strtab_sec
->sh_size
,
4995 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4997 group_name
= sym
->st_name
< strtab_size
4998 ? strtab
+ sym
->st_name
: _("<corrupt>");
5001 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5002 1, section
->sh_size
,
5006 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5007 entry
= byte_get (indices
, 4);
5010 if (do_section_groups
)
5012 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5013 get_group_flags (entry
), i
, name
, group_name
, size
);
5015 printf (_(" [Index] Name\n"));
5018 group
->group_index
= i
;
5020 for (j
= 0; j
< size
; j
++)
5022 struct group_list
* g
;
5024 entry
= byte_get (indices
, 4);
5027 if (entry
>= elf_header
.e_shnum
)
5029 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5030 entry
, i
, elf_header
.e_shnum
- 1);
5034 if (section_headers_groups
[entry
] != NULL
)
5038 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5040 section_headers_groups
[entry
]->group_index
);
5045 /* Intel C/C++ compiler may put section 0 in a
5046 section group. We just warn it the first time
5047 and ignore it afterwards. */
5048 static int warned
= 0;
5051 error (_("section 0 in group section [%5u]\n"),
5052 section_headers_groups
[entry
]->group_index
);
5058 section_headers_groups
[entry
] = group
;
5060 if (do_section_groups
)
5062 sec
= section_headers
+ entry
;
5063 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5066 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5067 g
->section_index
= entry
;
5068 g
->next
= group
->root
;
5086 /* Data used to display dynamic fixups. */
5088 struct ia64_vms_dynfixup
5090 bfd_vma needed_ident
; /* Library ident number. */
5091 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5092 bfd_vma fixup_needed
; /* Index of the library. */
5093 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5094 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5097 /* Data used to display dynamic relocations. */
5099 struct ia64_vms_dynimgrela
5101 bfd_vma img_rela_cnt
; /* Number of relocations. */
5102 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5105 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5109 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5110 const char *strtab
, unsigned int strtab_sz
)
5112 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5114 const char *lib_name
;
5116 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5117 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5118 _("dynamic section image fixups"));
5122 if (fixup
->needed
< strtab_sz
)
5123 lib_name
= strtab
+ fixup
->needed
;
5126 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5127 (unsigned long) fixup
->needed
);
5130 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5131 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5133 (_("Seg Offset Type SymVec DataType\n"));
5135 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5140 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5141 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5142 type
= BYTE_GET (imfs
[i
].type
);
5143 rtype
= elf_ia64_reloc_type (type
);
5145 printf (" 0x%08x ", type
);
5147 printf (" %-32s ", rtype
);
5148 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5149 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5155 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5158 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5160 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5163 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5164 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5165 _("dynamic section image relas"));
5169 printf (_("\nImage relocs\n"));
5171 (_("Seg Offset Type Addend Seg Sym Off\n"));
5173 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5178 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5179 printf ("%08" BFD_VMA_FMT
"x ",
5180 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5181 type
= BYTE_GET (imrs
[i
].type
);
5182 rtype
= elf_ia64_reloc_type (type
);
5184 printf ("0x%08x ", type
);
5186 printf ("%-31s ", rtype
);
5187 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5188 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5189 printf ("%08" BFD_VMA_FMT
"x\n",
5190 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5196 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5199 process_ia64_vms_dynamic_relocs (FILE *file
)
5201 struct ia64_vms_dynfixup fixup
;
5202 struct ia64_vms_dynimgrela imgrela
;
5203 Elf_Internal_Dyn
*entry
;
5205 bfd_vma strtab_off
= 0;
5206 bfd_vma strtab_sz
= 0;
5207 char *strtab
= NULL
;
5209 memset (&fixup
, 0, sizeof (fixup
));
5210 memset (&imgrela
, 0, sizeof (imgrela
));
5212 /* Note: the order of the entries is specified by the OpenVMS specs. */
5213 for (entry
= dynamic_section
;
5214 entry
< dynamic_section
+ dynamic_nent
;
5217 switch (entry
->d_tag
)
5219 case DT_IA_64_VMS_STRTAB_OFFSET
:
5220 strtab_off
= entry
->d_un
.d_val
;
5223 strtab_sz
= entry
->d_un
.d_val
;
5225 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5226 1, strtab_sz
, _("dynamic string section"));
5229 case DT_IA_64_VMS_NEEDED_IDENT
:
5230 fixup
.needed_ident
= entry
->d_un
.d_val
;
5233 fixup
.needed
= entry
->d_un
.d_val
;
5235 case DT_IA_64_VMS_FIXUP_NEEDED
:
5236 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5238 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5239 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5241 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5242 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5244 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5247 case DT_IA_64_VMS_IMG_RELA_CNT
:
5248 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5250 case DT_IA_64_VMS_IMG_RELA_OFF
:
5251 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5253 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5273 } dynamic_relocations
[] =
5275 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5276 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5277 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5280 /* Process the reloc section. */
5283 process_relocs (FILE * file
)
5285 unsigned long rel_size
;
5286 unsigned long rel_offset
;
5292 if (do_using_dynamic
)
5296 int has_dynamic_reloc
;
5299 has_dynamic_reloc
= 0;
5301 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5303 is_rela
= dynamic_relocations
[i
].rela
;
5304 name
= dynamic_relocations
[i
].name
;
5305 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5306 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5308 has_dynamic_reloc
|= rel_size
;
5310 if (is_rela
== UNKNOWN
)
5312 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5313 switch (dynamic_info
[DT_PLTREL
])
5327 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5328 name
, rel_offset
, rel_size
);
5330 dump_relocations (file
,
5331 offset_from_vma (file
, rel_offset
, rel_size
),
5333 dynamic_symbols
, num_dynamic_syms
,
5334 dynamic_strings
, dynamic_strings_length
, is_rela
);
5339 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5341 if (! has_dynamic_reloc
)
5342 printf (_("\nThere are no dynamic relocations in this file.\n"));
5346 Elf_Internal_Shdr
* section
;
5350 for (i
= 0, section
= section_headers
;
5351 i
< elf_header
.e_shnum
;
5354 if ( section
->sh_type
!= SHT_RELA
5355 && section
->sh_type
!= SHT_REL
)
5358 rel_offset
= section
->sh_offset
;
5359 rel_size
= section
->sh_size
;
5363 Elf_Internal_Shdr
* strsec
;
5366 printf (_("\nRelocation section "));
5368 if (string_table
== NULL
)
5369 printf ("%d", section
->sh_name
);
5371 printf (_("'%s'"), SECTION_NAME (section
));
5373 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5374 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5376 is_rela
= section
->sh_type
== SHT_RELA
;
5378 if (section
->sh_link
!= 0
5379 && section
->sh_link
< elf_header
.e_shnum
)
5381 Elf_Internal_Shdr
* symsec
;
5382 Elf_Internal_Sym
* symtab
;
5383 unsigned long nsyms
;
5384 unsigned long strtablen
= 0;
5385 char * strtab
= NULL
;
5387 symsec
= section_headers
+ section
->sh_link
;
5388 if (symsec
->sh_type
!= SHT_SYMTAB
5389 && symsec
->sh_type
!= SHT_DYNSYM
)
5392 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5393 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5398 if (symsec
->sh_link
!= 0
5399 && symsec
->sh_link
< elf_header
.e_shnum
)
5401 strsec
= section_headers
+ symsec
->sh_link
;
5403 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5406 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5409 dump_relocations (file
, rel_offset
, rel_size
,
5410 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5416 dump_relocations (file
, rel_offset
, rel_size
,
5417 NULL
, 0, NULL
, 0, is_rela
);
5424 printf (_("\nThere are no relocations in this file.\n"));
5430 /* Process the unwind section. */
5432 #include "unwind-ia64.h"
5434 /* An absolute address consists of a section and an offset. If the
5435 section is NULL, the offset itself is the address, otherwise, the
5436 address equals to LOAD_ADDRESS(section) + offset. */
5440 unsigned short section
;
5444 #define ABSADDR(a) \
5446 ? section_headers [(a).section].sh_addr + (a).offset \
5449 struct ia64_unw_table_entry
5451 struct absaddr start
;
5453 struct absaddr info
;
5456 struct ia64_unw_aux_info
5459 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5460 unsigned long table_len
; /* Length of unwind table. */
5461 unsigned char * info
; /* Unwind info. */
5462 unsigned long info_size
; /* Size of unwind info. */
5463 bfd_vma info_addr
; /* starting address of unwind info. */
5464 bfd_vma seg_base
; /* Starting address of segment. */
5465 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5466 unsigned long nsyms
; /* Number of symbols. */
5467 char * strtab
; /* The string table. */
5468 unsigned long strtab_size
; /* Size of string table. */
5472 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5473 unsigned long nsyms
,
5474 const char * strtab
,
5475 unsigned long strtab_size
,
5476 struct absaddr addr
,
5477 const char ** symname
,
5480 bfd_vma dist
= 0x100000;
5481 Elf_Internal_Sym
* sym
;
5482 Elf_Internal_Sym
* best
= NULL
;
5485 REMOVE_ARCH_BITS (addr
.offset
);
5487 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5489 bfd_vma value
= sym
->st_value
;
5491 REMOVE_ARCH_BITS (value
);
5493 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5494 && sym
->st_name
!= 0
5495 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5496 && addr
.offset
>= value
5497 && addr
.offset
- value
< dist
)
5500 dist
= addr
.offset
- value
;
5507 *symname
= (best
->st_name
>= strtab_size
5508 ? _("<corrupt>") : strtab
+ best
->st_name
);
5513 *offset
= addr
.offset
;
5517 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5519 struct ia64_unw_table_entry
* tp
;
5522 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5526 const unsigned char * dp
;
5527 const unsigned char * head
;
5528 const char * procname
;
5530 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5531 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5533 fputs ("\n<", stdout
);
5537 fputs (procname
, stdout
);
5540 printf ("+%lx", (unsigned long) offset
);
5543 fputs (">: [", stdout
);
5544 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5545 fputc ('-', stdout
);
5546 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5547 printf ("], info at +0x%lx\n",
5548 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5550 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5551 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5553 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5554 (unsigned) UNW_VER (stamp
),
5555 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5556 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5557 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5558 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5560 if (UNW_VER (stamp
) != 1)
5562 printf (_("\tUnknown version.\n"));
5567 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5568 dp
= unw_decode (dp
, in_body
, & in_body
);
5573 slurp_ia64_unwind_table (FILE * file
,
5574 struct ia64_unw_aux_info
* aux
,
5575 Elf_Internal_Shdr
* sec
)
5577 unsigned long size
, nrelas
, i
;
5578 Elf_Internal_Phdr
* seg
;
5579 struct ia64_unw_table_entry
* tep
;
5580 Elf_Internal_Shdr
* relsec
;
5581 Elf_Internal_Rela
* rela
;
5582 Elf_Internal_Rela
* rp
;
5583 unsigned char * table
;
5585 Elf_Internal_Sym
* sym
;
5586 const char * relname
;
5588 /* First, find the starting address of the segment that includes
5591 if (elf_header
.e_phnum
)
5593 if (! get_program_headers (file
))
5596 for (seg
= program_headers
;
5597 seg
< program_headers
+ elf_header
.e_phnum
;
5600 if (seg
->p_type
!= PT_LOAD
)
5603 if (sec
->sh_addr
>= seg
->p_vaddr
5604 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5606 aux
->seg_base
= seg
->p_vaddr
;
5612 /* Second, build the unwind table from the contents of the unwind section: */
5613 size
= sec
->sh_size
;
5614 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5619 aux
->table
= (struct ia64_unw_table_entry
*)
5620 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5622 for (tp
= table
; tp
< table
+ size
; ++tep
)
5624 tep
->start
.section
= SHN_UNDEF
;
5625 tep
->end
.section
= SHN_UNDEF
;
5626 tep
->info
.section
= SHN_UNDEF
;
5627 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5628 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5629 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5630 tep
->start
.offset
+= aux
->seg_base
;
5631 tep
->end
.offset
+= aux
->seg_base
;
5632 tep
->info
.offset
+= aux
->seg_base
;
5636 /* Third, apply any relocations to the unwind table: */
5637 for (relsec
= section_headers
;
5638 relsec
< section_headers
+ elf_header
.e_shnum
;
5641 if (relsec
->sh_type
!= SHT_RELA
5642 || relsec
->sh_info
>= elf_header
.e_shnum
5643 || section_headers
+ relsec
->sh_info
!= sec
)
5646 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5650 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5652 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5653 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5655 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5657 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5661 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5663 switch (rp
->r_offset
/eh_addr_size
% 3)
5666 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5667 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5670 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5671 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5674 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5675 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5685 aux
->table_len
= size
/ (3 * eh_addr_size
);
5690 ia64_process_unwind (FILE * file
)
5692 Elf_Internal_Shdr
* sec
;
5693 Elf_Internal_Shdr
* unwsec
= NULL
;
5694 Elf_Internal_Shdr
* strsec
;
5695 unsigned long i
, unwcount
= 0, unwstart
= 0;
5696 struct ia64_unw_aux_info aux
;
5698 memset (& aux
, 0, sizeof (aux
));
5700 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5702 if (sec
->sh_type
== SHT_SYMTAB
5703 && sec
->sh_link
< elf_header
.e_shnum
)
5705 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5706 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5708 strsec
= section_headers
+ sec
->sh_link
;
5709 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5712 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5714 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5719 printf (_("\nThere are no unwind sections in this file.\n"));
5721 while (unwcount
-- > 0)
5726 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5727 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5728 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5735 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5737 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5739 /* We need to find which section group it is in. */
5740 struct group_list
* g
= section_headers_groups
[i
]->root
;
5742 for (; g
!= NULL
; g
= g
->next
)
5744 sec
= section_headers
+ g
->section_index
;
5746 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5751 i
= elf_header
.e_shnum
;
5753 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5755 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5756 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5757 suffix
= SECTION_NAME (unwsec
) + len
;
5758 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5760 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5761 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5766 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5767 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5768 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5769 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5771 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5772 suffix
= SECTION_NAME (unwsec
) + len
;
5773 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5775 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5776 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5780 if (i
== elf_header
.e_shnum
)
5782 printf (_("\nCould not find unwind info section for "));
5784 if (string_table
== NULL
)
5785 printf ("%d", unwsec
->sh_name
);
5787 printf (_("'%s'"), SECTION_NAME (unwsec
));
5791 aux
.info_size
= sec
->sh_size
;
5792 aux
.info_addr
= sec
->sh_addr
;
5793 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5797 printf (_("\nUnwind section "));
5799 if (string_table
== NULL
)
5800 printf ("%d", unwsec
->sh_name
);
5802 printf (_("'%s'"), SECTION_NAME (unwsec
));
5804 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5805 (unsigned long) unwsec
->sh_offset
,
5806 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5808 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5810 if (aux
.table_len
> 0)
5811 dump_ia64_unwind (& aux
);
5814 free ((char *) aux
.table
);
5816 free ((char *) aux
.info
);
5825 free ((char *) aux
.strtab
);
5830 struct hppa_unw_table_entry
5832 struct absaddr start
;
5834 unsigned int Cannot_unwind
:1; /* 0 */
5835 unsigned int Millicode
:1; /* 1 */
5836 unsigned int Millicode_save_sr0
:1; /* 2 */
5837 unsigned int Region_description
:2; /* 3..4 */
5838 unsigned int reserved1
:1; /* 5 */
5839 unsigned int Entry_SR
:1; /* 6 */
5840 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5841 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5842 unsigned int Args_stored
:1; /* 16 */
5843 unsigned int Variable_Frame
:1; /* 17 */
5844 unsigned int Separate_Package_Body
:1; /* 18 */
5845 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5846 unsigned int Stack_Overflow_Check
:1; /* 20 */
5847 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5848 unsigned int Ada_Region
:1; /* 22 */
5849 unsigned int cxx_info
:1; /* 23 */
5850 unsigned int cxx_try_catch
:1; /* 24 */
5851 unsigned int sched_entry_seq
:1; /* 25 */
5852 unsigned int reserved2
:1; /* 26 */
5853 unsigned int Save_SP
:1; /* 27 */
5854 unsigned int Save_RP
:1; /* 28 */
5855 unsigned int Save_MRP_in_frame
:1; /* 29 */
5856 unsigned int extn_ptr_defined
:1; /* 30 */
5857 unsigned int Cleanup_defined
:1; /* 31 */
5859 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5860 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5861 unsigned int Large_frame
:1; /* 2 */
5862 unsigned int Pseudo_SP_Set
:1; /* 3 */
5863 unsigned int reserved4
:1; /* 4 */
5864 unsigned int Total_frame_size
:27; /* 5..31 */
5867 struct hppa_unw_aux_info
5869 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5870 unsigned long table_len
; /* Length of unwind table. */
5871 bfd_vma seg_base
; /* Starting address of segment. */
5872 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5873 unsigned long nsyms
; /* Number of symbols. */
5874 char * strtab
; /* The string table. */
5875 unsigned long strtab_size
; /* Size of string table. */
5879 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5881 struct hppa_unw_table_entry
* tp
;
5883 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5886 const char * procname
;
5888 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5889 aux
->strtab_size
, tp
->start
, &procname
,
5892 fputs ("\n<", stdout
);
5896 fputs (procname
, stdout
);
5899 printf ("+%lx", (unsigned long) offset
);
5902 fputs (">: [", stdout
);
5903 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5904 fputc ('-', stdout
);
5905 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5908 #define PF(_m) if (tp->_m) printf (#_m " ");
5909 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5912 PF(Millicode_save_sr0
);
5913 /* PV(Region_description); */
5919 PF(Separate_Package_Body
);
5920 PF(Frame_Extension_Millicode
);
5921 PF(Stack_Overflow_Check
);
5922 PF(Two_Instruction_SP_Increment
);
5926 PF(sched_entry_seq
);
5929 PF(Save_MRP_in_frame
);
5930 PF(extn_ptr_defined
);
5931 PF(Cleanup_defined
);
5932 PF(MPE_XL_interrupt_marker
);
5933 PF(HP_UX_interrupt_marker
);
5936 PV(Total_frame_size
);
5945 slurp_hppa_unwind_table (FILE * file
,
5946 struct hppa_unw_aux_info
* aux
,
5947 Elf_Internal_Shdr
* sec
)
5949 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5950 Elf_Internal_Phdr
* seg
;
5951 struct hppa_unw_table_entry
* tep
;
5952 Elf_Internal_Shdr
* relsec
;
5953 Elf_Internal_Rela
* rela
;
5954 Elf_Internal_Rela
* rp
;
5955 unsigned char * table
;
5957 Elf_Internal_Sym
* sym
;
5958 const char * relname
;
5960 /* First, find the starting address of the segment that includes
5963 if (elf_header
.e_phnum
)
5965 if (! get_program_headers (file
))
5968 for (seg
= program_headers
;
5969 seg
< program_headers
+ elf_header
.e_phnum
;
5972 if (seg
->p_type
!= PT_LOAD
)
5975 if (sec
->sh_addr
>= seg
->p_vaddr
5976 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5978 aux
->seg_base
= seg
->p_vaddr
;
5984 /* Second, build the unwind table from the contents of the unwind
5986 size
= sec
->sh_size
;
5987 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5993 nentries
= size
/ unw_ent_size
;
5994 size
= unw_ent_size
* nentries
;
5996 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5997 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5999 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6001 unsigned int tmp1
, tmp2
;
6003 tep
->start
.section
= SHN_UNDEF
;
6004 tep
->end
.section
= SHN_UNDEF
;
6006 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6007 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6008 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6009 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6011 tep
->start
.offset
+= aux
->seg_base
;
6012 tep
->end
.offset
+= aux
->seg_base
;
6014 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6015 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6016 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6017 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6018 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6019 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6020 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6021 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6022 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6023 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6024 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6025 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6026 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6027 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6028 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6029 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6030 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6031 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6032 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6033 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6034 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6035 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6036 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6037 tep
->Cleanup_defined
= tmp1
& 0x1;
6039 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6040 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6041 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6042 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6043 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6044 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6048 /* Third, apply any relocations to the unwind table. */
6049 for (relsec
= section_headers
;
6050 relsec
< section_headers
+ elf_header
.e_shnum
;
6053 if (relsec
->sh_type
!= SHT_RELA
6054 || relsec
->sh_info
>= elf_header
.e_shnum
6055 || section_headers
+ relsec
->sh_info
!= sec
)
6058 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6062 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6064 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6065 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6067 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6068 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6070 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6074 i
= rp
->r_offset
/ unw_ent_size
;
6076 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6079 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6080 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6083 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6084 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6094 aux
->table_len
= nentries
;
6100 hppa_process_unwind (FILE * file
)
6102 struct hppa_unw_aux_info aux
;
6103 Elf_Internal_Shdr
* unwsec
= NULL
;
6104 Elf_Internal_Shdr
* strsec
;
6105 Elf_Internal_Shdr
* sec
;
6108 memset (& aux
, 0, sizeof (aux
));
6110 if (string_table
== NULL
)
6113 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6115 if (sec
->sh_type
== SHT_SYMTAB
6116 && sec
->sh_link
< elf_header
.e_shnum
)
6118 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6119 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6121 strsec
= section_headers
+ sec
->sh_link
;
6122 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6125 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6127 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6132 printf (_("\nThere are no unwind sections in this file.\n"));
6134 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6136 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6138 printf (_("\nUnwind section "));
6139 printf (_("'%s'"), SECTION_NAME (sec
));
6141 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6142 (unsigned long) sec
->sh_offset
,
6143 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6145 slurp_hppa_unwind_table (file
, &aux
, sec
);
6146 if (aux
.table_len
> 0)
6147 dump_hppa_unwind (&aux
);
6150 free ((char *) aux
.table
);
6158 free ((char *) aux
.strtab
);
6165 unsigned char *data
;
6167 Elf_Internal_Shdr
*sec
;
6168 Elf_Internal_Rela
*rela
;
6169 unsigned long nrelas
;
6170 unsigned int rel_type
;
6172 Elf_Internal_Rela
*next_rela
;
6175 struct arm_unw_aux_info
6179 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6180 unsigned long nsyms
; /* Number of symbols. */
6181 char *strtab
; /* The string table. */
6182 unsigned long strtab_size
; /* Size of string table. */
6186 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6187 bfd_vma fn
, struct absaddr addr
)
6189 const char *procname
;
6192 if (addr
.section
== SHN_UNDEF
)
6195 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6196 aux
->strtab_size
, addr
, &procname
,
6199 print_vma (fn
, PREFIX_HEX
);
6203 fputs (" <", stdout
);
6204 fputs (procname
, stdout
);
6207 printf ("+0x%lx", (unsigned long) sym_offset
);
6208 fputc ('>', stdout
);
6215 arm_free_section (struct arm_section
*arm_sec
)
6217 if (arm_sec
->data
!= NULL
)
6218 free (arm_sec
->data
);
6220 if (arm_sec
->rela
!= NULL
)
6221 free (arm_sec
->rela
);
6225 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6226 struct arm_section
*arm_sec
,
6227 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6228 unsigned int *wordp
, struct absaddr
*addr
)
6230 Elf_Internal_Rela
*rp
;
6231 Elf_Internal_Sym
*sym
;
6232 const char * relname
;
6234 bfd_boolean wrapped
;
6236 addr
->section
= SHN_UNDEF
;
6239 if (sec
!= arm_sec
->sec
)
6241 Elf_Internal_Shdr
*relsec
;
6243 arm_free_section (arm_sec
);
6246 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6247 sec
->sh_size
, _("unwind data"));
6249 arm_sec
->rela
= NULL
;
6250 arm_sec
->nrelas
= 0;
6252 for (relsec
= section_headers
;
6253 relsec
< section_headers
+ elf_header
.e_shnum
;
6256 if (relsec
->sh_info
>= elf_header
.e_shnum
6257 || section_headers
+ relsec
->sh_info
!= sec
)
6260 if (relsec
->sh_type
== SHT_REL
)
6262 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6264 & arm_sec
->rela
, & arm_sec
->nrelas
))
6268 else if (relsec
->sh_type
== SHT_RELA
)
6270 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6272 & arm_sec
->rela
, & arm_sec
->nrelas
))
6278 arm_sec
->next_rela
= arm_sec
->rela
;
6281 if (arm_sec
->data
== NULL
)
6284 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6287 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6289 bfd_vma prelval
, offset
;
6291 if (rp
->r_offset
> word_offset
&& !wrapped
)
6296 if (rp
->r_offset
> word_offset
)
6299 if (rp
->r_offset
& 3)
6301 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6302 (unsigned long) rp
->r_offset
);
6306 if (rp
->r_offset
< word_offset
)
6309 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6311 if (streq (relname
, "R_ARM_NONE"))
6314 if (! streq (relname
, "R_ARM_PREL31"))
6316 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6320 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6322 if (arm_sec
->rel_type
== SHT_REL
)
6324 offset
= word
& 0x7fffffff;
6325 if (offset
& 0x40000000)
6326 offset
|= ~ (bfd_vma
) 0x7fffffff;
6329 offset
= rp
->r_addend
;
6331 offset
+= sym
->st_value
;
6332 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6334 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6335 addr
->section
= sym
->st_shndx
;
6336 addr
->offset
= offset
;
6341 arm_sec
->next_rela
= rp
;
6347 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6348 unsigned int word
, unsigned int remaining
,
6349 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6350 struct arm_section
*data_arm_sec
)
6353 unsigned int more_words
;
6354 struct absaddr addr
;
6357 if (remaining == 0 && more_words) \
6360 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6361 data_offset, &word, &addr)) \
6367 #define GET_OP(OP) \
6372 (OP) = word >> 24; \
6377 printf (_("[Truncated opcode]\n")); \
6380 printf ("0x%02x ", OP)
6384 /* Fetch the first word. */
6385 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6391 if ((word
& 0x80000000) == 0)
6393 /* Expand prel31 for personality routine. */
6395 const char *procname
;
6398 if (fn
& 0x40000000)
6399 fn
|= ~ (bfd_vma
) 0x7fffffff;
6400 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6402 printf (_(" Personality routine: "));
6403 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6404 fputc ('\n', stdout
);
6406 /* The GCC personality routines use the standard compact
6407 encoding, starting with one byte giving the number of
6409 if (procname
!= NULL
6410 && (const_strneq (procname
, "__gcc_personality_v0")
6411 || const_strneq (procname
, "__gxx_personality_v0")
6412 || const_strneq (procname
, "__gcj_personality_v0")
6413 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6420 printf (_(" [Truncated data]\n"));
6423 more_words
= word
>> 24;
6432 per_index
= (word
>> 24) & 0x7f;
6433 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6435 printf (_(" [reserved compact index %d]\n"), per_index
);
6439 printf (_(" Compact model %d\n"), per_index
);
6448 more_words
= (word
>> 16) & 0xff;
6454 /* Decode the unwinding instructions. */
6457 unsigned int op
, op2
;
6466 printf (" 0x%02x ", op
);
6468 if ((op
& 0xc0) == 0x00)
6470 int offset
= ((op
& 0x3f) << 2) + 4;
6471 printf (" vsp = vsp + %d", offset
);
6473 else if ((op
& 0xc0) == 0x40)
6475 int offset
= ((op
& 0x3f) << 2) + 4;
6476 printf (" vsp = vsp - %d", offset
);
6478 else if ((op
& 0xf0) == 0x80)
6481 if (op
== 0x80 && op2
== 0)
6482 printf (_("Refuse to unwind"));
6485 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6490 for (i
= 0; i
< 12; i
++)
6491 if (mask
& (1 << i
))
6497 printf ("r%d", 4 + i
);
6502 else if ((op
& 0xf0) == 0x90)
6504 if (op
== 0x9d || op
== 0x9f)
6505 printf (_(" [Reserved]"));
6507 printf (" vsp = r%d", op
& 0x0f);
6509 else if ((op
& 0xf0) == 0xa0)
6511 int end
= 4 + (op
& 0x07);
6515 for (i
= 4; i
<= end
; i
++)
6531 else if (op
== 0xb0)
6532 printf (_(" finish"));
6533 else if (op
== 0xb1)
6536 if (op2
== 0 || (op2
& 0xf0) != 0)
6537 printf (_("[Spare]"));
6540 unsigned int mask
= op2
& 0x0f;
6544 for (i
= 0; i
< 12; i
++)
6545 if (mask
& (1 << i
))
6556 else if (op
== 0xb2)
6558 unsigned char buf
[9];
6559 unsigned int i
, len
;
6560 unsigned long offset
;
6561 for (i
= 0; i
< sizeof (buf
); i
++)
6564 if ((buf
[i
] & 0x80) == 0)
6567 assert (i
< sizeof (buf
));
6568 offset
= read_uleb128 (buf
, &len
);
6569 assert (len
== i
+ 1);
6570 offset
= offset
* 4 + 0x204;
6571 printf ("vsp = vsp + %ld", offset
);
6575 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6578 printf (_("[unsupported two-byte opcode]"));
6582 printf (_(" [unsupported opcode]"));
6588 /* Decode the descriptors. Not implemented. */
6592 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6594 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6595 unsigned int i
, exidx_len
;
6597 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6598 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6599 exidx_len
= exidx_sec
->sh_size
/ 8;
6601 for (i
= 0; i
< exidx_len
; i
++)
6603 unsigned int exidx_fn
, exidx_entry
;
6604 struct absaddr fn_addr
, entry_addr
;
6607 fputc ('\n', stdout
);
6609 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6610 8 * i
, &exidx_fn
, &fn_addr
)
6611 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6612 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6614 arm_free_section (&exidx_arm_sec
);
6615 arm_free_section (&extab_arm_sec
);
6619 fn
= exidx_fn
& 0x7fffffff;
6620 if (fn
& 0x40000000)
6621 fn
|= ~ (bfd_vma
) 0x7fffffff;
6622 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6624 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6625 fputs (": ", stdout
);
6627 if (exidx_entry
== 1)
6629 print_vma (exidx_entry
, PREFIX_HEX
);
6630 fputs (" [cantunwind]\n", stdout
);
6632 else if (exidx_entry
& 0x80000000)
6634 print_vma (exidx_entry
, PREFIX_HEX
);
6635 fputc ('\n', stdout
);
6636 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6640 bfd_vma table
, table_offset
= 0;
6641 Elf_Internal_Shdr
*table_sec
;
6643 fputs ("@", stdout
);
6644 table
= exidx_entry
;
6645 if (table
& 0x40000000)
6646 table
|= ~ (bfd_vma
) 0x7fffffff;
6647 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6648 print_vma (table
, PREFIX_HEX
);
6651 /* Locate the matching .ARM.extab. */
6652 if (entry_addr
.section
!= SHN_UNDEF
6653 && entry_addr
.section
< elf_header
.e_shnum
)
6655 table_sec
= section_headers
+ entry_addr
.section
;
6656 table_offset
= entry_addr
.offset
;
6660 table_sec
= find_section_by_address (table
);
6661 if (table_sec
!= NULL
)
6662 table_offset
= table
- table_sec
->sh_addr
;
6664 if (table_sec
== NULL
)
6666 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6667 (unsigned long) table
);
6670 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6677 arm_free_section (&exidx_arm_sec
);
6678 arm_free_section (&extab_arm_sec
);
6682 arm_process_unwind (FILE *file
)
6684 struct arm_unw_aux_info aux
;
6685 Elf_Internal_Shdr
*unwsec
= NULL
;
6686 Elf_Internal_Shdr
*strsec
;
6687 Elf_Internal_Shdr
*sec
;
6690 memset (& aux
, 0, sizeof (aux
));
6693 if (string_table
== NULL
)
6696 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6698 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6700 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6701 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6703 strsec
= section_headers
+ sec
->sh_link
;
6704 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6705 1, strsec
->sh_size
, _("string table"));
6706 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6708 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6713 printf (_("\nThere are no unwind sections in this file.\n"));
6715 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6717 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6719 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6721 (unsigned long) sec
->sh_offset
,
6722 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6724 dump_arm_unwind (&aux
, sec
);
6731 free ((char *) aux
.strtab
);
6737 process_unwind (FILE * file
)
6739 struct unwind_handler
6742 int (* handler
)(FILE *);
6745 { EM_ARM
, arm_process_unwind
},
6746 { EM_IA_64
, ia64_process_unwind
},
6747 { EM_PARISC
, hppa_process_unwind
},
6755 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6756 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6757 return handlers
[i
].handler (file
);
6759 printf (_("\nThere are no unwind sections in this file.\n"));
6764 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6766 switch (entry
->d_tag
)
6769 if (entry
->d_un
.d_val
== 0)
6770 printf (_("NONE\n"));
6773 static const char * opts
[] =
6775 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6776 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6777 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6778 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6784 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6785 if (entry
->d_un
.d_val
& (1 << cnt
))
6787 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6794 case DT_MIPS_IVERSION
:
6795 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6796 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6798 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6801 case DT_MIPS_TIME_STAMP
:
6806 time_t atime
= entry
->d_un
.d_val
;
6807 tmp
= gmtime (&atime
);
6808 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6809 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6810 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6811 printf (_("Time Stamp: %s\n"), timebuf
);
6815 case DT_MIPS_RLD_VERSION
:
6816 case DT_MIPS_LOCAL_GOTNO
:
6817 case DT_MIPS_CONFLICTNO
:
6818 case DT_MIPS_LIBLISTNO
:
6819 case DT_MIPS_SYMTABNO
:
6820 case DT_MIPS_UNREFEXTNO
:
6821 case DT_MIPS_HIPAGENO
:
6822 case DT_MIPS_DELTA_CLASS_NO
:
6823 case DT_MIPS_DELTA_INSTANCE_NO
:
6824 case DT_MIPS_DELTA_RELOC_NO
:
6825 case DT_MIPS_DELTA_SYM_NO
:
6826 case DT_MIPS_DELTA_CLASSSYM_NO
:
6827 case DT_MIPS_COMPACT_SIZE
:
6828 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6832 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6837 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6839 switch (entry
->d_tag
)
6841 case DT_HP_DLD_FLAGS
:
6850 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6851 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6852 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6853 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6854 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6855 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6856 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6857 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6858 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6859 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6860 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6861 { DT_HP_GST
, "HP_GST" },
6862 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6863 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6864 { DT_HP_NODELETE
, "HP_NODELETE" },
6865 { DT_HP_GROUP
, "HP_GROUP" },
6866 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6870 bfd_vma val
= entry
->d_un
.d_val
;
6872 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6873 if (val
& flags
[cnt
].bit
)
6877 fputs (flags
[cnt
].str
, stdout
);
6879 val
^= flags
[cnt
].bit
;
6882 if (val
!= 0 || first
)
6886 print_vma (val
, HEX
);
6892 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6900 /* VMS vs Unix time offset and factor. */
6902 #define VMS_EPOCH_OFFSET 35067168000000000LL
6903 #define VMS_GRANULARITY_FACTOR 10000000
6905 /* Display a VMS time in a human readable format. */
6908 print_vms_time (bfd_int64_t vmstime
)
6913 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6914 tm
= gmtime (&unxtime
);
6915 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6916 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6917 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6922 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6924 switch (entry
->d_tag
)
6926 case DT_IA_64_PLT_RESERVE
:
6927 /* First 3 slots reserved. */
6928 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6930 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6933 case DT_IA_64_VMS_LINKTIME
:
6935 print_vms_time (entry
->d_un
.d_val
);
6939 case DT_IA_64_VMS_LNKFLAGS
:
6940 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6941 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
6942 printf (" CALL_DEBUG");
6943 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
6944 printf (" NOP0BUFS");
6945 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
6946 printf (" P0IMAGE");
6947 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
6948 printf (" MKTHREADS");
6949 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
6950 printf (" UPCALLS");
6951 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
6953 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
6954 printf (" INITIALIZE");
6955 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
6957 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
6958 printf (" EXE_INIT");
6959 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
6960 printf (" TBK_IN_IMG");
6961 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
6962 printf (" DBG_IN_IMG");
6963 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
6964 printf (" TBK_IN_DSF");
6965 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
6966 printf (" DBG_IN_DSF");
6967 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
6968 printf (" SIGNATURES");
6969 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
6970 printf (" REL_SEG_OFF");
6974 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6981 get_32bit_dynamic_section (FILE * file
)
6983 Elf32_External_Dyn
* edyn
;
6984 Elf32_External_Dyn
* ext
;
6985 Elf_Internal_Dyn
* entry
;
6987 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6988 dynamic_size
, _("dynamic section"));
6992 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6993 might not have the luxury of section headers. Look for the DT_NULL
6994 terminator to determine the number of entries. */
6995 for (ext
= edyn
, dynamic_nent
= 0;
6996 (char *) ext
< (char *) edyn
+ dynamic_size
;
7000 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7004 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7006 if (dynamic_section
== NULL
)
7008 error (_("Out of memory\n"));
7013 for (ext
= edyn
, entry
= dynamic_section
;
7014 entry
< dynamic_section
+ dynamic_nent
;
7017 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7018 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7027 get_64bit_dynamic_section (FILE * file
)
7029 Elf64_External_Dyn
* edyn
;
7030 Elf64_External_Dyn
* ext
;
7031 Elf_Internal_Dyn
* entry
;
7033 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7034 dynamic_size
, _("dynamic section"));
7038 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7039 might not have the luxury of section headers. Look for the DT_NULL
7040 terminator to determine the number of entries. */
7041 for (ext
= edyn
, dynamic_nent
= 0;
7042 (char *) ext
< (char *) edyn
+ dynamic_size
;
7046 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7050 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7052 if (dynamic_section
== NULL
)
7054 error (_("Out of memory\n"));
7059 for (ext
= edyn
, entry
= dynamic_section
;
7060 entry
< dynamic_section
+ dynamic_nent
;
7063 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7064 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7073 print_dynamic_flags (bfd_vma flags
)
7081 flag
= flags
& - flags
;
7091 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7092 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7093 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7094 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7095 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7096 default: fputs (_("unknown"), stdout
); break;
7102 /* Parse and display the contents of the dynamic section. */
7105 process_dynamic_section (FILE * file
)
7107 Elf_Internal_Dyn
* entry
;
7109 if (dynamic_size
== 0)
7112 printf (_("\nThere is no dynamic section in this file.\n"));
7119 if (! get_32bit_dynamic_section (file
))
7122 else if (! get_64bit_dynamic_section (file
))
7125 /* Find the appropriate symbol table. */
7126 if (dynamic_symbols
== NULL
)
7128 for (entry
= dynamic_section
;
7129 entry
< dynamic_section
+ dynamic_nent
;
7132 Elf_Internal_Shdr section
;
7134 if (entry
->d_tag
!= DT_SYMTAB
)
7137 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7139 /* Since we do not know how big the symbol table is,
7140 we default to reading in the entire file (!) and
7141 processing that. This is overkill, I know, but it
7143 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7145 if (archive_file_offset
!= 0)
7146 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7149 if (fseek (file
, 0, SEEK_END
))
7150 error (_("Unable to seek to end of file!\n"));
7152 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7156 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7158 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7160 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7161 if (num_dynamic_syms
< 1)
7163 error (_("Unable to determine the number of symbols to load\n"));
7167 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7171 /* Similarly find a string table. */
7172 if (dynamic_strings
== NULL
)
7174 for (entry
= dynamic_section
;
7175 entry
< dynamic_section
+ dynamic_nent
;
7178 unsigned long offset
;
7181 if (entry
->d_tag
!= DT_STRTAB
)
7184 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7186 /* Since we do not know how big the string table is,
7187 we default to reading in the entire file (!) and
7188 processing that. This is overkill, I know, but it
7191 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7193 if (archive_file_offset
!= 0)
7194 str_tab_len
= archive_file_size
- offset
;
7197 if (fseek (file
, 0, SEEK_END
))
7198 error (_("Unable to seek to end of file\n"));
7199 str_tab_len
= ftell (file
) - offset
;
7202 if (str_tab_len
< 1)
7205 (_("Unable to determine the length of the dynamic string table\n"));
7209 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7211 _("dynamic string table"));
7212 dynamic_strings_length
= str_tab_len
;
7217 /* And find the syminfo section if available. */
7218 if (dynamic_syminfo
== NULL
)
7220 unsigned long syminsz
= 0;
7222 for (entry
= dynamic_section
;
7223 entry
< dynamic_section
+ dynamic_nent
;
7226 if (entry
->d_tag
== DT_SYMINENT
)
7228 /* Note: these braces are necessary to avoid a syntax
7229 error from the SunOS4 C compiler. */
7230 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7232 else if (entry
->d_tag
== DT_SYMINSZ
)
7233 syminsz
= entry
->d_un
.d_val
;
7234 else if (entry
->d_tag
== DT_SYMINFO
)
7235 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7239 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7241 Elf_External_Syminfo
* extsyminfo
;
7242 Elf_External_Syminfo
* extsym
;
7243 Elf_Internal_Syminfo
* syminfo
;
7245 /* There is a syminfo section. Read the data. */
7246 extsyminfo
= (Elf_External_Syminfo
*)
7247 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7248 _("symbol information"));
7252 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7253 if (dynamic_syminfo
== NULL
)
7255 error (_("Out of memory\n"));
7259 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7260 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7261 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7262 ++syminfo
, ++extsym
)
7264 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7265 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7272 if (do_dynamic
&& dynamic_addr
)
7273 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7274 dynamic_addr
, dynamic_nent
);
7276 printf (_(" Tag Type Name/Value\n"));
7278 for (entry
= dynamic_section
;
7279 entry
< dynamic_section
+ dynamic_nent
;
7287 print_vma (entry
->d_tag
, FULL_HEX
);
7288 dtype
= get_dynamic_type (entry
->d_tag
);
7289 printf (" (%s)%*s", dtype
,
7290 ((is_32bit_elf
? 27 : 19)
7291 - (int) strlen (dtype
)),
7295 switch (entry
->d_tag
)
7299 print_dynamic_flags (entry
->d_un
.d_val
);
7309 switch (entry
->d_tag
)
7312 printf (_("Auxiliary library"));
7316 printf (_("Filter library"));
7320 printf (_("Configuration file"));
7324 printf (_("Dependency audit library"));
7328 printf (_("Audit library"));
7332 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7333 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7337 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7346 printf (_("Flags:"));
7348 if (entry
->d_un
.d_val
== 0)
7349 printf (_(" None\n"));
7352 unsigned long int val
= entry
->d_un
.d_val
;
7354 if (val
& DTF_1_PARINIT
)
7356 printf (" PARINIT");
7357 val
^= DTF_1_PARINIT
;
7359 if (val
& DTF_1_CONFEXP
)
7361 printf (" CONFEXP");
7362 val
^= DTF_1_CONFEXP
;
7365 printf (" %lx", val
);
7374 printf (_("Flags:"));
7376 if (entry
->d_un
.d_val
== 0)
7377 printf (_(" None\n"));
7380 unsigned long int val
= entry
->d_un
.d_val
;
7382 if (val
& DF_P1_LAZYLOAD
)
7384 printf (" LAZYLOAD");
7385 val
^= DF_P1_LAZYLOAD
;
7387 if (val
& DF_P1_GROUPPERM
)
7389 printf (" GROUPPERM");
7390 val
^= DF_P1_GROUPPERM
;
7393 printf (" %lx", val
);
7402 printf (_("Flags:"));
7403 if (entry
->d_un
.d_val
== 0)
7404 printf (_(" None\n"));
7407 unsigned long int val
= entry
->d_un
.d_val
;
7414 if (val
& DF_1_GLOBAL
)
7419 if (val
& DF_1_GROUP
)
7424 if (val
& DF_1_NODELETE
)
7426 printf (" NODELETE");
7427 val
^= DF_1_NODELETE
;
7429 if (val
& DF_1_LOADFLTR
)
7431 printf (" LOADFLTR");
7432 val
^= DF_1_LOADFLTR
;
7434 if (val
& DF_1_INITFIRST
)
7436 printf (" INITFIRST");
7437 val
^= DF_1_INITFIRST
;
7439 if (val
& DF_1_NOOPEN
)
7444 if (val
& DF_1_ORIGIN
)
7449 if (val
& DF_1_DIRECT
)
7454 if (val
& DF_1_TRANS
)
7459 if (val
& DF_1_INTERPOSE
)
7461 printf (" INTERPOSE");
7462 val
^= DF_1_INTERPOSE
;
7464 if (val
& DF_1_NODEFLIB
)
7466 printf (" NODEFLIB");
7467 val
^= DF_1_NODEFLIB
;
7469 if (val
& DF_1_NODUMP
)
7474 if (val
& DF_1_CONLFAT
)
7476 printf (" CONLFAT");
7477 val
^= DF_1_CONLFAT
;
7480 printf (" %lx", val
);
7487 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7489 puts (get_dynamic_type (entry
->d_un
.d_val
));
7509 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7515 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7516 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7522 switch (entry
->d_tag
)
7525 printf (_("Shared library: [%s]"), name
);
7527 if (streq (name
, program_interpreter
))
7528 printf (_(" program interpreter"));
7532 printf (_("Library soname: [%s]"), name
);
7536 printf (_("Library rpath: [%s]"), name
);
7540 printf (_("Library runpath: [%s]"), name
);
7544 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7549 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7562 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7566 case DT_INIT_ARRAYSZ
:
7567 case DT_FINI_ARRAYSZ
:
7568 case DT_GNU_CONFLICTSZ
:
7569 case DT_GNU_LIBLISTSZ
:
7572 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7573 printf (_(" (bytes)\n"));
7583 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7596 if (entry
->d_tag
== DT_USED
7597 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7599 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7603 printf (_("Not needed object: [%s]\n"), name
);
7608 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7614 /* The value of this entry is ignored. */
7619 case DT_GNU_PRELINKED
:
7623 time_t atime
= entry
->d_un
.d_val
;
7625 tmp
= gmtime (&atime
);
7626 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7627 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7628 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7634 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7637 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7643 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7644 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7649 switch (elf_header
.e_machine
)
7652 case EM_MIPS_RS3_LE
:
7653 dynamic_section_mips_val (entry
);
7656 dynamic_section_parisc_val (entry
);
7659 dynamic_section_ia64_val (entry
);
7662 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7674 get_ver_flags (unsigned int flags
)
7676 static char buff
[32];
7683 if (flags
& VER_FLG_BASE
)
7684 strcat (buff
, "BASE ");
7686 if (flags
& VER_FLG_WEAK
)
7688 if (flags
& VER_FLG_BASE
)
7689 strcat (buff
, "| ");
7691 strcat (buff
, "WEAK ");
7694 if (flags
& VER_FLG_INFO
)
7696 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7697 strcat (buff
, "| ");
7699 strcat (buff
, "INFO ");
7702 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7703 strcat (buff
, _("| <unknown>"));
7708 /* Display the contents of the version sections. */
7711 process_version_sections (FILE * file
)
7713 Elf_Internal_Shdr
* section
;
7720 for (i
= 0, section
= section_headers
;
7721 i
< elf_header
.e_shnum
;
7724 switch (section
->sh_type
)
7726 case SHT_GNU_verdef
:
7728 Elf_External_Verdef
* edefs
;
7736 (_("\nVersion definition section '%s' contains %u entries:\n"),
7737 SECTION_NAME (section
), section
->sh_info
);
7739 printf (_(" Addr: 0x"));
7740 printf_vma (section
->sh_addr
);
7741 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7742 (unsigned long) section
->sh_offset
, section
->sh_link
,
7743 section
->sh_link
< elf_header
.e_shnum
7744 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7747 edefs
= (Elf_External_Verdef
*)
7748 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7749 _("version definition section"));
7750 endbuf
= (char *) edefs
+ section
->sh_size
;
7754 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7757 Elf_External_Verdef
* edef
;
7758 Elf_Internal_Verdef ent
;
7759 Elf_External_Verdaux
* eaux
;
7760 Elf_Internal_Verdaux aux
;
7764 /* Check for negative or very large indicies. */
7765 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
7768 vstart
= ((char *) edefs
) + idx
;
7769 if (vstart
+ sizeof (*edef
) > endbuf
)
7772 edef
= (Elf_External_Verdef
*) vstart
;
7774 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7775 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7776 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7777 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7778 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7779 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7780 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7782 printf (_(" %#06x: Rev: %d Flags: %s"),
7783 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7785 printf (_(" Index: %d Cnt: %d "),
7786 ent
.vd_ndx
, ent
.vd_cnt
);
7788 /* Check for overflow. */
7789 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
7790 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
7793 vstart
+= ent
.vd_aux
;
7795 eaux
= (Elf_External_Verdaux
*) vstart
;
7797 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7798 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7800 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7801 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7803 printf (_("Name index: %ld\n"), aux
.vda_name
);
7805 isum
= idx
+ ent
.vd_aux
;
7807 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7809 /* Check for overflow. */
7810 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
7811 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
7814 isum
+= aux
.vda_next
;
7815 vstart
+= aux
.vda_next
;
7817 eaux
= (Elf_External_Verdaux
*) vstart
;
7818 if (vstart
+ sizeof (*eaux
) > endbuf
)
7821 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7822 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7824 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7825 printf (_(" %#06x: Parent %d: %s\n"),
7826 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7828 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7829 isum
, j
, aux
.vda_name
);
7833 printf (_(" Version def aux past end of section\n"));
7838 if (cnt
< section
->sh_info
)
7839 printf (_(" Version definition past end of section\n"));
7845 case SHT_GNU_verneed
:
7847 Elf_External_Verneed
* eneed
;
7854 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7855 SECTION_NAME (section
), section
->sh_info
);
7857 printf (_(" Addr: 0x"));
7858 printf_vma (section
->sh_addr
);
7859 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7860 (unsigned long) section
->sh_offset
, section
->sh_link
,
7861 section
->sh_link
< elf_header
.e_shnum
7862 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7865 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7866 section
->sh_offset
, 1,
7868 _("version need section"));
7869 endbuf
= (char *) eneed
+ section
->sh_size
;
7873 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7875 Elf_External_Verneed
* entry
;
7876 Elf_Internal_Verneed ent
;
7881 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
7884 vstart
= ((char *) eneed
) + idx
;
7885 if (vstart
+ sizeof (*entry
) > endbuf
)
7888 entry
= (Elf_External_Verneed
*) vstart
;
7890 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7891 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7892 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7893 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7894 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7896 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7898 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7899 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7901 printf (_(" File: %lx"), ent
.vn_file
);
7903 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7905 /* Check for overflow. */
7906 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
7907 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
7910 vstart
+= ent
.vn_aux
;
7912 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7914 Elf_External_Vernaux
* eaux
;
7915 Elf_Internal_Vernaux aux
;
7917 if (vstart
+ sizeof (*eaux
) > endbuf
)
7919 eaux
= (Elf_External_Vernaux
*) vstart
;
7921 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7922 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7923 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7924 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7925 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7927 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7928 printf (_(" %#06x: Name: %s"),
7929 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7931 printf (_(" %#06x: Name index: %lx"),
7932 isum
, aux
.vna_name
);
7934 printf (_(" Flags: %s Version: %d\n"),
7935 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7937 /* Check for overflow. */
7938 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
7939 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
7942 isum
+= aux
.vna_next
;
7943 vstart
+= aux
.vna_next
;
7946 printf (_(" Version need aux past end of section\n"));
7950 if (cnt
< section
->sh_info
)
7951 printf (_(" Version need past end of section\n"));
7957 case SHT_GNU_versym
:
7959 Elf_Internal_Shdr
* link_section
;
7962 unsigned char * edata
;
7963 unsigned short * data
;
7965 Elf_Internal_Sym
* symbols
;
7966 Elf_Internal_Shdr
* string_sec
;
7969 if (section
->sh_link
>= elf_header
.e_shnum
)
7972 link_section
= section_headers
+ section
->sh_link
;
7973 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7975 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7980 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7981 if (symbols
== NULL
)
7984 string_sec
= section_headers
+ link_section
->sh_link
;
7986 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7987 string_sec
->sh_size
,
7988 _("version string table"));
7992 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7993 SECTION_NAME (section
), total
);
7995 printf (_(" Addr: "));
7996 printf_vma (section
->sh_addr
);
7997 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7998 (unsigned long) section
->sh_offset
, section
->sh_link
,
7999 SECTION_NAME (link_section
));
8001 off
= offset_from_vma (file
,
8002 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8003 total
* sizeof (short));
8004 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8006 _("version symbol data"));
8013 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8015 for (cnt
= total
; cnt
--;)
8016 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8021 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8024 int check_def
, check_need
;
8027 printf (" %03x:", cnt
);
8029 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8030 switch (data
[cnt
+ j
])
8033 fputs (_(" 0 (*local*) "), stdout
);
8037 fputs (_(" 1 (*global*) "), stdout
);
8041 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8042 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8044 /* If this index value is greater than the size of the symbols
8045 array, break to avoid an out-of-bounds read, */
8046 if ((unsigned long)(cnt
+ j
) >=
8047 ((unsigned long)link_section
->sh_size
/
8048 (unsigned long)link_section
->sh_entsize
))
8050 warn (_("invalid index into symbol array\n"));
8056 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8057 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8060 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8067 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8069 Elf_Internal_Verneed ivn
;
8070 unsigned long offset
;
8072 offset
= offset_from_vma
8073 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8074 sizeof (Elf_External_Verneed
));
8078 Elf_Internal_Vernaux ivna
;
8079 Elf_External_Verneed evn
;
8080 Elf_External_Vernaux evna
;
8081 unsigned long a_off
;
8083 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8086 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8087 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8089 a_off
= offset
+ ivn
.vn_aux
;
8093 get_data (&evna
, file
, a_off
, sizeof (evna
),
8094 1, _("version need aux (2)"));
8096 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8097 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8099 a_off
+= ivna
.vna_next
;
8101 while (ivna
.vna_other
!= data
[cnt
+ j
]
8102 && ivna
.vna_next
!= 0);
8104 if (ivna
.vna_other
== data
[cnt
+ j
])
8106 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8108 if (ivna
.vna_name
>= string_sec
->sh_size
)
8109 name
= _("*invalid*");
8111 name
= strtab
+ ivna
.vna_name
;
8112 nn
+= printf ("(%s%-*s",
8114 12 - (int) strlen (name
),
8120 offset
+= ivn
.vn_next
;
8122 while (ivn
.vn_next
);
8125 if (check_def
&& data
[cnt
+ j
] != 0x8001
8126 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8128 Elf_Internal_Verdef ivd
;
8129 Elf_External_Verdef evd
;
8130 unsigned long offset
;
8132 offset
= offset_from_vma
8133 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8138 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8141 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8142 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8144 offset
+= ivd
.vd_next
;
8146 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8147 && ivd
.vd_next
!= 0);
8149 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8151 Elf_External_Verdaux evda
;
8152 Elf_Internal_Verdaux ivda
;
8154 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8156 get_data (&evda
, file
,
8157 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8159 _("version def aux"));
8161 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8163 if (ivda
.vda_name
>= string_sec
->sh_size
)
8164 name
= _("*invalid*");
8166 name
= strtab
+ ivda
.vda_name
;
8167 nn
+= printf ("(%s%-*s",
8169 12 - (int) strlen (name
),
8175 printf ("%*c", 18 - nn
, ' ');
8193 printf (_("\nNo version information found in this file.\n"));
8199 get_symbol_binding (unsigned int binding
)
8201 static char buff
[32];
8205 case STB_LOCAL
: return "LOCAL";
8206 case STB_GLOBAL
: return "GLOBAL";
8207 case STB_WEAK
: return "WEAK";
8209 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8210 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8212 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8214 if (binding
== STB_GNU_UNIQUE
8215 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8216 /* GNU/Linux is still using the default value 0. */
8217 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8219 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8222 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8228 get_symbol_type (unsigned int type
)
8230 static char buff
[32];
8234 case STT_NOTYPE
: return "NOTYPE";
8235 case STT_OBJECT
: return "OBJECT";
8236 case STT_FUNC
: return "FUNC";
8237 case STT_SECTION
: return "SECTION";
8238 case STT_FILE
: return "FILE";
8239 case STT_COMMON
: return "COMMON";
8240 case STT_TLS
: return "TLS";
8241 case STT_RELC
: return "RELC";
8242 case STT_SRELC
: return "SRELC";
8244 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8246 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8247 return "THUMB_FUNC";
8249 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8252 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8253 return "PARISC_MILLI";
8255 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8257 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8259 if (elf_header
.e_machine
== EM_PARISC
)
8261 if (type
== STT_HP_OPAQUE
)
8263 if (type
== STT_HP_STUB
)
8267 if (type
== STT_GNU_IFUNC
8268 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8269 /* GNU/Linux is still using the default value 0. */
8270 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8273 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8276 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8282 get_symbol_visibility (unsigned int visibility
)
8286 case STV_DEFAULT
: return "DEFAULT";
8287 case STV_INTERNAL
: return "INTERNAL";
8288 case STV_HIDDEN
: return "HIDDEN";
8289 case STV_PROTECTED
: return "PROTECTED";
8295 get_mips_symbol_other (unsigned int other
)
8299 case STO_OPTIONAL
: return "OPTIONAL";
8300 case STO_MIPS16
: return "MIPS16";
8301 case STO_MIPS_PLT
: return "MIPS PLT";
8302 case STO_MIPS_PIC
: return "MIPS PIC";
8303 default: return NULL
;
8308 get_ia64_symbol_other (unsigned int other
)
8312 static char res
[32];
8316 /* Function types is for images and .STB files only. */
8317 switch (elf_header
.e_type
)
8321 switch (VMS_ST_FUNC_TYPE (other
))
8323 case VMS_SFT_CODE_ADDR
:
8324 strcat (res
, " CA");
8326 case VMS_SFT_SYMV_IDX
:
8327 strcat (res
, " VEC");
8330 strcat (res
, " FD");
8332 case VMS_SFT_RESERVE
:
8333 strcat (res
, " RSV");
8342 switch (VMS_ST_LINKAGE (other
))
8344 case VMS_STL_IGNORE
:
8345 strcat (res
, " IGN");
8347 case VMS_STL_RESERVE
:
8348 strcat (res
, " RSV");
8351 strcat (res
, " STD");
8354 strcat (res
, " LNK");
8369 get_symbol_other (unsigned int other
)
8371 const char * result
= NULL
;
8372 static char buff
[32];
8377 switch (elf_header
.e_machine
)
8380 result
= get_mips_symbol_other (other
);
8383 result
= get_ia64_symbol_other (other
);
8392 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8397 get_symbol_index_type (unsigned int type
)
8399 static char buff
[32];
8403 case SHN_UNDEF
: return "UND";
8404 case SHN_ABS
: return "ABS";
8405 case SHN_COMMON
: return "COM";
8407 if (type
== SHN_IA_64_ANSI_COMMON
8408 && elf_header
.e_machine
== EM_IA_64
8409 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8411 else if ((elf_header
.e_machine
== EM_X86_64
8412 || elf_header
.e_machine
== EM_L1OM
)
8413 && type
== SHN_X86_64_LCOMMON
)
8415 else if (type
== SHN_MIPS_SCOMMON
8416 && elf_header
.e_machine
== EM_MIPS
)
8418 else if (type
== SHN_MIPS_SUNDEFINED
8419 && elf_header
.e_machine
== EM_MIPS
)
8421 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8422 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8423 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8424 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8425 else if (type
>= SHN_LORESERVE
)
8426 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8428 sprintf (buff
, "%3d", type
);
8436 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8438 unsigned char * e_data
;
8441 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8445 error (_("Out of memory\n"));
8449 if (fread (e_data
, ent_size
, number
, file
) != number
)
8451 error (_("Unable to read in dynamic data\n"));
8455 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8459 error (_("Out of memory\n"));
8465 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8473 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8475 Elf_Internal_Sym
* psym
;
8478 psym
= dynamic_symbols
+ si
;
8480 n
= print_vma (si
, DEC_5
);
8482 fputs (" " + n
, stdout
);
8483 printf (" %3lu: ", hn
);
8484 print_vma (psym
->st_value
, LONG_HEX
);
8486 print_vma (psym
->st_size
, DEC_5
);
8488 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8489 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8490 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8491 /* Check to see if any other bits in the st_other field are set.
8492 Note - displaying this information disrupts the layout of the
8493 table being generated, but for the moment this case is very
8495 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8496 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8497 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8498 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8499 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8501 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8505 /* Dump the symbol table. */
8507 process_symbol_table (FILE * file
)
8509 Elf_Internal_Shdr
* section
;
8510 bfd_vma nbuckets
= 0;
8511 bfd_vma nchains
= 0;
8512 bfd_vma
* buckets
= NULL
;
8513 bfd_vma
* chains
= NULL
;
8514 bfd_vma ngnubuckets
= 0;
8515 bfd_vma
* gnubuckets
= NULL
;
8516 bfd_vma
* gnuchains
= NULL
;
8517 bfd_vma gnusymidx
= 0;
8519 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8522 if (dynamic_info
[DT_HASH
]
8524 || (do_using_dynamic
8526 && dynamic_strings
!= NULL
)))
8528 unsigned char nb
[8];
8529 unsigned char nc
[8];
8530 int hash_ent_size
= 4;
8532 if ((elf_header
.e_machine
== EM_ALPHA
8533 || elf_header
.e_machine
== EM_S390
8534 || elf_header
.e_machine
== EM_S390_OLD
)
8535 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8539 (archive_file_offset
8540 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8541 sizeof nb
+ sizeof nc
)),
8544 error (_("Unable to seek to start of dynamic information\n"));
8548 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8550 error (_("Failed to read in number of buckets\n"));
8554 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8556 error (_("Failed to read in number of chains\n"));
8560 nbuckets
= byte_get (nb
, hash_ent_size
);
8561 nchains
= byte_get (nc
, hash_ent_size
);
8563 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8564 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8567 if (buckets
== NULL
|| chains
== NULL
)
8569 if (do_using_dynamic
)
8580 if (dynamic_info_DT_GNU_HASH
8582 || (do_using_dynamic
8584 && dynamic_strings
!= NULL
)))
8586 unsigned char nb
[16];
8587 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8588 bfd_vma buckets_vma
;
8591 (archive_file_offset
8592 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8596 error (_("Unable to seek to start of dynamic information\n"));
8600 if (fread (nb
, 16, 1, file
) != 1)
8602 error (_("Failed to read in number of buckets\n"));
8606 ngnubuckets
= byte_get (nb
, 4);
8607 gnusymidx
= byte_get (nb
+ 4, 4);
8608 bitmaskwords
= byte_get (nb
+ 8, 4);
8609 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8611 buckets_vma
+= bitmaskwords
* 4;
8613 buckets_vma
+= bitmaskwords
* 8;
8616 (archive_file_offset
8617 + offset_from_vma (file
, buckets_vma
, 4)),
8620 error (_("Unable to seek to start of dynamic information\n"));
8624 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8626 if (gnubuckets
== NULL
)
8629 for (i
= 0; i
< ngnubuckets
; i
++)
8630 if (gnubuckets
[i
] != 0)
8632 if (gnubuckets
[i
] < gnusymidx
)
8635 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8636 maxchain
= gnubuckets
[i
];
8639 if (maxchain
== 0xffffffff)
8642 maxchain
-= gnusymidx
;
8645 (archive_file_offset
8646 + offset_from_vma (file
, buckets_vma
8647 + 4 * (ngnubuckets
+ maxchain
), 4)),
8650 error (_("Unable to seek to start of dynamic information\n"));
8656 if (fread (nb
, 4, 1, file
) != 1)
8658 error (_("Failed to determine last chain length\n"));
8662 if (maxchain
+ 1 == 0)
8667 while ((byte_get (nb
, 4) & 1) == 0);
8670 (archive_file_offset
8671 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8674 error (_("Unable to seek to start of dynamic information\n"));
8678 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8681 if (gnuchains
== NULL
)
8686 if (do_using_dynamic
)
8691 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8694 && dynamic_strings
!= NULL
)
8698 if (dynamic_info
[DT_HASH
])
8702 printf (_("\nSymbol table for image:\n"));
8704 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8706 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8708 for (hn
= 0; hn
< nbuckets
; hn
++)
8713 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8714 print_dynamic_symbol (si
, hn
);
8718 if (dynamic_info_DT_GNU_HASH
)
8720 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8722 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8724 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8726 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8727 if (gnubuckets
[hn
] != 0)
8729 bfd_vma si
= gnubuckets
[hn
];
8730 bfd_vma off
= si
- gnusymidx
;
8734 print_dynamic_symbol (si
, hn
);
8737 while ((gnuchains
[off
++] & 1) == 0);
8741 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8745 for (i
= 0, section
= section_headers
;
8746 i
< elf_header
.e_shnum
;
8750 char * strtab
= NULL
;
8751 unsigned long int strtab_size
= 0;
8752 Elf_Internal_Sym
* symtab
;
8753 Elf_Internal_Sym
* psym
;
8755 if ((section
->sh_type
!= SHT_SYMTAB
8756 && section
->sh_type
!= SHT_DYNSYM
)
8758 && section
->sh_type
== SHT_SYMTAB
))
8761 if (section
->sh_entsize
== 0)
8763 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8764 SECTION_NAME (section
));
8768 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8769 SECTION_NAME (section
),
8770 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8773 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8775 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8777 symtab
= GET_ELF_SYMBOLS (file
, section
);
8781 if (section
->sh_link
== elf_header
.e_shstrndx
)
8783 strtab
= string_table
;
8784 strtab_size
= string_table_length
;
8786 else if (section
->sh_link
< elf_header
.e_shnum
)
8788 Elf_Internal_Shdr
* string_sec
;
8790 string_sec
= section_headers
+ section
->sh_link
;
8792 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8793 1, string_sec
->sh_size
,
8795 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8798 for (si
= 0, psym
= symtab
;
8799 si
< section
->sh_size
/ section
->sh_entsize
;
8802 printf ("%6d: ", si
);
8803 print_vma (psym
->st_value
, LONG_HEX
);
8805 print_vma (psym
->st_size
, DEC_5
);
8806 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8807 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8808 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8809 /* Check to see if any other bits in the st_other field are set.
8810 Note - displaying this information disrupts the layout of the
8811 table being generated, but for the moment this case is very rare. */
8812 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8813 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8814 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8815 print_symbol (25, psym
->st_name
< strtab_size
8816 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8818 if (section
->sh_type
== SHT_DYNSYM
&&
8819 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8821 unsigned char data
[2];
8822 unsigned short vers_data
;
8823 unsigned long offset
;
8827 offset
= offset_from_vma
8828 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8829 sizeof data
+ si
* sizeof (vers_data
));
8831 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8832 sizeof (data
), 1, _("version data"));
8834 vers_data
= byte_get (data
, 2);
8836 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8837 && section_headers
[psym
->st_shndx
].sh_type
8840 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8842 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8844 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8845 && (is_nobits
|| ! check_def
))
8847 Elf_External_Verneed evn
;
8848 Elf_Internal_Verneed ivn
;
8849 Elf_Internal_Vernaux ivna
;
8851 /* We must test both. */
8852 offset
= offset_from_vma
8853 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8858 unsigned long vna_off
;
8860 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8863 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8864 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8866 vna_off
= offset
+ ivn
.vn_aux
;
8870 Elf_External_Vernaux evna
;
8872 get_data (&evna
, file
, vna_off
,
8874 _("version need aux (3)"));
8876 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8877 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8878 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8880 vna_off
+= ivna
.vna_next
;
8882 while (ivna
.vna_other
!= vers_data
8883 && ivna
.vna_next
!= 0);
8885 if (ivna
.vna_other
== vers_data
)
8888 offset
+= ivn
.vn_next
;
8890 while (ivn
.vn_next
!= 0);
8892 if (ivna
.vna_other
== vers_data
)
8895 ivna
.vna_name
< strtab_size
8896 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8900 else if (! is_nobits
)
8901 error (_("bad dynamic symbol\n"));
8908 if (vers_data
!= 0x8001
8909 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8911 Elf_Internal_Verdef ivd
;
8912 Elf_Internal_Verdaux ivda
;
8913 Elf_External_Verdaux evda
;
8916 off
= offset_from_vma
8918 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8919 sizeof (Elf_External_Verdef
));
8923 Elf_External_Verdef evd
;
8925 get_data (&evd
, file
, off
, sizeof (evd
),
8926 1, _("version def"));
8928 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8929 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8930 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8934 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8935 && ivd
.vd_next
!= 0);
8940 get_data (&evda
, file
, off
, sizeof (evda
),
8941 1, _("version def aux"));
8943 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8945 if (psym
->st_name
!= ivda
.vda_name
)
8946 printf ((vers_data
& VERSYM_HIDDEN
)
8948 ivda
.vda_name
< strtab_size
8949 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8959 if (strtab
!= string_table
)
8965 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8967 if (do_histogram
&& buckets
!= NULL
)
8969 unsigned long * lengths
;
8970 unsigned long * counts
;
8973 unsigned long maxlength
= 0;
8974 unsigned long nzero_counts
= 0;
8975 unsigned long nsyms
= 0;
8977 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8978 (unsigned long) nbuckets
);
8979 printf (_(" Length Number %% of total Coverage\n"));
8981 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8982 if (lengths
== NULL
)
8984 error (_("Out of memory\n"));
8987 for (hn
= 0; hn
< nbuckets
; ++hn
)
8989 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8992 if (maxlength
< ++lengths
[hn
])
8997 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9000 error (_("Out of memory\n"));
9004 for (hn
= 0; hn
< nbuckets
; ++hn
)
9005 ++counts
[lengths
[hn
]];
9010 printf (" 0 %-10lu (%5.1f%%)\n",
9011 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9012 for (i
= 1; i
<= maxlength
; ++i
)
9014 nzero_counts
+= counts
[i
] * i
;
9015 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9016 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9017 (nzero_counts
* 100.0) / nsyms
);
9025 if (buckets
!= NULL
)
9031 if (do_histogram
&& gnubuckets
!= NULL
)
9033 unsigned long * lengths
;
9034 unsigned long * counts
;
9036 unsigned long maxlength
= 0;
9037 unsigned long nzero_counts
= 0;
9038 unsigned long nsyms
= 0;
9040 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9041 if (lengths
== NULL
)
9043 error (_("Out of memory\n"));
9047 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9048 (unsigned long) ngnubuckets
);
9049 printf (_(" Length Number %% of total Coverage\n"));
9051 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9052 if (gnubuckets
[hn
] != 0)
9054 bfd_vma off
, length
= 1;
9056 for (off
= gnubuckets
[hn
] - gnusymidx
;
9057 (gnuchains
[off
] & 1) == 0; ++off
)
9059 lengths
[hn
] = length
;
9060 if (length
> maxlength
)
9065 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9068 error (_("Out of memory\n"));
9072 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9073 ++counts
[lengths
[hn
]];
9075 if (ngnubuckets
> 0)
9078 printf (" 0 %-10lu (%5.1f%%)\n",
9079 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9080 for (j
= 1; j
<= maxlength
; ++j
)
9082 nzero_counts
+= counts
[j
] * j
;
9083 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9084 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9085 (nzero_counts
* 100.0) / nsyms
);
9099 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9103 if (dynamic_syminfo
== NULL
9105 /* No syminfo, this is ok. */
9108 /* There better should be a dynamic symbol section. */
9109 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9113 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9114 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9116 printf (_(" Num: Name BoundTo Flags\n"));
9117 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9119 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9121 printf ("%4d: ", i
);
9122 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9123 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9125 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9128 switch (dynamic_syminfo
[i
].si_boundto
)
9130 case SYMINFO_BT_SELF
:
9131 fputs ("SELF ", stdout
);
9133 case SYMINFO_BT_PARENT
:
9134 fputs ("PARENT ", stdout
);
9137 if (dynamic_syminfo
[i
].si_boundto
> 0
9138 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9139 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9141 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9145 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9149 if (flags
& SYMINFO_FLG_DIRECT
)
9151 if (flags
& SYMINFO_FLG_PASSTHRU
)
9152 printf (" PASSTHRU");
9153 if (flags
& SYMINFO_FLG_COPY
)
9155 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9156 printf (" LAZYLOAD");
9164 /* Check to see if the given reloc needs to be handled in a target specific
9165 manner. If so then process the reloc and return TRUE otherwise return
9169 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9170 unsigned char * start
,
9171 Elf_Internal_Sym
* symtab
)
9173 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9175 switch (elf_header
.e_machine
)
9178 case EM_CYGNUS_MN10300
:
9180 static Elf_Internal_Sym
* saved_sym
= NULL
;
9184 case 34: /* R_MN10300_ALIGN */
9186 case 33: /* R_MN10300_SYM_DIFF */
9187 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9189 case 1: /* R_MN10300_32 */
9190 case 2: /* R_MN10300_16 */
9191 if (saved_sym
!= NULL
)
9195 value
= reloc
->r_addend
9196 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9197 - saved_sym
->st_value
);
9199 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9206 if (saved_sym
!= NULL
)
9207 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9217 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9218 DWARF debug sections. This is a target specific test. Note - we do not
9219 go through the whole including-target-headers-multiple-times route, (as
9220 we have already done with <elf/h8.h>) because this would become very
9221 messy and even then this function would have to contain target specific
9222 information (the names of the relocs instead of their numeric values).
9223 FIXME: This is not the correct way to solve this problem. The proper way
9224 is to have target specific reloc sizing and typing functions created by
9225 the reloc-macros.h header, in the same way that it already creates the
9226 reloc naming functions. */
9229 is_32bit_abs_reloc (unsigned int reloc_type
)
9231 switch (elf_header
.e_machine
)
9235 return reloc_type
== 1; /* R_386_32. */
9237 return reloc_type
== 1; /* R_68K_32. */
9239 return reloc_type
== 1; /* R_860_32. */
9241 return reloc_type
== 2; /* R_960_32. */
9243 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
9245 return reloc_type
== 1; /* R_ARC_32. */
9247 return reloc_type
== 2; /* R_ARM_ABS32 */
9250 return reloc_type
== 1;
9252 return reloc_type
== 0x12; /* R_byte4_data. */
9254 return reloc_type
== 3; /* R_CRIS_32. */
9257 return reloc_type
== 3; /* R_CR16_NUM32. */
9259 return reloc_type
== 15; /* R_CRX_NUM32. */
9261 return reloc_type
== 1;
9262 case EM_CYGNUS_D10V
:
9264 return reloc_type
== 6; /* R_D10V_32. */
9265 case EM_CYGNUS_D30V
:
9267 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9269 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9270 case EM_CYGNUS_FR30
:
9272 return reloc_type
== 3; /* R_FR30_32. */
9276 return reloc_type
== 1; /* R_H8_DIR32. */
9278 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9281 return reloc_type
== 2; /* R_IP2K_32. */
9283 return reloc_type
== 2; /* R_IQ2000_32. */
9284 case EM_LATTICEMICO32
:
9285 return reloc_type
== 3; /* R_LM32_32. */
9288 return reloc_type
== 3; /* R_M32C_32. */
9290 return reloc_type
== 34; /* R_M32R_32_RELA. */
9292 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9294 return reloc_type
== 4; /* R_MEP_32. */
9296 return reloc_type
== 1; /* R_MICROBLAZE_32. */
9298 return reloc_type
== 2; /* R_MIPS_32. */
9300 return reloc_type
== 4; /* R_MMIX_32. */
9301 case EM_CYGNUS_MN10200
:
9303 return reloc_type
== 1; /* R_MN10200_32. */
9304 case EM_CYGNUS_MN10300
:
9306 return reloc_type
== 1; /* R_MN10300_32. */
9308 return reloc_type
== 1; /* R_MOXIE_32. */
9311 return reloc_type
== 1; /* R_MSP43_32. */
9313 return reloc_type
== 2; /* R_MT_32. */
9314 case EM_ALTERA_NIOS2
:
9316 return reloc_type
== 1; /* R_NIOS_32. */
9319 return reloc_type
== 1; /* R_OR32_32. */
9321 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9322 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9325 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9327 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9329 return reloc_type
== 1; /* R_PPC_ADDR32. */
9331 return reloc_type
== 1; /* R_RX_DIR32. */
9333 return reloc_type
== 1; /* R_I370_ADDR31. */
9336 return reloc_type
== 4; /* R_S390_32. */
9338 return reloc_type
== 8; /* R_SCORE_ABS32. */
9340 return reloc_type
== 1; /* R_SH_DIR32. */
9341 case EM_SPARC32PLUS
:
9344 return reloc_type
== 3 /* R_SPARC_32. */
9345 || reloc_type
== 23; /* R_SPARC_UA32. */
9347 return reloc_type
== 6; /* R_SPU_ADDR32 */
9349 return reloc_type
== 1; /* R_C6000_ABS32. */
9350 case EM_CYGNUS_V850
:
9352 return reloc_type
== 6; /* R_V850_ABS32. */
9354 return reloc_type
== 1; /* R_VAX_32. */
9357 return reloc_type
== 10; /* R_X86_64_32. */
9360 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9362 return reloc_type
== 1; /* R_XSTROMY16_32. */
9365 return reloc_type
== 1; /* R_XTENSA_32. */
9367 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9368 elf_header
.e_machine
);
9373 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9374 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9377 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9379 switch (elf_header
.e_machine
)
9383 return reloc_type
== 2; /* R_386_PC32. */
9385 return reloc_type
== 4; /* R_68K_PC32. */
9387 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9389 return reloc_type
== 3; /* R_ARM_REL32 */
9391 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
9393 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9395 return reloc_type
== 26; /* R_PPC_REL32. */
9397 return reloc_type
== 26; /* R_PPC64_REL32. */
9400 return reloc_type
== 5; /* R_390_PC32. */
9402 return reloc_type
== 2; /* R_SH_REL32. */
9403 case EM_SPARC32PLUS
:
9406 return reloc_type
== 6; /* R_SPARC_DISP32. */
9408 return reloc_type
== 13; /* R_SPU_REL32. */
9411 return reloc_type
== 2; /* R_X86_64_PC32. */
9414 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9416 /* Do not abort or issue an error message here. Not all targets use
9417 pc-relative 32-bit relocs in their DWARF debug information and we
9418 have already tested for target coverage in is_32bit_abs_reloc. A
9419 more helpful warning message will be generated by apply_relocations
9420 anyway, so just return. */
9425 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9426 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9429 is_64bit_abs_reloc (unsigned int reloc_type
)
9431 switch (elf_header
.e_machine
)
9434 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9436 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9438 return reloc_type
== 80; /* R_PARISC_DIR64. */
9440 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9441 case EM_SPARC32PLUS
:
9444 return reloc_type
== 54; /* R_SPARC_UA64. */
9447 return reloc_type
== 1; /* R_X86_64_64. */
9450 return reloc_type
== 22; /* R_S390_64 */
9452 return reloc_type
== 18; /* R_MIPS_64 */
9458 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9459 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9462 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9464 switch (elf_header
.e_machine
)
9467 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9469 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9471 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9473 return reloc_type
== 44; /* R_PPC64_REL64 */
9474 case EM_SPARC32PLUS
:
9477 return reloc_type
== 46; /* R_SPARC_DISP64 */
9480 return reloc_type
== 24; /* R_X86_64_PC64 */
9483 return reloc_type
== 23; /* R_S390_PC64 */
9489 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9490 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9493 is_24bit_abs_reloc (unsigned int reloc_type
)
9495 switch (elf_header
.e_machine
)
9497 case EM_CYGNUS_MN10200
:
9499 return reloc_type
== 4; /* R_MN10200_24. */
9505 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9506 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9509 is_16bit_abs_reloc (unsigned int reloc_type
)
9511 switch (elf_header
.e_machine
)
9515 return reloc_type
== 4; /* R_AVR_16. */
9516 case EM_CYGNUS_D10V
:
9518 return reloc_type
== 3; /* R_D10V_16. */
9522 return reloc_type
== R_H8_DIR16
;
9525 return reloc_type
== 1; /* R_IP2K_16. */
9528 return reloc_type
== 1; /* R_M32C_16 */
9531 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9532 case EM_ALTERA_NIOS2
:
9534 return reloc_type
== 9; /* R_NIOS_16. */
9536 return reloc_type
== 2; /* R_C6000_ABS16. */
9539 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9545 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9546 relocation entries (possibly formerly used for SHT_GROUP sections). */
9549 is_none_reloc (unsigned int reloc_type
)
9551 switch (elf_header
.e_machine
)
9553 case EM_68K
: /* R_68K_NONE. */
9554 case EM_386
: /* R_386_NONE. */
9555 case EM_SPARC32PLUS
:
9557 case EM_SPARC
: /* R_SPARC_NONE. */
9558 case EM_MIPS
: /* R_MIPS_NONE. */
9559 case EM_PARISC
: /* R_PARISC_NONE. */
9560 case EM_ALPHA
: /* R_ALPHA_NONE. */
9561 case EM_PPC
: /* R_PPC_NONE. */
9562 case EM_PPC64
: /* R_PPC64_NONE. */
9563 case EM_ARM
: /* R_ARM_NONE. */
9564 case EM_IA_64
: /* R_IA64_NONE. */
9565 case EM_SH
: /* R_SH_NONE. */
9567 case EM_S390
: /* R_390_NONE. */
9568 case EM_CRIS
: /* R_CRIS_NONE. */
9569 case EM_X86_64
: /* R_X86_64_NONE. */
9570 case EM_L1OM
: /* R_X86_64_NONE. */
9571 case EM_MN10300
: /* R_MN10300_NONE. */
9572 case EM_MOXIE
: /* R_MOXIE_NONE. */
9573 case EM_M32R
: /* R_M32R_NONE. */
9574 case EM_TI_C6000
:/* R_C6000_NONE. */
9576 case EM_C166
: /* R_XC16X_NONE. */
9577 return reloc_type
== 0;
9580 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9581 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9582 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9583 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9588 /* Apply relocations to a section.
9589 Note: So far support has been added only for those relocations
9590 which can be found in debug sections.
9591 FIXME: Add support for more relocations ? */
9594 apply_relocations (void * file
,
9595 Elf_Internal_Shdr
* section
,
9596 unsigned char * start
)
9598 Elf_Internal_Shdr
* relsec
;
9599 unsigned char * end
= start
+ section
->sh_size
;
9601 if (elf_header
.e_type
!= ET_REL
)
9604 /* Find the reloc section associated with the section. */
9605 for (relsec
= section_headers
;
9606 relsec
< section_headers
+ elf_header
.e_shnum
;
9609 bfd_boolean is_rela
;
9610 unsigned long num_relocs
;
9611 Elf_Internal_Rela
* relocs
;
9612 Elf_Internal_Rela
* rp
;
9613 Elf_Internal_Shdr
* symsec
;
9614 Elf_Internal_Sym
* symtab
;
9615 Elf_Internal_Sym
* sym
;
9617 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9618 || relsec
->sh_info
>= elf_header
.e_shnum
9619 || section_headers
+ relsec
->sh_info
!= section
9620 || relsec
->sh_size
== 0
9621 || relsec
->sh_link
>= elf_header
.e_shnum
)
9624 is_rela
= relsec
->sh_type
== SHT_RELA
;
9628 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9629 relsec
->sh_size
, & relocs
, & num_relocs
))
9634 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9635 relsec
->sh_size
, & relocs
, & num_relocs
))
9639 /* SH uses RELA but uses in place value instead of the addend field. */
9640 if (elf_header
.e_machine
== EM_SH
)
9643 symsec
= section_headers
+ relsec
->sh_link
;
9644 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9646 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9649 unsigned int reloc_type
;
9650 unsigned int reloc_size
;
9651 unsigned char * rloc
;
9653 reloc_type
= get_reloc_type (rp
->r_info
);
9655 if (target_specific_reloc_handling (rp
, start
, symtab
))
9657 else if (is_none_reloc (reloc_type
))
9659 else if (is_32bit_abs_reloc (reloc_type
)
9660 || is_32bit_pcrel_reloc (reloc_type
))
9662 else if (is_64bit_abs_reloc (reloc_type
)
9663 || is_64bit_pcrel_reloc (reloc_type
))
9665 else if (is_24bit_abs_reloc (reloc_type
))
9667 else if (is_16bit_abs_reloc (reloc_type
))
9671 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9672 reloc_type
, SECTION_NAME (section
));
9676 rloc
= start
+ rp
->r_offset
;
9677 if ((rloc
+ reloc_size
) > end
)
9679 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9680 (unsigned long) rp
->r_offset
,
9681 SECTION_NAME (section
));
9685 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9687 /* If the reloc has a symbol associated with it,
9688 make sure that it is of an appropriate type.
9690 Relocations against symbols without type can happen.
9691 Gcc -feliminate-dwarf2-dups may generate symbols
9692 without type for debug info.
9694 Icc generates relocations against function symbols
9695 instead of local labels.
9697 Relocations against object symbols can happen, eg when
9698 referencing a global array. For an example of this see
9699 the _clz.o binary in libgcc.a. */
9701 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9703 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9704 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9705 (long int)(rp
- relocs
),
9706 SECTION_NAME (relsec
));
9712 addend
+= rp
->r_addend
;
9713 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9716 || (elf_header
.e_machine
== EM_XTENSA
9718 || ((elf_header
.e_machine
== EM_PJ
9719 || elf_header
.e_machine
== EM_PJ_OLD
)
9721 || ((elf_header
.e_machine
== EM_D30V
9722 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
9723 && reloc_type
== 12))
9724 addend
+= byte_get (rloc
, reloc_size
);
9726 if (is_32bit_pcrel_reloc (reloc_type
)
9727 || is_64bit_pcrel_reloc (reloc_type
))
9729 /* On HPPA, all pc-relative relocations are biased by 8. */
9730 if (elf_header
.e_machine
== EM_PARISC
)
9732 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9736 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9745 #ifdef SUPPORT_DISASSEMBLY
9747 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9749 printf (_("\nAssembly dump of section %s\n"),
9750 SECTION_NAME (section
));
9752 /* XXX -- to be done --- XXX */
9758 /* Reads in the contents of SECTION from FILE, returning a pointer
9759 to a malloc'ed buffer or NULL if something went wrong. */
9762 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9764 bfd_size_type num_bytes
;
9766 num_bytes
= section
->sh_size
;
9768 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9770 printf (_("\nSection '%s' has no data to dump.\n"),
9771 SECTION_NAME (section
));
9775 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9776 _("section contents"));
9781 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9783 Elf_Internal_Shdr
* relsec
;
9784 bfd_size_type num_bytes
;
9788 char * name
= SECTION_NAME (section
);
9789 bfd_boolean some_strings_shown
;
9791 start
= get_section_contents (section
, file
);
9795 printf (_("\nString dump of section '%s':\n"), name
);
9797 /* If the section being dumped has relocations against it the user might
9798 be expecting these relocations to have been applied. Check for this
9799 case and issue a warning message in order to avoid confusion.
9800 FIXME: Maybe we ought to have an option that dumps a section with
9802 for (relsec
= section_headers
;
9803 relsec
< section_headers
+ elf_header
.e_shnum
;
9806 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9807 || relsec
->sh_info
>= elf_header
.e_shnum
9808 || section_headers
+ relsec
->sh_info
!= section
9809 || relsec
->sh_size
== 0
9810 || relsec
->sh_link
>= elf_header
.e_shnum
)
9813 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9817 num_bytes
= section
->sh_size
;
9819 end
= start
+ num_bytes
;
9820 some_strings_shown
= FALSE
;
9824 while (!ISPRINT (* data
))
9831 /* PR 11128: Use two separate invocations in order to work
9832 around bugs in the Solaris 8 implementation of printf. */
9833 printf (" [%6tx] ", data
- start
);
9834 printf ("%s\n", data
);
9836 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9838 data
+= strlen (data
);
9839 some_strings_shown
= TRUE
;
9843 if (! some_strings_shown
)
9844 printf (_(" No strings found in this section."));
9852 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9854 bfd_boolean relocate
)
9856 Elf_Internal_Shdr
* relsec
;
9857 bfd_size_type bytes
;
9859 unsigned char * data
;
9860 unsigned char * start
;
9862 start
= (unsigned char *) get_section_contents (section
, file
);
9866 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9870 apply_relocations (file
, section
, start
);
9874 /* If the section being dumped has relocations against it the user might
9875 be expecting these relocations to have been applied. Check for this
9876 case and issue a warning message in order to avoid confusion.
9877 FIXME: Maybe we ought to have an option that dumps a section with
9879 for (relsec
= section_headers
;
9880 relsec
< section_headers
+ elf_header
.e_shnum
;
9883 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9884 || relsec
->sh_info
>= elf_header
.e_shnum
9885 || section_headers
+ relsec
->sh_info
!= section
9886 || relsec
->sh_size
== 0
9887 || relsec
->sh_link
>= elf_header
.e_shnum
)
9890 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9895 addr
= section
->sh_addr
;
9896 bytes
= section
->sh_size
;
9905 lbytes
= (bytes
> 16 ? 16 : bytes
);
9907 printf (" 0x%8.8lx ", (unsigned long) addr
);
9909 for (j
= 0; j
< 16; j
++)
9912 printf ("%2.2x", data
[j
]);
9920 for (j
= 0; j
< lbytes
; j
++)
9923 if (k
>= ' ' && k
< 0x7f)
9941 /* Uncompresses a section that was compressed using zlib, in place. */
9944 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
9945 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
9950 dwarf_size_type compressed_size
= *size
;
9951 unsigned char * compressed_buffer
= *buffer
;
9952 dwarf_size_type uncompressed_size
;
9953 unsigned char * uncompressed_buffer
;
9956 dwarf_size_type header_size
= 12;
9958 /* Read the zlib header. In this case, it should be "ZLIB" followed
9959 by the uncompressed section size, 8 bytes in big-endian order. */
9960 if (compressed_size
< header_size
9961 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9964 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9965 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9966 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9967 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9968 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9969 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9970 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9971 uncompressed_size
+= compressed_buffer
[11];
9973 /* It is possible the section consists of several compressed
9974 buffers concatenated together, so we uncompress in a loop. */
9978 strm
.avail_in
= compressed_size
- header_size
;
9979 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9980 strm
.avail_out
= uncompressed_size
;
9981 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9983 rc
= inflateInit (& strm
);
9984 while (strm
.avail_in
> 0)
9988 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9989 + (uncompressed_size
- strm
.avail_out
));
9990 rc
= inflate (&strm
, Z_FINISH
);
9991 if (rc
!= Z_STREAM_END
)
9993 rc
= inflateReset (& strm
);
9995 rc
= inflateEnd (& strm
);
9997 || strm
.avail_out
!= 0)
10000 free (compressed_buffer
);
10001 *buffer
= uncompressed_buffer
;
10002 *size
= uncompressed_size
;
10006 free (uncompressed_buffer
);
10007 /* Indicate decompression failure. */
10010 #endif /* HAVE_ZLIB_H */
10014 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10015 Elf_Internal_Shdr
* sec
, void * file
)
10017 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10020 /* If it is already loaded, do nothing. */
10021 if (section
->start
!= NULL
)
10024 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10025 section
->address
= sec
->sh_addr
;
10026 section
->size
= sec
->sh_size
;
10027 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10029 sec
->sh_size
, buf
);
10030 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10031 sec
->sh_size
= section
->size
;
10033 if (section
->start
== NULL
)
10036 if (debug_displays
[debug
].relocate
)
10037 apply_relocations ((FILE *) file
, sec
, section
->start
);
10043 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10045 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10046 Elf_Internal_Shdr
* sec
;
10048 /* Locate the debug section. */
10049 sec
= find_section (section
->uncompressed_name
);
10051 section
->name
= section
->uncompressed_name
;
10054 sec
= find_section (section
->compressed_name
);
10056 section
->name
= section
->compressed_name
;
10061 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10065 free_debug_section (enum dwarf_section_display_enum debug
)
10067 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10069 if (section
->start
== NULL
)
10072 free ((char *) section
->start
);
10073 section
->start
= NULL
;
10074 section
->address
= 0;
10079 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10081 char * name
= SECTION_NAME (section
);
10082 bfd_size_type length
;
10086 length
= section
->sh_size
;
10089 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10092 if (section
->sh_type
== SHT_NOBITS
)
10094 /* There is no point in dumping the contents of a debugging section
10095 which has the NOBITS type - the bits in the file will be random.
10096 This can happen when a file containing a .eh_frame section is
10097 stripped with the --only-keep-debug command line option. */
10098 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10102 if (const_strneq (name
, ".gnu.linkonce.wi."))
10103 name
= ".debug_info";
10105 /* See if we know how to display the contents of this section. */
10106 for (i
= 0; i
< max
; i
++)
10107 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10108 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10110 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10111 int secondary
= (section
!= find_section (name
));
10114 free_debug_section ((enum dwarf_section_display_enum
) i
);
10116 if (streq (sec
->uncompressed_name
, name
))
10117 sec
->name
= sec
->uncompressed_name
;
10119 sec
->name
= sec
->compressed_name
;
10120 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10123 result
&= debug_displays
[i
].display (sec
, file
);
10125 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10126 free_debug_section ((enum dwarf_section_display_enum
) i
);
10134 printf (_("Unrecognized debug section: %s\n"), name
);
10141 /* Set DUMP_SECTS for all sections where dumps were requested
10142 based on section name. */
10145 initialise_dumps_byname (void)
10147 struct dump_list_entry
* cur
;
10149 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10154 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10155 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10157 request_dump_bynumber (i
, cur
->type
);
10162 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10168 process_section_contents (FILE * file
)
10170 Elf_Internal_Shdr
* section
;
10176 initialise_dumps_byname ();
10178 for (i
= 0, section
= section_headers
;
10179 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10182 #ifdef SUPPORT_DISASSEMBLY
10183 if (dump_sects
[i
] & DISASS_DUMP
)
10184 disassemble_section (section
, file
);
10186 if (dump_sects
[i
] & HEX_DUMP
)
10187 dump_section_as_bytes (section
, file
, FALSE
);
10189 if (dump_sects
[i
] & RELOC_DUMP
)
10190 dump_section_as_bytes (section
, file
, TRUE
);
10192 if (dump_sects
[i
] & STRING_DUMP
)
10193 dump_section_as_strings (section
, file
);
10195 if (dump_sects
[i
] & DEBUG_DUMP
)
10196 display_debug_section (section
, file
);
10199 /* Check to see if the user requested a
10200 dump of a section that does not exist. */
10201 while (i
++ < num_dump_sects
)
10203 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10207 process_mips_fpe_exception (int mask
)
10212 if (mask
& OEX_FPU_INEX
)
10213 fputs ("INEX", stdout
), first
= 0;
10214 if (mask
& OEX_FPU_UFLO
)
10215 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10216 if (mask
& OEX_FPU_OFLO
)
10217 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10218 if (mask
& OEX_FPU_DIV0
)
10219 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10220 if (mask
& OEX_FPU_INVAL
)
10221 printf ("%sINVAL", first
? "" : "|");
10224 fputs ("0", stdout
);
10227 /* ARM EABI attributes section. */
10232 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10234 const char ** table
;
10235 } arm_attr_public_tag
;
10237 static const char * arm_attr_tag_CPU_arch
[] =
10238 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10239 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10240 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10241 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10242 {"No", "Thumb-1", "Thumb-2"};
10243 static const char * arm_attr_tag_FP_arch
[] =
10244 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10245 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10246 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10247 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10248 static const char * arm_attr_tag_PCS_config
[] =
10249 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10250 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10251 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10252 {"V6", "SB", "TLS", "Unused"};
10253 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10254 {"Absolute", "PC-relative", "SB-relative", "None"};
10255 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10256 {"Absolute", "PC-relative", "None"};
10257 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10258 {"None", "direct", "GOT-indirect"};
10259 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10260 {"None", "??? 1", "2", "??? 3", "4"};
10261 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10262 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10263 {"Unused", "Needed", "Sign only"};
10264 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10265 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10266 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10267 {"Unused", "Finite", "RTABI", "IEEE 754"};
10268 static const char * arm_attr_tag_ABI_enum_size
[] =
10269 {"Unused", "small", "int", "forced to int"};
10270 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10271 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10272 static const char * arm_attr_tag_ABI_VFP_args
[] =
10273 {"AAPCS", "VFP registers", "custom"};
10274 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10275 {"AAPCS", "WMMX registers", "custom"};
10276 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10277 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10278 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10279 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10280 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10281 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10282 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10283 static const char * arm_attr_tag_FP_HP_extension
[] =
10284 {"Not Allowed", "Allowed"};
10285 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10286 {"None", "IEEE 754", "Alternative Format"};
10287 static const char * arm_attr_tag_MPextension_use
[] =
10288 {"Not Allowed", "Allowed"};
10289 static const char * arm_attr_tag_DIV_use
[] =
10290 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10291 "Allowed in v7-A with integer division extension"};
10292 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10293 static const char * arm_attr_tag_Virtualization_use
[] =
10294 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10295 "TrustZone and Virtualization Extensions"};
10296 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10297 {"Not Allowed", "Allowed"};
10299 #define LOOKUP(id, name) \
10300 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10301 static arm_attr_public_tag arm_attr_public_tags
[] =
10303 {4, "CPU_raw_name", 1, NULL
},
10304 {5, "CPU_name", 1, NULL
},
10305 LOOKUP(6, CPU_arch
),
10306 {7, "CPU_arch_profile", 0, NULL
},
10307 LOOKUP(8, ARM_ISA_use
),
10308 LOOKUP(9, THUMB_ISA_use
),
10309 LOOKUP(10, FP_arch
),
10310 LOOKUP(11, WMMX_arch
),
10311 LOOKUP(12, Advanced_SIMD_arch
),
10312 LOOKUP(13, PCS_config
),
10313 LOOKUP(14, ABI_PCS_R9_use
),
10314 LOOKUP(15, ABI_PCS_RW_data
),
10315 LOOKUP(16, ABI_PCS_RO_data
),
10316 LOOKUP(17, ABI_PCS_GOT_use
),
10317 LOOKUP(18, ABI_PCS_wchar_t
),
10318 LOOKUP(19, ABI_FP_rounding
),
10319 LOOKUP(20, ABI_FP_denormal
),
10320 LOOKUP(21, ABI_FP_exceptions
),
10321 LOOKUP(22, ABI_FP_user_exceptions
),
10322 LOOKUP(23, ABI_FP_number_model
),
10323 {24, "ABI_align_needed", 0, NULL
},
10324 {25, "ABI_align_preserved", 0, NULL
},
10325 LOOKUP(26, ABI_enum_size
),
10326 LOOKUP(27, ABI_HardFP_use
),
10327 LOOKUP(28, ABI_VFP_args
),
10328 LOOKUP(29, ABI_WMMX_args
),
10329 LOOKUP(30, ABI_optimization_goals
),
10330 LOOKUP(31, ABI_FP_optimization_goals
),
10331 {32, "compatibility", 0, NULL
},
10332 LOOKUP(34, CPU_unaligned_access
),
10333 LOOKUP(36, FP_HP_extension
),
10334 LOOKUP(38, ABI_FP_16bit_format
),
10335 LOOKUP(42, MPextension_use
),
10336 LOOKUP(44, DIV_use
),
10337 {64, "nodefaults", 0, NULL
},
10338 {65, "also_compatible_with", 0, NULL
},
10339 LOOKUP(66, T2EE_use
),
10340 {67, "conformance", 1, NULL
},
10341 LOOKUP(68, Virtualization_use
),
10342 LOOKUP(70, MPextension_use_legacy
)
10346 static unsigned char *
10347 display_arm_attribute (unsigned char * p
)
10352 arm_attr_public_tag
* attr
;
10356 tag
= read_uleb128 (p
, &len
);
10359 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10361 if (arm_attr_public_tags
[i
].tag
== tag
)
10363 attr
= &arm_attr_public_tags
[i
];
10370 printf (" Tag_%s: ", attr
->name
);
10371 switch (attr
->type
)
10376 case 7: /* Tag_CPU_arch_profile. */
10377 val
= read_uleb128 (p
, &len
);
10381 case 0: printf (_("None\n")); break;
10382 case 'A': printf (_("Application\n")); break;
10383 case 'R': printf (_("Realtime\n")); break;
10384 case 'M': printf (_("Microcontroller\n")); break;
10385 case 'S': printf (_("Application or Realtime\n")); break;
10386 default: printf ("??? (%d)\n", val
); break;
10390 case 24: /* Tag_align_needed. */
10391 val
= read_uleb128 (p
, &len
);
10395 case 0: printf (_("None\n")); break;
10396 case 1: printf (_("8-byte\n")); break;
10397 case 2: printf (_("4-byte\n")); break;
10398 case 3: printf ("??? 3\n"); break;
10401 printf (_("8-byte and up to %d-byte extended\n"),
10404 printf ("??? (%d)\n", val
);
10409 case 25: /* Tag_align_preserved. */
10410 val
= read_uleb128 (p
, &len
);
10414 case 0: printf (_("None\n")); break;
10415 case 1: printf (_("8-byte, except leaf SP\n")); break;
10416 case 2: printf (_("8-byte\n")); break;
10417 case 3: printf ("??? 3\n"); break;
10420 printf (_("8-byte and up to %d-byte extended\n"),
10423 printf ("??? (%d)\n", val
);
10428 case 32: /* Tag_compatibility. */
10429 val
= read_uleb128 (p
, &len
);
10431 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10432 p
+= strlen ((char *) p
) + 1;
10435 case 64: /* Tag_nodefaults. */
10437 printf (_("True\n"));
10440 case 65: /* Tag_also_compatible_with. */
10441 val
= read_uleb128 (p
, &len
);
10443 if (val
== 6 /* Tag_CPU_arch. */)
10445 val
= read_uleb128 (p
, &len
);
10447 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10448 printf ("??? (%d)\n", val
);
10450 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10454 while (*(p
++) != '\0' /* NUL terminator. */);
10468 assert (attr
->type
& 0x80);
10469 val
= read_uleb128 (p
, &len
);
10471 type
= attr
->type
& 0x7f;
10473 printf ("??? (%d)\n", val
);
10475 printf ("%s\n", attr
->table
[val
]);
10482 type
= 1; /* String. */
10484 type
= 2; /* uleb128. */
10485 printf (" Tag_unknown_%d: ", tag
);
10490 printf ("\"%s\"\n", p
);
10491 p
+= strlen ((char *) p
) + 1;
10495 val
= read_uleb128 (p
, &len
);
10497 printf ("%d (0x%x)\n", val
, val
);
10503 static unsigned char *
10504 display_gnu_attribute (unsigned char * p
,
10505 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10512 tag
= read_uleb128 (p
, &len
);
10515 /* Tag_compatibility is the only generic GNU attribute defined at
10519 val
= read_uleb128 (p
, &len
);
10521 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10522 p
+= strlen ((char *) p
) + 1;
10526 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10527 return display_proc_gnu_attribute (p
, tag
);
10530 type
= 1; /* String. */
10532 type
= 2; /* uleb128. */
10533 printf (" Tag_unknown_%d: ", tag
);
10537 printf ("\"%s\"\n", p
);
10538 p
+= strlen ((char *) p
) + 1;
10542 val
= read_uleb128 (p
, &len
);
10544 printf ("%d (0x%x)\n", val
, val
);
10550 static unsigned char *
10551 display_power_gnu_attribute (unsigned char * p
, int tag
)
10557 if (tag
== Tag_GNU_Power_ABI_FP
)
10559 val
= read_uleb128 (p
, &len
);
10561 printf (" Tag_GNU_Power_ABI_FP: ");
10566 printf (_("Hard or soft float\n"));
10569 printf (_("Hard float\n"));
10572 printf (_("Soft float\n"));
10575 printf (_("Single-precision hard float\n"));
10578 printf ("??? (%d)\n", val
);
10584 if (tag
== Tag_GNU_Power_ABI_Vector
)
10586 val
= read_uleb128 (p
, &len
);
10588 printf (" Tag_GNU_Power_ABI_Vector: ");
10592 printf (_("Any\n"));
10595 printf (_("Generic\n"));
10598 printf ("AltiVec\n");
10604 printf ("??? (%d)\n", val
);
10610 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10612 val
= read_uleb128 (p
, &len
);
10614 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10618 printf (_("Any\n"));
10621 printf ("r3/r4\n");
10624 printf (_("Memory\n"));
10627 printf ("??? (%d)\n", val
);
10634 type
= 1; /* String. */
10636 type
= 2; /* uleb128. */
10637 printf (" Tag_unknown_%d: ", tag
);
10641 printf ("\"%s\"\n", p
);
10642 p
+= strlen ((char *) p
) + 1;
10646 val
= read_uleb128 (p
, &len
);
10648 printf ("%d (0x%x)\n", val
, val
);
10654 static unsigned char *
10655 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10661 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10663 val
= read_uleb128 (p
, &len
);
10665 printf (" Tag_GNU_MIPS_ABI_FP: ");
10670 printf (_("Hard or soft float\n"));
10673 printf (_("Hard float (double precision)\n"));
10676 printf (_("Hard float (single precision)\n"));
10679 printf (_("Soft float\n"));
10682 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10685 printf ("??? (%d)\n", val
);
10692 type
= 1; /* String. */
10694 type
= 2; /* uleb128. */
10695 printf (" Tag_unknown_%d: ", tag
);
10699 printf ("\"%s\"\n", p
);
10700 p
+= strlen ((char *) p
) + 1;
10704 val
= read_uleb128 (p
, &len
);
10706 printf ("%d (0x%x)\n", val
, val
);
10712 static unsigned char *
10713 display_tic6x_attribute (unsigned char * p
)
10719 tag
= read_uleb128 (p
, &len
);
10725 val
= read_uleb128 (p
, &len
);
10727 printf (" Tag_ISA: ");
10731 case C6XABI_Tag_ISA_none
:
10732 printf (_("None\n"));
10734 case C6XABI_Tag_ISA_C62X
:
10737 case C6XABI_Tag_ISA_C67X
:
10740 case C6XABI_Tag_ISA_C67XP
:
10741 printf ("C67x+\n");
10743 case C6XABI_Tag_ISA_C64X
:
10746 case C6XABI_Tag_ISA_C64XP
:
10747 printf ("C64x+\n");
10749 case C6XABI_Tag_ISA_C674X
:
10750 printf ("C674x\n");
10753 printf ("??? (%d)\n", val
);
10758 case Tag_ABI_wchar_t
:
10759 val
= read_uleb128 (p
, &len
);
10761 printf (" Tag_ABI_wchar_t: ");
10765 printf (_("Not used\n"));
10768 printf (_("2 bytes\n"));
10771 printf (_("4 bytes\n"));
10774 printf ("??? (%d)\n", val
);
10779 case Tag_ABI_stack_align_needed
:
10780 val
= read_uleb128 (p
, &len
);
10782 printf (" Tag_ABI_stack_align_needed: ");
10786 printf (_("8-byte\n"));
10789 printf (_("16-byte\n"));
10792 printf ("??? (%d)\n", val
);
10797 case Tag_ABI_stack_align_preserved
:
10798 val
= read_uleb128 (p
, &len
);
10800 printf (" Tag_ABI_stack_align_preserved: ");
10804 printf (_("8-byte\n"));
10807 printf (_("16-byte\n"));
10810 printf ("??? (%d)\n", val
);
10816 val
= read_uleb128 (p
, &len
);
10818 printf (" Tag_ABI_DSBT: ");
10822 printf (_("DSBT addressing not used\n"));
10825 printf (_("DSBT addressing used\n"));
10828 printf ("??? (%d)\n", val
);
10834 val
= read_uleb128 (p
, &len
);
10836 printf (" Tag_ABI_PID: ");
10840 printf (_("Data addressing position-dependent\n"));
10843 printf (_("Data addressing position-independent, GOT near DP\n"));
10846 printf (_("Data addressing position-independent, GOT far from DP\n"));
10849 printf ("??? (%d)\n", val
);
10855 val
= read_uleb128 (p
, &len
);
10857 printf (" Tag_ABI_PIC: ");
10861 printf (_("Code addressing position-dependent\n"));
10864 printf (_("Code addressing position-independent\n"));
10867 printf ("??? (%d)\n", val
);
10872 case Tag_ABI_array_object_alignment
:
10873 val
= read_uleb128 (p
, &len
);
10875 printf (" Tag_ABI_array_object_alignment: ");
10879 printf (_("8-byte\n"));
10882 printf (_("4-byte\n"));
10885 printf (_("16-byte\n"));
10888 printf ("??? (%d)\n", val
);
10893 case Tag_ABI_array_object_align_expected
:
10894 val
= read_uleb128 (p
, &len
);
10896 printf (" Tag_ABI_array_object_align_expected: ");
10900 printf (_("8-byte\n"));
10903 printf (_("4-byte\n"));
10906 printf (_("16-byte\n"));
10909 printf ("??? (%d)\n", val
);
10914 case Tag_ABI_compatibility
:
10915 val
= read_uleb128 (p
, &len
);
10917 printf (" Tag_ABI_compatibility: ");
10918 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10919 p
+= strlen ((char *) p
) + 1;
10922 case Tag_ABI_conformance
:
10923 printf (" Tag_ABI_conformance: ");
10924 printf ("\"%s\"\n", p
);
10925 p
+= strlen ((char *) p
) + 1;
10929 printf (" Tag_unknown_%d: ", tag
);
10933 printf ("\"%s\"\n", p
);
10934 p
+= strlen ((char *) p
) + 1;
10938 val
= read_uleb128 (p
, &len
);
10940 printf ("%d (0x%x)\n", val
, val
);
10947 process_attributes (FILE * file
,
10948 const char * public_name
,
10949 unsigned int proc_type
,
10950 unsigned char * (* display_pub_attribute
) (unsigned char *),
10951 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10953 Elf_Internal_Shdr
* sect
;
10954 unsigned char * contents
;
10956 unsigned char * end
;
10957 bfd_vma section_len
;
10961 /* Find the section header so that we get the size. */
10962 for (i
= 0, sect
= section_headers
;
10963 i
< elf_header
.e_shnum
;
10966 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10969 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10970 sect
->sh_size
, _("attributes"));
10971 if (contents
== NULL
)
10977 len
= sect
->sh_size
- 1;
10983 bfd_boolean public_section
;
10984 bfd_boolean gnu_section
;
10986 section_len
= byte_get (p
, 4);
10989 if (section_len
> len
)
10991 printf (_("ERROR: Bad section length (%d > %d)\n"),
10992 (int) section_len
, (int) len
);
10996 len
-= section_len
;
10997 printf (_("Attribute Section: %s\n"), p
);
10999 if (public_name
&& streq ((char *) p
, public_name
))
11000 public_section
= TRUE
;
11002 public_section
= FALSE
;
11004 if (streq ((char *) p
, "gnu"))
11005 gnu_section
= TRUE
;
11007 gnu_section
= FALSE
;
11009 namelen
= strlen ((char *) p
) + 1;
11011 section_len
-= namelen
+ 4;
11013 while (section_len
> 0)
11019 size
= byte_get (p
, 4);
11020 if (size
> section_len
)
11022 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11023 (int) size
, (int) section_len
);
11024 size
= section_len
;
11027 section_len
-= size
;
11028 end
= p
+ size
- 1;
11034 printf (_("File Attributes\n"));
11037 printf (_("Section Attributes:"));
11040 printf (_("Symbol Attributes:"));
11046 val
= read_uleb128 (p
, &j
);
11050 printf (" %d", val
);
11055 printf (_("Unknown tag: %d\n"), tag
);
11056 public_section
= FALSE
;
11060 if (public_section
)
11063 p
= display_pub_attribute (p
);
11065 else if (gnu_section
)
11068 p
= display_gnu_attribute (p
,
11069 display_proc_gnu_attribute
);
11073 /* ??? Do something sensible, like dump hex. */
11074 printf (_(" Unknown section contexts\n"));
11081 printf (_("Unknown format '%c'\n"), *p
);
11089 process_arm_specific (FILE * file
)
11091 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
11092 display_arm_attribute
, NULL
);
11096 process_power_specific (FILE * file
)
11098 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11099 display_power_gnu_attribute
);
11103 process_tic6x_specific (FILE * file
)
11105 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
11106 display_tic6x_attribute
, NULL
);
11109 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11110 Print the Address, Access and Initial fields of an entry at VMA ADDR
11111 and return the VMA of the next entry. */
11114 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11117 print_vma (addr
, LONG_HEX
);
11119 if (addr
< pltgot
+ 0xfff0)
11120 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
11122 printf ("%10s", "");
11125 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11130 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11131 print_vma (entry
, LONG_HEX
);
11133 return addr
+ (is_32bit_elf
? 4 : 8);
11136 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11137 PLTGOT. Print the Address and Initial fields of an entry at VMA
11138 ADDR and return the VMA of the next entry. */
11141 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11144 print_vma (addr
, LONG_HEX
);
11147 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11152 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11153 print_vma (entry
, LONG_HEX
);
11155 return addr
+ (is_32bit_elf
? 4 : 8);
11159 process_mips_specific (FILE * file
)
11161 Elf_Internal_Dyn
* entry
;
11162 size_t liblist_offset
= 0;
11163 size_t liblistno
= 0;
11164 size_t conflictsno
= 0;
11165 size_t options_offset
= 0;
11166 size_t conflicts_offset
= 0;
11167 size_t pltrelsz
= 0;
11169 bfd_vma pltgot
= 0;
11170 bfd_vma mips_pltgot
= 0;
11171 bfd_vma jmprel
= 0;
11172 bfd_vma local_gotno
= 0;
11173 bfd_vma gotsym
= 0;
11174 bfd_vma symtabno
= 0;
11176 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11177 display_mips_gnu_attribute
);
11179 /* We have a lot of special sections. Thanks SGI! */
11180 if (dynamic_section
== NULL
)
11181 /* No information available. */
11184 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11185 switch (entry
->d_tag
)
11187 case DT_MIPS_LIBLIST
:
11189 = offset_from_vma (file
, entry
->d_un
.d_val
,
11190 liblistno
* sizeof (Elf32_External_Lib
));
11192 case DT_MIPS_LIBLISTNO
:
11193 liblistno
= entry
->d_un
.d_val
;
11195 case DT_MIPS_OPTIONS
:
11196 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11198 case DT_MIPS_CONFLICT
:
11200 = offset_from_vma (file
, entry
->d_un
.d_val
,
11201 conflictsno
* sizeof (Elf32_External_Conflict
));
11203 case DT_MIPS_CONFLICTNO
:
11204 conflictsno
= entry
->d_un
.d_val
;
11207 pltgot
= entry
->d_un
.d_ptr
;
11209 case DT_MIPS_LOCAL_GOTNO
:
11210 local_gotno
= entry
->d_un
.d_val
;
11212 case DT_MIPS_GOTSYM
:
11213 gotsym
= entry
->d_un
.d_val
;
11215 case DT_MIPS_SYMTABNO
:
11216 symtabno
= entry
->d_un
.d_val
;
11218 case DT_MIPS_PLTGOT
:
11219 mips_pltgot
= entry
->d_un
.d_ptr
;
11222 pltrel
= entry
->d_un
.d_val
;
11225 pltrelsz
= entry
->d_un
.d_val
;
11228 jmprel
= entry
->d_un
.d_ptr
;
11234 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11236 Elf32_External_Lib
* elib
;
11239 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11241 sizeof (Elf32_External_Lib
),
11245 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11246 (unsigned long) liblistno
);
11247 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11250 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11257 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11258 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11259 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11260 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11261 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11263 tmp
= gmtime (&atime
);
11264 snprintf (timebuf
, sizeof (timebuf
),
11265 "%04u-%02u-%02uT%02u:%02u:%02u",
11266 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11267 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11269 printf ("%3lu: ", (unsigned long) cnt
);
11270 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11271 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11273 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11274 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11275 liblist
.l_version
);
11277 if (liblist
.l_flags
== 0)
11281 static const struct
11288 { " EXACT_MATCH", LL_EXACT_MATCH
},
11289 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11290 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11291 { " EXPORTS", LL_EXPORTS
},
11292 { " DELAY_LOAD", LL_DELAY_LOAD
},
11293 { " DELTA", LL_DELTA
}
11295 int flags
= liblist
.l_flags
;
11298 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11299 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11301 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11302 flags
^= l_flags_vals
[fcnt
].bit
;
11305 printf (" %#x", (unsigned int) flags
);
11315 if (options_offset
!= 0)
11317 Elf_External_Options
* eopt
;
11318 Elf_Internal_Shdr
* sect
= section_headers
;
11319 Elf_Internal_Options
* iopt
;
11320 Elf_Internal_Options
* option
;
11324 /* Find the section header so that we get the size. */
11325 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11328 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11329 sect
->sh_size
, _("options"));
11332 iopt
= (Elf_Internal_Options
*)
11333 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11336 error (_("Out of memory\n"));
11343 while (offset
< sect
->sh_size
)
11345 Elf_External_Options
* eoption
;
11347 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11349 option
->kind
= BYTE_GET (eoption
->kind
);
11350 option
->size
= BYTE_GET (eoption
->size
);
11351 option
->section
= BYTE_GET (eoption
->section
);
11352 option
->info
= BYTE_GET (eoption
->info
);
11354 offset
+= option
->size
;
11360 printf (_("\nSection '%s' contains %d entries:\n"),
11361 SECTION_NAME (sect
), cnt
);
11369 switch (option
->kind
)
11372 /* This shouldn't happen. */
11373 printf (" NULL %d %lx", option
->section
, option
->info
);
11376 printf (" REGINFO ");
11377 if (elf_header
.e_machine
== EM_MIPS
)
11380 Elf32_External_RegInfo
* ereg
;
11381 Elf32_RegInfo reginfo
;
11383 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11384 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11385 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11386 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11387 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11388 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11389 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11391 printf ("GPR %08lx GP 0x%lx\n",
11392 reginfo
.ri_gprmask
,
11393 (unsigned long) reginfo
.ri_gp_value
);
11394 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11395 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11396 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11401 Elf64_External_RegInfo
* ereg
;
11402 Elf64_Internal_RegInfo reginfo
;
11404 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11405 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11406 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11407 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11408 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11409 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11410 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11412 printf ("GPR %08lx GP 0x",
11413 reginfo
.ri_gprmask
);
11414 printf_vma (reginfo
.ri_gp_value
);
11417 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11418 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11419 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11423 case ODK_EXCEPTIONS
:
11424 fputs (" EXCEPTIONS fpe_min(", stdout
);
11425 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11426 fputs (") fpe_max(", stdout
);
11427 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11428 fputs (")", stdout
);
11430 if (option
->info
& OEX_PAGE0
)
11431 fputs (" PAGE0", stdout
);
11432 if (option
->info
& OEX_SMM
)
11433 fputs (" SMM", stdout
);
11434 if (option
->info
& OEX_FPDBUG
)
11435 fputs (" FPDBUG", stdout
);
11436 if (option
->info
& OEX_DISMISS
)
11437 fputs (" DISMISS", stdout
);
11440 fputs (" PAD ", stdout
);
11441 if (option
->info
& OPAD_PREFIX
)
11442 fputs (" PREFIX", stdout
);
11443 if (option
->info
& OPAD_POSTFIX
)
11444 fputs (" POSTFIX", stdout
);
11445 if (option
->info
& OPAD_SYMBOL
)
11446 fputs (" SYMBOL", stdout
);
11449 fputs (" HWPATCH ", stdout
);
11450 if (option
->info
& OHW_R4KEOP
)
11451 fputs (" R4KEOP", stdout
);
11452 if (option
->info
& OHW_R8KPFETCH
)
11453 fputs (" R8KPFETCH", stdout
);
11454 if (option
->info
& OHW_R5KEOP
)
11455 fputs (" R5KEOP", stdout
);
11456 if (option
->info
& OHW_R5KCVTL
)
11457 fputs (" R5KCVTL", stdout
);
11460 fputs (" FILL ", stdout
);
11461 /* XXX Print content of info word? */
11464 fputs (" TAGS ", stdout
);
11465 /* XXX Print content of info word? */
11468 fputs (" HWAND ", stdout
);
11469 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11470 fputs (" R4KEOP_CHECKED", stdout
);
11471 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11472 fputs (" R4KEOP_CLEAN", stdout
);
11475 fputs (" HWOR ", stdout
);
11476 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11477 fputs (" R4KEOP_CHECKED", stdout
);
11478 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11479 fputs (" R4KEOP_CLEAN", stdout
);
11482 printf (" GP_GROUP %#06lx self-contained %#06lx",
11483 option
->info
& OGP_GROUP
,
11484 (option
->info
& OGP_SELF
) >> 16);
11487 printf (" IDENT %#06lx self-contained %#06lx",
11488 option
->info
& OGP_GROUP
,
11489 (option
->info
& OGP_SELF
) >> 16);
11492 /* This shouldn't happen. */
11493 printf (" %3d ??? %d %lx",
11494 option
->kind
, option
->section
, option
->info
);
11498 len
= sizeof (* eopt
);
11499 while (len
< option
->size
)
11500 if (((char *) option
)[len
] >= ' '
11501 && ((char *) option
)[len
] < 0x7f)
11502 printf ("%c", ((char *) option
)[len
++]);
11504 printf ("\\%03o", ((char *) option
)[len
++]);
11506 fputs ("\n", stdout
);
11514 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11516 Elf32_Conflict
* iconf
;
11519 if (dynamic_symbols
== NULL
)
11521 error (_("conflict list found without a dynamic symbol table\n"));
11525 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11528 error (_("Out of memory\n"));
11534 Elf32_External_Conflict
* econf32
;
11536 econf32
= (Elf32_External_Conflict
*)
11537 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11538 sizeof (* econf32
), _("conflict"));
11542 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11543 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11549 Elf64_External_Conflict
* econf64
;
11551 econf64
= (Elf64_External_Conflict
*)
11552 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11553 sizeof (* econf64
), _("conflict"));
11557 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11558 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11563 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11564 (unsigned long) conflictsno
);
11565 puts (_(" Num: Index Value Name"));
11567 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11569 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11571 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11572 print_vma (psym
->st_value
, FULL_HEX
);
11574 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11575 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11577 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11584 if (pltgot
!= 0 && local_gotno
!= 0)
11586 bfd_vma ent
, local_end
, global_end
;
11588 unsigned char * data
;
11592 addr_size
= (is_32bit_elf
? 4 : 8);
11593 local_end
= pltgot
+ local_gotno
* addr_size
;
11594 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11596 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11597 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11598 global_end
- pltgot
, 1, _("GOT"));
11599 printf (_("\nPrimary GOT:\n"));
11600 printf (_(" Canonical gp value: "));
11601 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11604 printf (_(" Reserved entries:\n"));
11605 printf (_(" %*s %10s %*s Purpose\n"),
11606 addr_size
* 2, _("Address"), _("Access"),
11607 addr_size
* 2, _("Initial"));
11608 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11609 printf (_(" Lazy resolver\n"));
11611 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11612 >> (addr_size
* 8 - 1)) != 0)
11614 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11615 printf (_(" Module pointer (GNU extension)\n"));
11619 if (ent
< local_end
)
11621 printf (_(" Local entries:\n"));
11622 printf (" %*s %10s %*s\n",
11623 addr_size
* 2, _("Address"), _("Access"),
11624 addr_size
* 2, _("Initial"));
11625 while (ent
< local_end
)
11627 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11633 if (gotsym
< symtabno
)
11637 printf (_(" Global entries:\n"));
11638 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
11639 addr_size
* 2, _("Address"), _("Access"),
11640 addr_size
* 2, _("Initial"),
11641 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11642 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11643 for (i
= gotsym
; i
< symtabno
; i
++)
11645 Elf_Internal_Sym
* psym
;
11647 psym
= dynamic_symbols
+ i
;
11648 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11650 print_vma (psym
->st_value
, LONG_HEX
);
11651 printf (" %-7s %3s ",
11652 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11653 get_symbol_index_type (psym
->st_shndx
));
11654 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11655 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11657 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11667 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11670 size_t offset
, rel_offset
;
11671 unsigned long count
, i
;
11672 unsigned char * data
;
11673 int addr_size
, sym_width
;
11674 Elf_Internal_Rela
* rels
;
11676 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11677 if (pltrel
== DT_RELA
)
11679 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11684 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11689 addr_size
= (is_32bit_elf
? 4 : 8);
11690 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11692 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11693 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11695 printf (_("\nPLT GOT:\n\n"));
11696 printf (_(" Reserved entries:\n"));
11697 printf (_(" %*s %*s Purpose\n"),
11698 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11699 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11700 printf (_(" PLT lazy resolver\n"));
11701 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11702 printf (_(" Module pointer\n"));
11705 printf (_(" Entries:\n"));
11706 printf (" %*s %*s %*s %-7s %3s %s\n",
11707 addr_size
* 2, _("Address"),
11708 addr_size
* 2, _("Initial"),
11709 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11710 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11711 for (i
= 0; i
< count
; i
++)
11713 Elf_Internal_Sym
* psym
;
11715 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11716 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11718 print_vma (psym
->st_value
, LONG_HEX
);
11719 printf (" %-7s %3s ",
11720 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11721 get_symbol_index_type (psym
->st_shndx
));
11722 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11723 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11725 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11739 process_gnu_liblist (FILE * file
)
11741 Elf_Internal_Shdr
* section
;
11742 Elf_Internal_Shdr
* string_sec
;
11743 Elf32_External_Lib
* elib
;
11745 size_t strtab_size
;
11752 for (i
= 0, section
= section_headers
;
11753 i
< elf_header
.e_shnum
;
11756 switch (section
->sh_type
)
11758 case SHT_GNU_LIBLIST
:
11759 if (section
->sh_link
>= elf_header
.e_shnum
)
11762 elib
= (Elf32_External_Lib
*)
11763 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11768 string_sec
= section_headers
+ section
->sh_link
;
11770 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11771 string_sec
->sh_size
,
11772 _("liblist string table"));
11773 strtab_size
= string_sec
->sh_size
;
11776 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11782 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11783 SECTION_NAME (section
),
11784 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11786 puts (_(" Library Time Stamp Checksum Version Flags"));
11788 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11796 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11797 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11798 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11799 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11800 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11802 tmp
= gmtime (&atime
);
11803 snprintf (timebuf
, sizeof (timebuf
),
11804 "%04u-%02u-%02uT%02u:%02u:%02u",
11805 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11806 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11808 printf ("%3lu: ", (unsigned long) cnt
);
11810 printf ("%-20s", liblist
.l_name
< strtab_size
11811 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11813 printf ("%-20.20s", liblist
.l_name
< strtab_size
11814 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11815 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11816 liblist
.l_version
, liblist
.l_flags
);
11826 static const char *
11827 get_note_type (unsigned e_type
)
11829 static char buff
[64];
11831 if (elf_header
.e_type
== ET_CORE
)
11835 return _("NT_AUXV (auxiliary vector)");
11837 return _("NT_PRSTATUS (prstatus structure)");
11839 return _("NT_FPREGSET (floating point registers)");
11841 return _("NT_PRPSINFO (prpsinfo structure)");
11842 case NT_TASKSTRUCT
:
11843 return _("NT_TASKSTRUCT (task structure)");
11845 return _("NT_PRXFPREG (user_xfpregs structure)");
11847 return _("NT_PPC_VMX (ppc Altivec registers)");
11849 return _("NT_PPC_VSX (ppc VSX registers)");
11850 case NT_X86_XSTATE
:
11851 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11852 case NT_S390_HIGH_GPRS
:
11853 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11854 case NT_S390_TIMER
:
11855 return _("NT_S390_TIMER (s390 timer register)");
11856 case NT_S390_TODCMP
:
11857 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11858 case NT_S390_TODPREG
:
11859 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11861 return _("NT_S390_CTRS (s390 control registers)");
11862 case NT_S390_PREFIX
:
11863 return _("NT_S390_PREFIX (s390 prefix register)");
11865 return _("NT_PSTATUS (pstatus structure)");
11867 return _("NT_FPREGS (floating point registers)");
11869 return _("NT_PSINFO (psinfo structure)");
11871 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11873 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11874 case NT_WIN32PSTATUS
:
11875 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11883 return _("NT_VERSION (version)");
11885 return _("NT_ARCH (architecture)");
11890 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11894 static const char *
11895 get_gnu_elf_note_type (unsigned e_type
)
11897 static char buff
[64];
11901 case NT_GNU_ABI_TAG
:
11902 return _("NT_GNU_ABI_TAG (ABI version tag)");
11904 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11905 case NT_GNU_BUILD_ID
:
11906 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11907 case NT_GNU_GOLD_VERSION
:
11908 return _("NT_GNU_GOLD_VERSION (gold version)");
11913 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11917 static const char *
11918 get_netbsd_elfcore_note_type (unsigned e_type
)
11920 static char buff
[64];
11922 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11924 /* NetBSD core "procinfo" structure. */
11925 return _("NetBSD procinfo structure");
11928 /* As of Jan 2002 there are no other machine-independent notes
11929 defined for NetBSD core files. If the note type is less
11930 than the start of the machine-dependent note types, we don't
11933 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11935 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11939 switch (elf_header
.e_machine
)
11941 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11942 and PT_GETFPREGS == mach+2. */
11947 case EM_SPARC32PLUS
:
11951 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11952 return _("PT_GETREGS (reg structure)");
11953 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11954 return _("PT_GETFPREGS (fpreg structure)");
11960 /* On all other arch's, PT_GETREGS == mach+1 and
11961 PT_GETFPREGS == mach+3. */
11965 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11966 return _("PT_GETREGS (reg structure)");
11967 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11968 return _("PT_GETFPREGS (fpreg structure)");
11974 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11975 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11979 /* Note that by the ELF standard, the name field is already null byte
11980 terminated, and namesz includes the terminating null byte.
11981 I.E. the value of namesz for the name "FSF" is 4.
11983 If the value of namesz is zero, there is no name present. */
11985 process_note (Elf_Internal_Note
* pnote
)
11987 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11990 if (pnote
->namesz
== 0)
11991 /* If there is no note name, then use the default set of
11992 note type strings. */
11993 nt
= get_note_type (pnote
->type
);
11995 else if (const_strneq (pnote
->namedata
, "GNU"))
11996 /* GNU-specific object file notes. */
11997 nt
= get_gnu_elf_note_type (pnote
->type
);
11999 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
12000 /* NetBSD-specific core file notes. */
12001 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
12003 else if (strneq (pnote
->namedata
, "SPU/", 4))
12005 /* SPU-specific core file notes. */
12006 nt
= pnote
->namedata
+ 4;
12011 /* Don't recognize this note name; just use the default set of
12012 note type strings. */
12013 nt
= get_note_type (pnote
->type
);
12015 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
12021 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
12023 Elf_External_Note
* pnotes
;
12024 Elf_External_Note
* external
;
12030 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
12032 if (pnotes
== NULL
)
12037 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12038 (unsigned long) offset
, (unsigned long) length
);
12039 printf (_(" Owner\t\tData size\tDescription\n"));
12041 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
12043 Elf_External_Note
* next
;
12044 Elf_Internal_Note inote
;
12045 char * temp
= NULL
;
12047 inote
.type
= BYTE_GET (external
->type
);
12048 inote
.namesz
= BYTE_GET (external
->namesz
);
12049 inote
.namedata
= external
->name
;
12050 inote
.descsz
= BYTE_GET (external
->descsz
);
12051 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
12052 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
12054 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
12056 if ( ((char *) next
> ((char *) pnotes
) + length
)
12057 || ((char *) next
< (char *) pnotes
))
12059 warn (_("corrupt note found at offset %lx into core notes\n"),
12060 (unsigned long) ((char *) external
- (char *) pnotes
));
12061 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12062 inote
.type
, inote
.namesz
, inote
.descsz
);
12068 /* Prevent out-of-bounds indexing. */
12069 if (inote
.namedata
+ inote
.namesz
>= (char *) pnotes
+ length
12070 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
12072 warn (_("corrupt note found at offset %lx into core notes\n"),
12073 (unsigned long) ((char *) external
- (char *) pnotes
));
12074 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12075 inote
.type
, inote
.namesz
, inote
.descsz
);
12079 /* Verify that name is null terminated. It appears that at least
12080 one version of Linux (RedHat 6.0) generates corefiles that don't
12081 comply with the ELF spec by failing to include the null byte in
12083 if (inote
.namedata
[inote
.namesz
] != '\0')
12085 temp
= (char *) malloc (inote
.namesz
+ 1);
12089 error (_("Out of memory\n"));
12094 strncpy (temp
, inote
.namedata
, inote
.namesz
);
12095 temp
[inote
.namesz
] = 0;
12097 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12098 inote
.namedata
= temp
;
12101 res
&= process_note (& inote
);
12116 process_corefile_note_segments (FILE * file
)
12118 Elf_Internal_Phdr
* segment
;
12122 if (! get_program_headers (file
))
12125 for (i
= 0, segment
= program_headers
;
12126 i
< elf_header
.e_phnum
;
12129 if (segment
->p_type
== PT_NOTE
)
12130 res
&= process_corefile_note_segment (file
,
12131 (bfd_vma
) segment
->p_offset
,
12132 (bfd_vma
) segment
->p_filesz
);
12139 process_note_sections (FILE * file
)
12141 Elf_Internal_Shdr
* section
;
12145 for (i
= 0, section
= section_headers
;
12146 i
< elf_header
.e_shnum
;
12148 if (section
->sh_type
== SHT_NOTE
)
12149 res
&= process_corefile_note_segment (file
,
12150 (bfd_vma
) section
->sh_offset
,
12151 (bfd_vma
) section
->sh_size
);
12157 process_notes (FILE * file
)
12159 /* If we have not been asked to display the notes then do nothing. */
12163 if (elf_header
.e_type
!= ET_CORE
)
12164 return process_note_sections (file
);
12166 /* No program headers means no NOTE segment. */
12167 if (elf_header
.e_phnum
> 0)
12168 return process_corefile_note_segments (file
);
12170 printf (_("No note segments present in the core file.\n"));
12175 process_arch_specific (FILE * file
)
12180 switch (elf_header
.e_machine
)
12183 return process_arm_specific (file
);
12185 case EM_MIPS_RS3_LE
:
12186 return process_mips_specific (file
);
12189 return process_power_specific (file
);
12192 return process_tic6x_specific (file
);
12201 get_file_header (FILE * file
)
12203 /* Read in the identity array. */
12204 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12207 /* Determine how to read the rest of the header. */
12208 switch (elf_header
.e_ident
[EI_DATA
])
12210 default: /* fall through */
12211 case ELFDATANONE
: /* fall through */
12213 byte_get
= byte_get_little_endian
;
12214 byte_put
= byte_put_little_endian
;
12217 byte_get
= byte_get_big_endian
;
12218 byte_put
= byte_put_big_endian
;
12222 /* For now we only support 32 bit and 64 bit ELF files. */
12223 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12225 /* Read in the rest of the header. */
12228 Elf32_External_Ehdr ehdr32
;
12230 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12233 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12234 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12235 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12236 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12237 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12238 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12239 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12240 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12241 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12242 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12243 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12244 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12245 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12249 Elf64_External_Ehdr ehdr64
;
12251 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12252 we will not be able to cope with the 64bit data found in
12253 64 ELF files. Detect this now and abort before we start
12254 overwriting things. */
12255 if (sizeof (bfd_vma
) < 8)
12257 error (_("This instance of readelf has been built without support for a\n\
12258 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12262 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12265 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12266 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12267 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12268 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12269 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12270 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12271 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12272 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12273 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12274 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12275 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12276 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12277 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12280 if (elf_header
.e_shoff
)
12282 /* There may be some extensions in the first section header. Don't
12283 bomb if we can't read it. */
12285 get_32bit_section_headers (file
, 1);
12287 get_64bit_section_headers (file
, 1);
12293 /* Process one ELF object file according to the command line options.
12294 This file may actually be stored in an archive. The file is
12295 positioned at the start of the ELF object. */
12298 process_object (char * file_name
, FILE * file
)
12302 if (! get_file_header (file
))
12304 error (_("%s: Failed to read file header\n"), file_name
);
12308 /* Initialise per file variables. */
12309 for (i
= ARRAY_SIZE (version_info
); i
--;)
12310 version_info
[i
] = 0;
12312 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12313 dynamic_info
[i
] = 0;
12315 /* Process the file. */
12317 printf (_("\nFile: %s\n"), file_name
);
12319 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12320 Note we do this even if cmdline_dump_sects is empty because we
12321 must make sure that the dump_sets array is zeroed out before each
12322 object file is processed. */
12323 if (num_dump_sects
> num_cmdline_dump_sects
)
12324 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12326 if (num_cmdline_dump_sects
> 0)
12328 if (num_dump_sects
== 0)
12329 /* A sneaky way of allocating the dump_sects array. */
12330 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12332 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12333 memcpy (dump_sects
, cmdline_dump_sects
,
12334 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12337 if (! process_file_header ())
12340 if (! process_section_headers (file
))
12342 /* Without loaded section headers we cannot process lots of
12344 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12346 if (! do_using_dynamic
)
12347 do_syms
= do_dyn_syms
= do_reloc
= 0;
12350 if (! process_section_groups (file
))
12352 /* Without loaded section groups we cannot process unwind. */
12356 if (process_program_headers (file
))
12357 process_dynamic_section (file
);
12359 process_relocs (file
);
12361 process_unwind (file
);
12363 process_symbol_table (file
);
12365 process_syminfo (file
);
12367 process_version_sections (file
);
12369 process_section_contents (file
);
12371 process_notes (file
);
12373 process_gnu_liblist (file
);
12375 process_arch_specific (file
);
12377 if (program_headers
)
12379 free (program_headers
);
12380 program_headers
= NULL
;
12383 if (section_headers
)
12385 free (section_headers
);
12386 section_headers
= NULL
;
12391 free (string_table
);
12392 string_table
= NULL
;
12393 string_table_length
= 0;
12396 if (dynamic_strings
)
12398 free (dynamic_strings
);
12399 dynamic_strings
= NULL
;
12400 dynamic_strings_length
= 0;
12403 if (dynamic_symbols
)
12405 free (dynamic_symbols
);
12406 dynamic_symbols
= NULL
;
12407 num_dynamic_syms
= 0;
12410 if (dynamic_syminfo
)
12412 free (dynamic_syminfo
);
12413 dynamic_syminfo
= NULL
;
12416 if (dynamic_section
)
12418 free (dynamic_section
);
12419 dynamic_section
= NULL
;
12422 if (section_headers_groups
)
12424 free (section_headers_groups
);
12425 section_headers_groups
= NULL
;
12428 if (section_groups
)
12430 struct group_list
* g
;
12431 struct group_list
* next
;
12433 for (i
= 0; i
< group_count
; i
++)
12435 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12442 free (section_groups
);
12443 section_groups
= NULL
;
12446 free_debug_memory ();
12451 /* Process an ELF archive.
12452 On entry the file is positioned just after the ARMAG string. */
12455 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12457 struct archive_info arch
;
12458 struct archive_info nested_arch
;
12464 /* The ARCH structure is used to hold information about this archive. */
12465 arch
.file_name
= NULL
;
12467 arch
.index_array
= NULL
;
12468 arch
.sym_table
= NULL
;
12469 arch
.longnames
= NULL
;
12471 /* The NESTED_ARCH structure is used as a single-item cache of information
12472 about a nested archive (when members of a thin archive reside within
12473 another regular archive file). */
12474 nested_arch
.file_name
= NULL
;
12475 nested_arch
.file
= NULL
;
12476 nested_arch
.index_array
= NULL
;
12477 nested_arch
.sym_table
= NULL
;
12478 nested_arch
.longnames
= NULL
;
12480 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12486 if (do_archive_index
)
12488 if (arch
.sym_table
== NULL
)
12489 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12493 unsigned long current_pos
;
12495 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12496 file_name
, arch
.index_num
, arch
.sym_size
);
12497 current_pos
= ftell (file
);
12499 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12501 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12503 char * member_name
;
12505 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12507 if (member_name
!= NULL
)
12509 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12511 if (qualified_name
!= NULL
)
12513 printf (_("Binary %s contains:\n"), qualified_name
);
12514 free (qualified_name
);
12519 if (l
>= arch
.sym_size
)
12521 error (_("%s: end of the symbol table reached before the end of the index\n"),
12525 printf ("\t%s\n", arch
.sym_table
+ l
);
12526 l
+= strlen (arch
.sym_table
+ l
) + 1;
12531 if (l
< arch
.sym_size
)
12532 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12535 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12537 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12543 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12544 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12545 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12546 && !do_section_groups
&& !do_dyn_syms
)
12548 ret
= 0; /* Archive index only. */
12559 char * qualified_name
;
12561 /* Read the next archive header. */
12562 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12564 error (_("%s: failed to seek to next archive header\n"), file_name
);
12567 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12568 if (got
!= sizeof arch
.arhdr
)
12572 error (_("%s: failed to read archive header\n"), file_name
);
12576 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12578 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12583 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12585 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12586 if (archive_file_size
& 01)
12587 ++archive_file_size
;
12589 name
= get_archive_member_name (&arch
, &nested_arch
);
12592 error (_("%s: bad archive file name\n"), file_name
);
12596 namelen
= strlen (name
);
12598 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12599 if (qualified_name
== NULL
)
12601 error (_("%s: bad archive file name\n"), file_name
);
12606 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12608 /* This is a proxy for an external member of a thin archive. */
12609 FILE * member_file
;
12610 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12611 if (member_file_name
== NULL
)
12617 member_file
= fopen (member_file_name
, "rb");
12618 if (member_file
== NULL
)
12620 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12621 free (member_file_name
);
12626 archive_file_offset
= arch
.nested_member_origin
;
12628 ret
|= process_object (qualified_name
, member_file
);
12630 fclose (member_file
);
12631 free (member_file_name
);
12633 else if (is_thin_archive
)
12635 /* This is a proxy for a member of a nested archive. */
12636 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12638 /* The nested archive file will have been opened and setup by
12639 get_archive_member_name. */
12640 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12642 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12647 ret
|= process_object (qualified_name
, nested_arch
.file
);
12651 archive_file_offset
= arch
.next_arhdr_offset
;
12652 arch
.next_arhdr_offset
+= archive_file_size
;
12654 ret
|= process_object (qualified_name
, file
);
12657 if (dump_sects
!= NULL
)
12661 num_dump_sects
= 0;
12664 free (qualified_name
);
12668 if (nested_arch
.file
!= NULL
)
12669 fclose (nested_arch
.file
);
12670 release_archive (&nested_arch
);
12671 release_archive (&arch
);
12677 process_file (char * file_name
)
12680 struct stat statbuf
;
12681 char armag
[SARMAG
];
12684 if (stat (file_name
, &statbuf
) < 0)
12686 if (errno
== ENOENT
)
12687 error (_("'%s': No such file\n"), file_name
);
12689 error (_("Could not locate '%s'. System error message: %s\n"),
12690 file_name
, strerror (errno
));
12694 if (! S_ISREG (statbuf
.st_mode
))
12696 error (_("'%s' is not an ordinary file\n"), file_name
);
12700 file
= fopen (file_name
, "rb");
12703 error (_("Input file '%s' is not readable.\n"), file_name
);
12707 if (fread (armag
, SARMAG
, 1, file
) != 1)
12709 error (_("%s: Failed to read file's magic number\n"), file_name
);
12714 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12715 ret
= process_archive (file_name
, file
, FALSE
);
12716 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12717 ret
= process_archive (file_name
, file
, TRUE
);
12720 if (do_archive_index
)
12721 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12725 archive_file_size
= archive_file_offset
= 0;
12726 ret
= process_object (file_name
, file
);
12734 #ifdef SUPPORT_DISASSEMBLY
12735 /* Needed by the i386 disassembler. For extra credit, someone could
12736 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12740 print_address (unsigned int addr
, FILE * outfile
)
12742 fprintf (outfile
,"0x%8.8x", addr
);
12745 /* Needed by the i386 disassembler. */
12747 db_task_printsym (unsigned int addr
)
12749 print_address (addr
, stderr
);
12754 main (int argc
, char ** argv
)
12758 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12759 setlocale (LC_MESSAGES
, "");
12761 #if defined (HAVE_SETLOCALE)
12762 setlocale (LC_CTYPE
, "");
12764 bindtextdomain (PACKAGE
, LOCALEDIR
);
12765 textdomain (PACKAGE
);
12767 expandargv (&argc
, &argv
);
12769 parse_args (argc
, argv
);
12771 if (num_dump_sects
> 0)
12773 /* Make a copy of the dump_sects array. */
12774 cmdline_dump_sects
= (dump_type
*)
12775 malloc (num_dump_sects
* sizeof (* dump_sects
));
12776 if (cmdline_dump_sects
== NULL
)
12777 error (_("Out of memory allocating dump request table.\n"));
12780 memcpy (cmdline_dump_sects
, dump_sects
,
12781 num_dump_sects
* sizeof (* dump_sects
));
12782 num_cmdline_dump_sects
= num_dump_sects
;
12786 if (optind
< (argc
- 1))
12790 while (optind
< argc
)
12791 err
|= process_file (argv
[optind
++]);
12793 if (dump_sects
!= NULL
)
12795 if (cmdline_dump_sects
!= NULL
)
12796 free (cmdline_dump_sects
);