1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012
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. */
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files.
58 Only do this if we believe that the compiler can support a 64 bit
59 data type. For now we only rely on GCC being able to do this. */
68 #include "elf/common.h"
69 #include "elf/external.h"
70 #include "elf/internal.h"
73 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
81 /* Undo the effects of #including reloc-macros.h. */
83 #undef START_RELOC_NUMBERS
87 #undef END_RELOC_NUMBERS
88 #undef _RELOC_MACROS_H
90 /* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
94 #define RELOC_MACROS_GEN_FUNC
96 #include "elf/aarch64.h"
97 #include "elf/alpha.h"
101 #include "elf/bfin.h"
102 #include "elf/cr16.h"
103 #include "elf/cris.h"
105 #include "elf/d10v.h"
106 #include "elf/d30v.h"
108 #include "elf/epiphany.h"
109 #include "elf/fr30.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/mcore.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/or32.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/x86-64.h"
152 #include "elf/xc16x.h"
153 #include "elf/xgate.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
158 #include "libiberty.h"
159 #include "safe-ctype.h"
160 #include "filenames.h"
162 char * program_name
= "readelf";
163 static long archive_file_offset
;
164 static unsigned long archive_file_size
;
165 static unsigned long dynamic_addr
;
166 static bfd_size_type dynamic_size
;
167 static unsigned int dynamic_nent
;
168 static char * dynamic_strings
;
169 static unsigned long dynamic_strings_length
;
170 static char * string_table
;
171 static unsigned long string_table_length
;
172 static unsigned long num_dynamic_syms
;
173 static Elf_Internal_Sym
* dynamic_symbols
;
174 static Elf_Internal_Syminfo
* dynamic_syminfo
;
175 static unsigned long dynamic_syminfo_offset
;
176 static unsigned int dynamic_syminfo_nent
;
177 static char program_interpreter
[PATH_MAX
];
178 static bfd_vma dynamic_info
[DT_ENCODING
];
179 static bfd_vma dynamic_info_DT_GNU_HASH
;
180 static bfd_vma version_info
[16];
181 static Elf_Internal_Ehdr elf_header
;
182 static Elf_Internal_Shdr
* section_headers
;
183 static Elf_Internal_Phdr
* program_headers
;
184 static Elf_Internal_Dyn
* dynamic_section
;
185 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
186 static int show_name
;
187 static int do_dynamic
;
189 static int do_dyn_syms
;
191 static int do_sections
;
192 static int do_section_groups
;
193 static int do_section_details
;
194 static int do_segments
;
195 static int do_unwind
;
196 static int do_using_dynamic
;
197 static int do_header
;
199 static int do_version
;
200 static int do_histogram
;
201 static int do_debugging
;
204 static int do_archive_index
;
205 static int is_32bit_elf
;
209 struct group_list
* next
;
210 unsigned int section_index
;
215 struct group_list
* root
;
216 unsigned int group_index
;
219 static size_t group_count
;
220 static struct group
* section_groups
;
221 static struct group
** section_headers_groups
;
224 /* Flag bits indicating particular types of dump. */
225 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
226 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
227 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
228 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
229 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
231 typedef unsigned char dump_type
;
233 /* A linked list of the section names for which dumps were requested. */
234 struct dump_list_entry
238 struct dump_list_entry
* next
;
240 static struct dump_list_entry
* dump_sects_byname
;
242 /* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244 static dump_type
* cmdline_dump_sects
= NULL
;
245 static unsigned int num_cmdline_dump_sects
= 0;
247 /* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252 static dump_type
* dump_sects
= NULL
;
253 static unsigned int num_dump_sects
= 0;
256 /* How to print a vma value. */
257 typedef enum print_mode
271 #define SECTION_NAME(X) \
272 ((X) == NULL ? _("<none>") \
273 : string_table == NULL ? _("<no-name>") \
274 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
275 : string_table + (X)->sh_name))
277 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
279 #define GET_ELF_SYMBOLS(file, section, sym_count) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
281 : get_64bit_elf_symbols (file, section, sym_count))
283 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
284 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
285 already been called and verified that the string exists. */
286 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
288 #define REMOVE_ARCH_BITS(ADDR) \
291 if (elf_header.e_machine == EM_ARM) \
296 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
297 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
298 using malloc and fill that. In either case return the pointer to the start of
299 the retrieved data or NULL if something went wrong. If something does go wrong
300 emit an error message using REASON as part of the context. */
303 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
308 if (size
== 0 || nmemb
== 0)
311 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
313 error (_("Unable to seek to 0x%lx for %s\n"),
314 (unsigned long) archive_file_offset
+ offset
, reason
);
321 /* Check for overflow. */
322 if (nmemb
< (~(size_t) 0 - 1) / size
)
323 /* + 1 so that we can '\0' terminate invalid string table sections. */
324 mvar
= malloc (size
* nmemb
+ 1);
328 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
329 (unsigned long)(size
* nmemb
), reason
);
333 ((char *) mvar
)[size
* nmemb
] = '\0';
336 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
338 error (_("Unable to read in 0x%lx bytes of %s\n"),
339 (unsigned long)(size
* nmemb
), reason
);
348 /* Print a VMA value. */
351 print_vma (bfd_vma vma
, print_mode mode
)
364 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
371 return printf ("%5" BFD_VMA_FMT
"d", vma
);
379 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
382 return printf ("%" BFD_VMA_FMT
"d", vma
);
385 return printf ("%" BFD_VMA_FMT
"u", vma
);
390 /* Display a symbol on stdout. Handles the display of control characters and
391 multibye characters (assuming the host environment supports them).
393 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
395 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
396 padding as necessary.
398 Returns the number of emitted characters. */
401 print_symbol (int width
, const char *symbol
)
403 bfd_boolean extra_padding
= FALSE
;
405 #ifdef HAVE_MBSTATE_T
412 /* Keep the width positive. This also helps. */
414 extra_padding
= TRUE
;
418 /* Set the remaining width to a very large value.
419 This simplifies the code below. */
420 width_remaining
= INT_MAX
;
422 width_remaining
= width
;
424 #ifdef HAVE_MBSTATE_T
425 /* Initialise the multibyte conversion state. */
426 memset (& state
, 0, sizeof (state
));
429 while (width_remaining
)
432 const char c
= *symbol
++;
437 /* Do not print control characters directly as they can affect terminal
438 settings. Such characters usually appear in the names generated
439 by the assembler for local labels. */
442 if (width_remaining
< 2)
445 printf ("^%c", c
+ 0x40);
446 width_remaining
-= 2;
449 else if (ISPRINT (c
))
457 #ifdef HAVE_MBSTATE_T
460 /* Let printf do the hard work of displaying multibyte characters. */
461 printf ("%.1s", symbol
- 1);
465 #ifdef HAVE_MBSTATE_T
466 /* Try to find out how many bytes made up the character that was
467 just printed. Advance the symbol pointer past the bytes that
469 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
473 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
478 if (extra_padding
&& num_printed
< width
)
480 /* Fill in the remaining spaces. */
481 printf ("%-*s", width
- num_printed
, " ");
488 /* Return a pointer to section NAME, or NULL if no such section exists. */
490 static Elf_Internal_Shdr
*
491 find_section (const char * name
)
495 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
496 if (streq (SECTION_NAME (section_headers
+ i
), name
))
497 return section_headers
+ i
;
502 /* Return a pointer to a section containing ADDR, or NULL if no such
505 static Elf_Internal_Shdr
*
506 find_section_by_address (bfd_vma addr
)
510 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
512 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
513 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
520 /* Return a pointer to section NAME, or NULL if no such section exists,
521 restricted to the list of sections given in SET. */
523 static Elf_Internal_Shdr
*
524 find_section_in_set (const char * name
, unsigned int * set
)
530 while ((i
= *set
++) > 0)
531 if (streq (SECTION_NAME (section_headers
+ i
), name
))
532 return section_headers
+ i
;
535 return find_section (name
);
538 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
542 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
544 return read_leb128 (data
, length_return
, 0);
547 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
548 This OS has so many departures from the ELF standard that we test it at
554 return elf_header
.e_machine
== EM_IA_64
555 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
558 /* Guess the relocation size commonly used by the specific machines. */
561 guess_is_rela (unsigned int e_machine
)
565 /* Targets that use REL relocations. */
582 /* Targets that use RELA relocations. */
586 case EM_ADAPTEVA_EPIPHANY
:
588 case EM_ALTERA_NIOS2
:
607 case EM_LATTICEMICO32
:
615 case EM_CYGNUS_MN10200
:
617 case EM_CYGNUS_MN10300
:
647 case EM_MICROBLAZE_OLD
:
668 warn (_("Don't know about relocations on this machine architecture\n"));
674 slurp_rela_relocs (FILE * file
,
675 unsigned long rel_offset
,
676 unsigned long rel_size
,
677 Elf_Internal_Rela
** relasp
,
678 unsigned long * nrelasp
)
680 Elf_Internal_Rela
* relas
;
681 unsigned long nrelas
;
686 Elf32_External_Rela
* erelas
;
688 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
689 rel_size
, _("32-bit relocation data"));
693 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
695 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
696 sizeof (Elf_Internal_Rela
));
701 error (_("out of memory parsing relocs\n"));
705 for (i
= 0; i
< nrelas
; i
++)
707 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
708 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
709 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
716 Elf64_External_Rela
* erelas
;
718 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
719 rel_size
, _("64-bit relocation data"));
723 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
725 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
726 sizeof (Elf_Internal_Rela
));
731 error (_("out of memory parsing relocs\n"));
735 for (i
= 0; i
< nrelas
; i
++)
737 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
738 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
739 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
741 /* The #ifdef BFD64 below is to prevent a compile time
742 warning. We know that if we do not have a 64 bit data
743 type that we will never execute this code anyway. */
745 if (elf_header
.e_machine
== EM_MIPS
746 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
748 /* In little-endian objects, r_info isn't really a
749 64-bit little-endian value: it has a 32-bit
750 little-endian symbol index followed by four
751 individual byte fields. Reorder INFO
753 bfd_vma inf
= relas
[i
].r_info
;
754 inf
= (((inf
& 0xffffffff) << 32)
755 | ((inf
>> 56) & 0xff)
756 | ((inf
>> 40) & 0xff00)
757 | ((inf
>> 24) & 0xff0000)
758 | ((inf
>> 8) & 0xff000000));
759 relas
[i
].r_info
= inf
;
772 slurp_rel_relocs (FILE * file
,
773 unsigned long rel_offset
,
774 unsigned long rel_size
,
775 Elf_Internal_Rela
** relsp
,
776 unsigned long * nrelsp
)
778 Elf_Internal_Rela
* rels
;
784 Elf32_External_Rel
* erels
;
786 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
787 rel_size
, _("32-bit relocation data"));
791 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
793 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
798 error (_("out of memory parsing relocs\n"));
802 for (i
= 0; i
< nrels
; i
++)
804 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
805 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
806 rels
[i
].r_addend
= 0;
813 Elf64_External_Rel
* erels
;
815 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
816 rel_size
, _("64-bit relocation data"));
820 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
822 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
827 error (_("out of memory parsing relocs\n"));
831 for (i
= 0; i
< nrels
; i
++)
833 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
834 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
835 rels
[i
].r_addend
= 0;
837 /* The #ifdef BFD64 below is to prevent a compile time
838 warning. We know that if we do not have a 64 bit data
839 type that we will never execute this code anyway. */
841 if (elf_header
.e_machine
== EM_MIPS
842 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
844 /* In little-endian objects, r_info isn't really a
845 64-bit little-endian value: it has a 32-bit
846 little-endian symbol index followed by four
847 individual byte fields. Reorder INFO
849 bfd_vma inf
= rels
[i
].r_info
;
850 inf
= (((inf
& 0xffffffff) << 32)
851 | ((inf
>> 56) & 0xff)
852 | ((inf
>> 40) & 0xff00)
853 | ((inf
>> 24) & 0xff0000)
854 | ((inf
>> 8) & 0xff000000));
855 rels
[i
].r_info
= inf
;
867 /* Returns the reloc type extracted from the reloc info field. */
870 get_reloc_type (bfd_vma reloc_info
)
873 return ELF32_R_TYPE (reloc_info
);
875 switch (elf_header
.e_machine
)
878 /* Note: We assume that reloc_info has already been adjusted for us. */
879 return ELF64_MIPS_R_TYPE (reloc_info
);
882 return ELF64_R_TYPE_ID (reloc_info
);
885 return ELF64_R_TYPE (reloc_info
);
889 /* Return the symbol index extracted from the reloc info field. */
892 get_reloc_symindex (bfd_vma reloc_info
)
894 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
897 /* Display the contents of the relocation data found at the specified
901 dump_relocations (FILE * file
,
902 unsigned long rel_offset
,
903 unsigned long rel_size
,
904 Elf_Internal_Sym
* symtab
,
907 unsigned long strtablen
,
911 Elf_Internal_Rela
* rels
;
913 if (is_rela
== UNKNOWN
)
914 is_rela
= guess_is_rela (elf_header
.e_machine
);
918 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
923 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
932 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
934 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
939 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
941 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
949 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
951 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
956 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
958 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
962 for (i
= 0; i
< rel_size
; i
++)
967 bfd_vma symtab_index
;
970 offset
= rels
[i
].r_offset
;
971 inf
= rels
[i
].r_info
;
973 type
= get_reloc_type (inf
);
974 symtab_index
= get_reloc_symindex (inf
);
978 printf ("%8.8lx %8.8lx ",
979 (unsigned long) offset
& 0xffffffff,
980 (unsigned long) inf
& 0xffffffff);
984 #if BFD_HOST_64BIT_LONG
986 ? "%16.16lx %16.16lx "
987 : "%12.12lx %12.12lx ",
989 #elif BFD_HOST_64BIT_LONG_LONG
992 ? "%16.16llx %16.16llx "
993 : "%12.12llx %12.12llx ",
997 ? "%16.16I64x %16.16I64x "
998 : "%12.12I64x %12.12I64x ",
1003 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1004 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1005 _bfd_int64_high (offset
),
1006 _bfd_int64_low (offset
),
1007 _bfd_int64_high (inf
),
1008 _bfd_int64_low (inf
));
1012 switch (elf_header
.e_machine
)
1019 rtype
= elf_aarch64_reloc_type (type
);
1023 case EM_CYGNUS_M32R
:
1024 rtype
= elf_m32r_reloc_type (type
);
1029 rtype
= elf_i386_reloc_type (type
);
1034 rtype
= elf_m68hc11_reloc_type (type
);
1038 rtype
= elf_m68k_reloc_type (type
);
1042 rtype
= elf_i960_reloc_type (type
);
1047 rtype
= elf_avr_reloc_type (type
);
1050 case EM_OLD_SPARCV9
:
1051 case EM_SPARC32PLUS
:
1054 rtype
= elf_sparc_reloc_type (type
);
1058 rtype
= elf_spu_reloc_type (type
);
1062 case EM_CYGNUS_V850
:
1063 rtype
= v850_reloc_type (type
);
1067 case EM_CYGNUS_D10V
:
1068 rtype
= elf_d10v_reloc_type (type
);
1072 case EM_CYGNUS_D30V
:
1073 rtype
= elf_d30v_reloc_type (type
);
1077 rtype
= elf_dlx_reloc_type (type
);
1081 rtype
= elf_sh_reloc_type (type
);
1085 case EM_CYGNUS_MN10300
:
1086 rtype
= elf_mn10300_reloc_type (type
);
1090 case EM_CYGNUS_MN10200
:
1091 rtype
= elf_mn10200_reloc_type (type
);
1095 case EM_CYGNUS_FR30
:
1096 rtype
= elf_fr30_reloc_type (type
);
1100 rtype
= elf_frv_reloc_type (type
);
1104 rtype
= elf_mcore_reloc_type (type
);
1108 rtype
= elf_mmix_reloc_type (type
);
1112 rtype
= elf_moxie_reloc_type (type
);
1117 rtype
= elf_msp430_reloc_type (type
);
1121 rtype
= elf_ppc_reloc_type (type
);
1125 rtype
= elf_ppc64_reloc_type (type
);
1129 case EM_MIPS_RS3_LE
:
1130 rtype
= elf_mips_reloc_type (type
);
1134 rtype
= elf_alpha_reloc_type (type
);
1138 rtype
= elf_arm_reloc_type (type
);
1142 rtype
= elf_arc_reloc_type (type
);
1146 rtype
= elf_hppa_reloc_type (type
);
1152 rtype
= elf_h8_reloc_type (type
);
1157 rtype
= elf_or32_reloc_type (type
);
1162 rtype
= elf_pj_reloc_type (type
);
1165 rtype
= elf_ia64_reloc_type (type
);
1169 rtype
= elf_cris_reloc_type (type
);
1173 rtype
= elf_i860_reloc_type (type
);
1179 rtype
= elf_x86_64_reloc_type (type
);
1183 rtype
= i370_reloc_type (type
);
1188 rtype
= elf_s390_reloc_type (type
);
1192 rtype
= elf_score_reloc_type (type
);
1196 rtype
= elf_xstormy16_reloc_type (type
);
1200 rtype
= elf_crx_reloc_type (type
);
1204 rtype
= elf_vax_reloc_type (type
);
1207 case EM_ADAPTEVA_EPIPHANY
:
1208 rtype
= elf_epiphany_reloc_type (type
);
1213 rtype
= elf_ip2k_reloc_type (type
);
1217 rtype
= elf_iq2000_reloc_type (type
);
1222 rtype
= elf_xtensa_reloc_type (type
);
1225 case EM_LATTICEMICO32
:
1226 rtype
= elf_lm32_reloc_type (type
);
1231 rtype
= elf_m32c_reloc_type (type
);
1235 rtype
= elf_mt_reloc_type (type
);
1239 rtype
= elf_bfin_reloc_type (type
);
1243 rtype
= elf_mep_reloc_type (type
);
1247 rtype
= elf_cr16_reloc_type (type
);
1251 case EM_MICROBLAZE_OLD
:
1252 rtype
= elf_microblaze_reloc_type (type
);
1256 rtype
= elf_rl78_reloc_type (type
);
1260 rtype
= elf_rx_reloc_type (type
);
1265 rtype
= elf_xc16x_reloc_type (type
);
1269 rtype
= elf_tic6x_reloc_type (type
);
1273 rtype
= elf_tilegx_reloc_type (type
);
1277 rtype
= elf_tilepro_reloc_type (type
);
1281 rtype
= elf_xgate_reloc_type (type
);
1286 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1288 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1290 if (elf_header
.e_machine
== EM_ALPHA
1292 && streq (rtype
, "R_ALPHA_LITUSE")
1295 switch (rels
[i
].r_addend
)
1297 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1298 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1299 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1300 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1301 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1302 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1303 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1304 default: rtype
= NULL
;
1307 printf (" (%s)", rtype
);
1311 printf (_("<unknown addend: %lx>"),
1312 (unsigned long) rels
[i
].r_addend
);
1315 else if (symtab_index
)
1317 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1318 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1321 Elf_Internal_Sym
* psym
;
1323 psym
= symtab
+ symtab_index
;
1327 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1331 unsigned int width
= is_32bit_elf
? 8 : 14;
1333 /* Relocations against GNU_IFUNC symbols do not use the value
1334 of the symbol as the address to relocate against. Instead
1335 they invoke the function named by the symbol and use its
1336 result as the address for relocation.
1338 To indicate this to the user, do not display the value of
1339 the symbol in the "Symbols's Value" field. Instead show
1340 its name followed by () as a hint that the symbol is
1344 || psym
->st_name
== 0
1345 || psym
->st_name
>= strtablen
)
1348 name
= strtab
+ psym
->st_name
;
1350 len
= print_symbol (width
, name
);
1351 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1355 print_vma (psym
->st_value
, LONG_HEX
);
1357 printf (is_32bit_elf
? " " : " ");
1360 if (psym
->st_name
== 0)
1362 const char * sec_name
= "<null>";
1365 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1367 if (psym
->st_shndx
< elf_header
.e_shnum
)
1369 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1370 else if (psym
->st_shndx
== SHN_ABS
)
1372 else if (psym
->st_shndx
== SHN_COMMON
)
1373 sec_name
= "COMMON";
1374 else if ((elf_header
.e_machine
== EM_MIPS
1375 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1376 || (elf_header
.e_machine
== EM_TI_C6000
1377 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1378 sec_name
= "SCOMMON";
1379 else if (elf_header
.e_machine
== EM_MIPS
1380 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1381 sec_name
= "SUNDEF";
1382 else if ((elf_header
.e_machine
== EM_X86_64
1383 || elf_header
.e_machine
== EM_L1OM
1384 || elf_header
.e_machine
== EM_K1OM
)
1385 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1386 sec_name
= "LARGE_COMMON";
1387 else if (elf_header
.e_machine
== EM_IA_64
1388 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1389 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1390 sec_name
= "ANSI_COM";
1391 else if (is_ia64_vms ()
1392 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1393 sec_name
= "VMS_SYMVEC";
1396 sprintf (name_buf
, "<section 0x%x>",
1397 (unsigned int) psym
->st_shndx
);
1398 sec_name
= name_buf
;
1401 print_symbol (22, sec_name
);
1403 else if (strtab
== NULL
)
1404 printf (_("<string table index: %3ld>"), psym
->st_name
);
1405 else if (psym
->st_name
>= strtablen
)
1406 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1408 print_symbol (22, strtab
+ psym
->st_name
);
1412 bfd_signed_vma off
= rels
[i
].r_addend
;
1415 printf (" - %" BFD_VMA_FMT
"x", - off
);
1417 printf (" + %" BFD_VMA_FMT
"x", off
);
1423 bfd_signed_vma off
= rels
[i
].r_addend
;
1425 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1427 printf ("-%" BFD_VMA_FMT
"x", - off
);
1429 printf ("%" BFD_VMA_FMT
"x", off
);
1432 if (elf_header
.e_machine
== EM_SPARCV9
1434 && streq (rtype
, "R_SPARC_OLO10"))
1435 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1440 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1442 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1443 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1444 const char * rtype2
= elf_mips_reloc_type (type2
);
1445 const char * rtype3
= elf_mips_reloc_type (type3
);
1447 printf (" Type2: ");
1450 printf (_("unrecognized: %-7lx"),
1451 (unsigned long) type2
& 0xffffffff);
1453 printf ("%-17.17s", rtype2
);
1455 printf ("\n Type3: ");
1458 printf (_("unrecognized: %-7lx"),
1459 (unsigned long) type3
& 0xffffffff);
1461 printf ("%-17.17s", rtype3
);
1472 get_mips_dynamic_type (unsigned long type
)
1476 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1477 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1478 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1479 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1480 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1481 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1482 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1483 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1484 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1485 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1486 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1487 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1488 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1489 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1490 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1491 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1492 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1493 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1494 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1495 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1496 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1497 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1498 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1499 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1500 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1501 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1502 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1503 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1504 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1505 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1506 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1507 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1508 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1509 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1510 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1511 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1512 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1513 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1514 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1515 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1516 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1517 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1518 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1519 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1520 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1527 get_sparc64_dynamic_type (unsigned long type
)
1531 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1538 get_ppc_dynamic_type (unsigned long type
)
1542 case DT_PPC_GOT
: return "PPC_GOT";
1543 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1550 get_ppc64_dynamic_type (unsigned long type
)
1554 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1555 case DT_PPC64_OPD
: return "PPC64_OPD";
1556 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1557 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1564 get_parisc_dynamic_type (unsigned long type
)
1568 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1569 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1570 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1571 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1572 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1573 case DT_HP_PREINIT
: return "HP_PREINIT";
1574 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1575 case DT_HP_NEEDED
: return "HP_NEEDED";
1576 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1577 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1578 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1579 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1580 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1581 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1582 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1583 case DT_HP_FILTERED
: return "HP_FILTERED";
1584 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1585 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1586 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1587 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1588 case DT_PLT
: return "PLT";
1589 case DT_PLT_SIZE
: return "PLT_SIZE";
1590 case DT_DLT
: return "DLT";
1591 case DT_DLT_SIZE
: return "DLT_SIZE";
1598 get_ia64_dynamic_type (unsigned long type
)
1602 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1603 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1604 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1605 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1606 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1607 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1608 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1609 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1610 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1611 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1612 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1613 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1614 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1615 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1616 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1617 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1618 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1619 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1620 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1621 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1622 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1623 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1624 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1625 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1626 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1627 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1628 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1629 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1630 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1631 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1632 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1639 get_alpha_dynamic_type (unsigned long type
)
1643 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1650 get_score_dynamic_type (unsigned long type
)
1654 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1655 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1656 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1657 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1658 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1659 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1666 get_tic6x_dynamic_type (unsigned long type
)
1670 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1671 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1672 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1673 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1674 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1675 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1682 get_dynamic_type (unsigned long type
)
1684 static char buff
[64];
1688 case DT_NULL
: return "NULL";
1689 case DT_NEEDED
: return "NEEDED";
1690 case DT_PLTRELSZ
: return "PLTRELSZ";
1691 case DT_PLTGOT
: return "PLTGOT";
1692 case DT_HASH
: return "HASH";
1693 case DT_STRTAB
: return "STRTAB";
1694 case DT_SYMTAB
: return "SYMTAB";
1695 case DT_RELA
: return "RELA";
1696 case DT_RELASZ
: return "RELASZ";
1697 case DT_RELAENT
: return "RELAENT";
1698 case DT_STRSZ
: return "STRSZ";
1699 case DT_SYMENT
: return "SYMENT";
1700 case DT_INIT
: return "INIT";
1701 case DT_FINI
: return "FINI";
1702 case DT_SONAME
: return "SONAME";
1703 case DT_RPATH
: return "RPATH";
1704 case DT_SYMBOLIC
: return "SYMBOLIC";
1705 case DT_REL
: return "REL";
1706 case DT_RELSZ
: return "RELSZ";
1707 case DT_RELENT
: return "RELENT";
1708 case DT_PLTREL
: return "PLTREL";
1709 case DT_DEBUG
: return "DEBUG";
1710 case DT_TEXTREL
: return "TEXTREL";
1711 case DT_JMPREL
: return "JMPREL";
1712 case DT_BIND_NOW
: return "BIND_NOW";
1713 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1714 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1715 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1716 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1717 case DT_RUNPATH
: return "RUNPATH";
1718 case DT_FLAGS
: return "FLAGS";
1720 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1721 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1723 case DT_CHECKSUM
: return "CHECKSUM";
1724 case DT_PLTPADSZ
: return "PLTPADSZ";
1725 case DT_MOVEENT
: return "MOVEENT";
1726 case DT_MOVESZ
: return "MOVESZ";
1727 case DT_FEATURE
: return "FEATURE";
1728 case DT_POSFLAG_1
: return "POSFLAG_1";
1729 case DT_SYMINSZ
: return "SYMINSZ";
1730 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1732 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1733 case DT_CONFIG
: return "CONFIG";
1734 case DT_DEPAUDIT
: return "DEPAUDIT";
1735 case DT_AUDIT
: return "AUDIT";
1736 case DT_PLTPAD
: return "PLTPAD";
1737 case DT_MOVETAB
: return "MOVETAB";
1738 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1740 case DT_VERSYM
: return "VERSYM";
1742 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1743 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1744 case DT_RELACOUNT
: return "RELACOUNT";
1745 case DT_RELCOUNT
: return "RELCOUNT";
1746 case DT_FLAGS_1
: return "FLAGS_1";
1747 case DT_VERDEF
: return "VERDEF";
1748 case DT_VERDEFNUM
: return "VERDEFNUM";
1749 case DT_VERNEED
: return "VERNEED";
1750 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1752 case DT_AUXILIARY
: return "AUXILIARY";
1753 case DT_USED
: return "USED";
1754 case DT_FILTER
: return "FILTER";
1756 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1757 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1758 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1759 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1760 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1761 case DT_GNU_HASH
: return "GNU_HASH";
1764 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1766 const char * result
;
1768 switch (elf_header
.e_machine
)
1771 case EM_MIPS_RS3_LE
:
1772 result
= get_mips_dynamic_type (type
);
1775 result
= get_sparc64_dynamic_type (type
);
1778 result
= get_ppc_dynamic_type (type
);
1781 result
= get_ppc64_dynamic_type (type
);
1784 result
= get_ia64_dynamic_type (type
);
1787 result
= get_alpha_dynamic_type (type
);
1790 result
= get_score_dynamic_type (type
);
1793 result
= get_tic6x_dynamic_type (type
);
1803 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1805 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1806 || (elf_header
.e_machine
== EM_PARISC
1807 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1809 const char * result
;
1811 switch (elf_header
.e_machine
)
1814 result
= get_parisc_dynamic_type (type
);
1817 result
= get_ia64_dynamic_type (type
);
1827 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1831 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1838 get_file_type (unsigned e_type
)
1840 static char buff
[32];
1844 case ET_NONE
: return _("NONE (None)");
1845 case ET_REL
: return _("REL (Relocatable file)");
1846 case ET_EXEC
: return _("EXEC (Executable file)");
1847 case ET_DYN
: return _("DYN (Shared object file)");
1848 case ET_CORE
: return _("CORE (Core file)");
1851 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1852 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1853 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1854 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1856 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1862 get_machine_name (unsigned e_machine
)
1864 static char buff
[64]; /* XXX */
1868 case EM_NONE
: return _("None");
1869 case EM_AARCH64
: return "AArch64";
1870 case EM_M32
: return "WE32100";
1871 case EM_SPARC
: return "Sparc";
1872 case EM_SPU
: return "SPU";
1873 case EM_386
: return "Intel 80386";
1874 case EM_68K
: return "MC68000";
1875 case EM_88K
: return "MC88000";
1876 case EM_486
: return "Intel 80486";
1877 case EM_860
: return "Intel 80860";
1878 case EM_MIPS
: return "MIPS R3000";
1879 case EM_S370
: return "IBM System/370";
1880 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1881 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1882 case EM_PARISC
: return "HPPA";
1883 case EM_PPC_OLD
: return "Power PC (old)";
1884 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1885 case EM_960
: return "Intel 90860";
1886 case EM_PPC
: return "PowerPC";
1887 case EM_PPC64
: return "PowerPC64";
1888 case EM_V800
: return "NEC V800";
1889 case EM_FR20
: return "Fujitsu FR20";
1890 case EM_RH32
: return "TRW RH32";
1891 case EM_MCORE
: return "MCORE";
1892 case EM_ARM
: return "ARM";
1893 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1894 case EM_SH
: return "Renesas / SuperH SH";
1895 case EM_SPARCV9
: return "Sparc v9";
1896 case EM_TRICORE
: return "Siemens Tricore";
1897 case EM_ARC
: return "ARC";
1898 case EM_H8_300
: return "Renesas H8/300";
1899 case EM_H8_300H
: return "Renesas H8/300H";
1900 case EM_H8S
: return "Renesas H8S";
1901 case EM_H8_500
: return "Renesas H8/500";
1902 case EM_IA_64
: return "Intel IA-64";
1903 case EM_MIPS_X
: return "Stanford MIPS-X";
1904 case EM_COLDFIRE
: return "Motorola Coldfire";
1905 case EM_ALPHA
: return "Alpha";
1906 case EM_CYGNUS_D10V
:
1907 case EM_D10V
: return "d10v";
1908 case EM_CYGNUS_D30V
:
1909 case EM_D30V
: return "d30v";
1910 case EM_CYGNUS_M32R
:
1911 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1912 case EM_CYGNUS_V850
:
1913 case EM_V850
: return "Renesas V850";
1914 case EM_CYGNUS_MN10300
:
1915 case EM_MN10300
: return "mn10300";
1916 case EM_CYGNUS_MN10200
:
1917 case EM_MN10200
: return "mn10200";
1918 case EM_MOXIE
: return "Moxie";
1919 case EM_CYGNUS_FR30
:
1920 case EM_FR30
: return "Fujitsu FR30";
1921 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1923 case EM_PJ
: return "picoJava";
1924 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1925 case EM_PCP
: return "Siemens PCP";
1926 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1927 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1928 case EM_STARCORE
: return "Motorola Star*Core processor";
1929 case EM_ME16
: return "Toyota ME16 processor";
1930 case EM_ST100
: return "STMicroelectronics ST100 processor";
1931 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1932 case EM_PDSP
: return "Sony DSP processor";
1933 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1934 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1935 case EM_FX66
: return "Siemens FX66 microcontroller";
1936 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1937 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1938 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1939 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1940 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1941 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1942 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1943 case EM_SVX
: return "Silicon Graphics SVx";
1944 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1945 case EM_VAX
: return "Digital VAX";
1947 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1948 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1949 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1950 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1951 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1952 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1953 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1954 case EM_PRISM
: return "Vitesse Prism";
1955 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1956 case EM_L1OM
: return "Intel L1OM";
1957 case EM_K1OM
: return "Intel K1OM";
1959 case EM_S390
: return "IBM S/390";
1960 case EM_SCORE
: return "SUNPLUS S+Core";
1961 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1963 case EM_OR32
: return "OpenRISC";
1964 case EM_ARC_A5
: return "ARC International ARCompact processor";
1965 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1966 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
1967 case EM_DLX
: return "OpenDLX";
1969 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1970 case EM_IQ2000
: return "Vitesse IQ2000";
1972 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1973 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1974 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1975 case EM_NS32K
: return "National Semiconductor 32000 series";
1976 case EM_TPC
: return "Tenor Network TPC processor";
1977 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1978 case EM_MAX
: return "MAX Processor";
1979 case EM_CR
: return "National Semiconductor CompactRISC";
1980 case EM_F2MC16
: return "Fujitsu F2MC16";
1981 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1982 case EM_LATTICEMICO32
: return "Lattice Mico32";
1984 case EM_M32C
: return "Renesas M32c";
1985 case EM_MT
: return "Morpho Techologies MT processor";
1986 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1987 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1988 case EM_SEP
: return "Sharp embedded microprocessor";
1989 case EM_ARCA
: return "Arca RISC microprocessor";
1990 case EM_UNICORE
: return "Unicore";
1991 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1992 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1993 case EM_NIOS32
: return "Altera Nios";
1994 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1996 case EM_XC16X
: return "Infineon Technologies xc16x";
1997 case EM_M16C
: return "Renesas M16C series microprocessors";
1998 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1999 case EM_CE
: return "Freescale Communication Engine RISC core";
2000 case EM_TSK3000
: return "Altium TSK3000 core";
2001 case EM_RS08
: return "Freescale RS08 embedded processor";
2002 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2003 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2004 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2005 case EM_SE_C17
: return "Seiko Epson C17 family";
2006 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2007 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2008 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2009 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2010 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2011 case EM_R32C
: return "Renesas R32C series microprocessors";
2012 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2013 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2014 case EM_8051
: return "Intel 8051 and variants";
2015 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2016 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2017 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2018 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2019 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2020 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2021 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2022 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2025 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2026 case EM_RL78
: return "Renesas RL78";
2027 case EM_RX
: return "Renesas RX";
2028 case EM_METAG
: return "Imagination Technologies META processor architecture";
2029 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2030 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2031 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2032 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2033 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2034 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2035 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2036 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2037 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2038 case EM_CUDA
: return "NVIDIA CUDA architecture";
2039 case EM_XGATE
: return "Motorola XGATE embedded processor";
2041 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2047 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2052 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2053 e_flags
&= ~ EF_ARM_EABIMASK
;
2055 /* Handle "generic" ARM flags. */
2056 if (e_flags
& EF_ARM_RELEXEC
)
2058 strcat (buf
, ", relocatable executable");
2059 e_flags
&= ~ EF_ARM_RELEXEC
;
2062 if (e_flags
& EF_ARM_HASENTRY
)
2064 strcat (buf
, ", has entry point");
2065 e_flags
&= ~ EF_ARM_HASENTRY
;
2068 /* Now handle EABI specific flags. */
2072 strcat (buf
, ", <unrecognized EABI>");
2077 case EF_ARM_EABI_VER1
:
2078 strcat (buf
, ", Version1 EABI");
2083 /* Process flags one bit at a time. */
2084 flag
= e_flags
& - e_flags
;
2089 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2090 strcat (buf
, ", sorted symbol tables");
2100 case EF_ARM_EABI_VER2
:
2101 strcat (buf
, ", Version2 EABI");
2106 /* Process flags one bit at a time. */
2107 flag
= e_flags
& - e_flags
;
2112 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2113 strcat (buf
, ", sorted symbol tables");
2116 case EF_ARM_DYNSYMSUSESEGIDX
:
2117 strcat (buf
, ", dynamic symbols use segment index");
2120 case EF_ARM_MAPSYMSFIRST
:
2121 strcat (buf
, ", mapping symbols precede others");
2131 case EF_ARM_EABI_VER3
:
2132 strcat (buf
, ", Version3 EABI");
2135 case EF_ARM_EABI_VER4
:
2136 strcat (buf
, ", Version4 EABI");
2141 /* Process flags one bit at a time. */
2142 flag
= e_flags
& - e_flags
;
2148 strcat (buf
, ", BE8");
2152 strcat (buf
, ", LE8");
2163 case EF_ARM_EABI_VER5
:
2164 strcat (buf
, ", Version5 EABI");
2169 /* Process flags one bit at a time. */
2170 flag
= e_flags
& - e_flags
;
2176 strcat (buf
, ", BE8");
2180 strcat (buf
, ", LE8");
2183 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2184 strcat (buf
, ", soft-float ABI");
2187 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2188 strcat (buf
, ", hard-float ABI");
2198 case EF_ARM_EABI_UNKNOWN
:
2199 strcat (buf
, ", GNU EABI");
2204 /* Process flags one bit at a time. */
2205 flag
= e_flags
& - e_flags
;
2210 case EF_ARM_INTERWORK
:
2211 strcat (buf
, ", interworking enabled");
2214 case EF_ARM_APCS_26
:
2215 strcat (buf
, ", uses APCS/26");
2218 case EF_ARM_APCS_FLOAT
:
2219 strcat (buf
, ", uses APCS/float");
2223 strcat (buf
, ", position independent");
2227 strcat (buf
, ", 8 bit structure alignment");
2230 case EF_ARM_NEW_ABI
:
2231 strcat (buf
, ", uses new ABI");
2234 case EF_ARM_OLD_ABI
:
2235 strcat (buf
, ", uses old ABI");
2238 case EF_ARM_SOFT_FLOAT
:
2239 strcat (buf
, ", software FP");
2242 case EF_ARM_VFP_FLOAT
:
2243 strcat (buf
, ", VFP");
2246 case EF_ARM_MAVERICK_FLOAT
:
2247 strcat (buf
, ", Maverick FP");
2258 strcat (buf
,_(", <unknown>"));
2262 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2264 static char buf
[1024];
2276 decode_ARM_machine_flags (e_flags
, buf
);
2280 if (e_flags
& EF_BFIN_PIC
)
2281 strcat (buf
, ", PIC");
2283 if (e_flags
& EF_BFIN_FDPIC
)
2284 strcat (buf
, ", FDPIC");
2286 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2287 strcat (buf
, ", code in L1");
2289 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2290 strcat (buf
, ", data in L1");
2295 switch (e_flags
& EF_FRV_CPU_MASK
)
2297 case EF_FRV_CPU_GENERIC
:
2301 strcat (buf
, ", fr???");
2304 case EF_FRV_CPU_FR300
:
2305 strcat (buf
, ", fr300");
2308 case EF_FRV_CPU_FR400
:
2309 strcat (buf
, ", fr400");
2311 case EF_FRV_CPU_FR405
:
2312 strcat (buf
, ", fr405");
2315 case EF_FRV_CPU_FR450
:
2316 strcat (buf
, ", fr450");
2319 case EF_FRV_CPU_FR500
:
2320 strcat (buf
, ", fr500");
2322 case EF_FRV_CPU_FR550
:
2323 strcat (buf
, ", fr550");
2326 case EF_FRV_CPU_SIMPLE
:
2327 strcat (buf
, ", simple");
2329 case EF_FRV_CPU_TOMCAT
:
2330 strcat (buf
, ", tomcat");
2336 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2337 strcat (buf
, ", m68000");
2338 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2339 strcat (buf
, ", cpu32");
2340 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2341 strcat (buf
, ", fido_a");
2344 char const * isa
= _("unknown");
2345 char const * mac
= _("unknown mac");
2346 char const * additional
= NULL
;
2348 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2350 case EF_M68K_CF_ISA_A_NODIV
:
2352 additional
= ", nodiv";
2354 case EF_M68K_CF_ISA_A
:
2357 case EF_M68K_CF_ISA_A_PLUS
:
2360 case EF_M68K_CF_ISA_B_NOUSP
:
2362 additional
= ", nousp";
2364 case EF_M68K_CF_ISA_B
:
2367 case EF_M68K_CF_ISA_C
:
2370 case EF_M68K_CF_ISA_C_NODIV
:
2372 additional
= ", nodiv";
2375 strcat (buf
, ", cf, isa ");
2378 strcat (buf
, additional
);
2379 if (e_flags
& EF_M68K_CF_FLOAT
)
2380 strcat (buf
, ", float");
2381 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2386 case EF_M68K_CF_MAC
:
2389 case EF_M68K_CF_EMAC
:
2392 case EF_M68K_CF_EMAC_B
:
2405 if (e_flags
& EF_PPC_EMB
)
2406 strcat (buf
, ", emb");
2408 if (e_flags
& EF_PPC_RELOCATABLE
)
2409 strcat (buf
, _(", relocatable"));
2411 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2412 strcat (buf
, _(", relocatable-lib"));
2416 case EM_CYGNUS_V850
:
2417 switch (e_flags
& EF_V850_ARCH
)
2419 case E_V850E2V3_ARCH
:
2420 strcat (buf
, ", v850e2v3");
2423 strcat (buf
, ", v850e2");
2426 strcat (buf
, ", v850e1");
2429 strcat (buf
, ", v850e");
2432 strcat (buf
, ", v850");
2435 strcat (buf
, _(", unknown v850 architecture variant"));
2441 case EM_CYGNUS_M32R
:
2442 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2443 strcat (buf
, ", m32r");
2447 case EM_MIPS_RS3_LE
:
2448 if (e_flags
& EF_MIPS_NOREORDER
)
2449 strcat (buf
, ", noreorder");
2451 if (e_flags
& EF_MIPS_PIC
)
2452 strcat (buf
, ", pic");
2454 if (e_flags
& EF_MIPS_CPIC
)
2455 strcat (buf
, ", cpic");
2457 if (e_flags
& EF_MIPS_UCODE
)
2458 strcat (buf
, ", ugen_reserved");
2460 if (e_flags
& EF_MIPS_ABI2
)
2461 strcat (buf
, ", abi2");
2463 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2464 strcat (buf
, ", odk first");
2466 if (e_flags
& EF_MIPS_32BITMODE
)
2467 strcat (buf
, ", 32bitmode");
2469 switch ((e_flags
& EF_MIPS_MACH
))
2471 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2472 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2473 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2474 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2475 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2476 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2477 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2478 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2479 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2480 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2481 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2482 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2483 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2484 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2485 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2486 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2488 /* We simply ignore the field in this case to avoid confusion:
2489 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2492 default: strcat (buf
, _(", unknown CPU")); break;
2495 switch ((e_flags
& EF_MIPS_ABI
))
2497 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2498 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2499 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2500 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2502 /* We simply ignore the field in this case to avoid confusion:
2503 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2504 This means it is likely to be an o32 file, but not for
2507 default: strcat (buf
, _(", unknown ABI")); break;
2510 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2511 strcat (buf
, ", mdmx");
2513 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2514 strcat (buf
, ", mips16");
2516 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2517 strcat (buf
, ", micromips");
2519 switch ((e_flags
& EF_MIPS_ARCH
))
2521 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2522 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2523 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2524 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2525 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2526 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2527 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2528 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2529 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2530 default: strcat (buf
, _(", unknown ISA")); break;
2533 if (e_flags
& EF_SH_PIC
)
2534 strcat (buf
, ", pic");
2536 if (e_flags
& EF_SH_FDPIC
)
2537 strcat (buf
, ", fdpic");
2541 switch ((e_flags
& EF_SH_MACH_MASK
))
2543 case EF_SH1
: strcat (buf
, ", sh1"); break;
2544 case EF_SH2
: strcat (buf
, ", sh2"); break;
2545 case EF_SH3
: strcat (buf
, ", sh3"); break;
2546 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2547 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2548 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2549 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2550 case EF_SH4
: strcat (buf
, ", sh4"); break;
2551 case EF_SH5
: strcat (buf
, ", sh5"); break;
2552 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2553 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2554 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2555 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2556 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2557 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2558 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2559 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2560 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2561 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2562 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2563 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2564 default: strcat (buf
, _(", unknown ISA")); break;
2570 if (e_flags
& EF_SPARC_32PLUS
)
2571 strcat (buf
, ", v8+");
2573 if (e_flags
& EF_SPARC_SUN_US1
)
2574 strcat (buf
, ", ultrasparcI");
2576 if (e_flags
& EF_SPARC_SUN_US3
)
2577 strcat (buf
, ", ultrasparcIII");
2579 if (e_flags
& EF_SPARC_HAL_R1
)
2580 strcat (buf
, ", halr1");
2582 if (e_flags
& EF_SPARC_LEDATA
)
2583 strcat (buf
, ", ledata");
2585 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2586 strcat (buf
, ", tso");
2588 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2589 strcat (buf
, ", pso");
2591 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2592 strcat (buf
, ", rmo");
2596 switch (e_flags
& EF_PARISC_ARCH
)
2598 case EFA_PARISC_1_0
:
2599 strcpy (buf
, ", PA-RISC 1.0");
2601 case EFA_PARISC_1_1
:
2602 strcpy (buf
, ", PA-RISC 1.1");
2604 case EFA_PARISC_2_0
:
2605 strcpy (buf
, ", PA-RISC 2.0");
2610 if (e_flags
& EF_PARISC_TRAPNIL
)
2611 strcat (buf
, ", trapnil");
2612 if (e_flags
& EF_PARISC_EXT
)
2613 strcat (buf
, ", ext");
2614 if (e_flags
& EF_PARISC_LSB
)
2615 strcat (buf
, ", lsb");
2616 if (e_flags
& EF_PARISC_WIDE
)
2617 strcat (buf
, ", wide");
2618 if (e_flags
& EF_PARISC_NO_KABP
)
2619 strcat (buf
, ", no kabp");
2620 if (e_flags
& EF_PARISC_LAZYSWAP
)
2621 strcat (buf
, ", lazyswap");
2626 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2627 strcat (buf
, ", new calling convention");
2629 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2630 strcat (buf
, ", gnu calling convention");
2634 if ((e_flags
& EF_IA_64_ABI64
))
2635 strcat (buf
, ", 64-bit");
2637 strcat (buf
, ", 32-bit");
2638 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2639 strcat (buf
, ", reduced fp model");
2640 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2641 strcat (buf
, ", no function descriptors, constant gp");
2642 else if ((e_flags
& EF_IA_64_CONS_GP
))
2643 strcat (buf
, ", constant gp");
2644 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2645 strcat (buf
, ", absolute");
2646 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2648 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2649 strcat (buf
, ", vms_linkages");
2650 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2652 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2654 case EF_IA_64_VMS_COMCOD_WARNING
:
2655 strcat (buf
, ", warning");
2657 case EF_IA_64_VMS_COMCOD_ERROR
:
2658 strcat (buf
, ", error");
2660 case EF_IA_64_VMS_COMCOD_ABORT
:
2661 strcat (buf
, ", abort");
2670 if ((e_flags
& EF_VAX_NONPIC
))
2671 strcat (buf
, ", non-PIC");
2672 if ((e_flags
& EF_VAX_DFLOAT
))
2673 strcat (buf
, ", D-Float");
2674 if ((e_flags
& EF_VAX_GFLOAT
))
2675 strcat (buf
, ", G-Float");
2679 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2680 strcat (buf
, ", 64-bit doubles");
2681 if (e_flags
& E_FLAG_RX_DSP
)
2682 strcat (buf
, ", dsp");
2683 if (e_flags
& E_FLAG_RX_PID
)
2684 strcat (buf
, ", pid");
2688 if (e_flags
& EF_S390_HIGH_GPRS
)
2689 strcat (buf
, ", highgprs");
2693 if ((e_flags
& EF_C6000_REL
))
2694 strcat (buf
, ", relocatable module");
2703 get_osabi_name (unsigned int osabi
)
2705 static char buff
[32];
2709 case ELFOSABI_NONE
: return "UNIX - System V";
2710 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2711 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2712 case ELFOSABI_GNU
: return "UNIX - GNU";
2713 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2714 case ELFOSABI_AIX
: return "UNIX - AIX";
2715 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2716 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2717 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2718 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2719 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2720 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2721 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2722 case ELFOSABI_AROS
: return "AROS";
2723 case ELFOSABI_FENIXOS
: return "FenixOS";
2726 switch (elf_header
.e_machine
)
2731 case ELFOSABI_ARM
: return "ARM";
2741 case ELFOSABI_STANDALONE
: return _("Standalone App");
2750 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2751 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2760 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2766 get_aarch64_segment_type (unsigned long type
)
2770 case PT_AARCH64_ARCHEXT
:
2771 return "AARCH64_ARCHEXT";
2780 get_arm_segment_type (unsigned long type
)
2794 get_mips_segment_type (unsigned long type
)
2798 case PT_MIPS_REGINFO
:
2800 case PT_MIPS_RTPROC
:
2802 case PT_MIPS_OPTIONS
:
2812 get_parisc_segment_type (unsigned long type
)
2816 case PT_HP_TLS
: return "HP_TLS";
2817 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2818 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2819 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2820 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2821 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2822 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2823 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2824 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2825 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2826 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2827 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2828 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2829 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2830 case PT_HP_STACK
: return "HP_STACK";
2831 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2832 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2833 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2834 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2843 get_ia64_segment_type (unsigned long type
)
2847 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2848 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2849 case PT_HP_TLS
: return "HP_TLS";
2850 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2851 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2852 case PT_IA_64_HP_STACK
: return "HP_STACK";
2861 get_tic6x_segment_type (unsigned long type
)
2865 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2874 get_segment_type (unsigned long p_type
)
2876 static char buff
[32];
2880 case PT_NULL
: return "NULL";
2881 case PT_LOAD
: return "LOAD";
2882 case PT_DYNAMIC
: return "DYNAMIC";
2883 case PT_INTERP
: return "INTERP";
2884 case PT_NOTE
: return "NOTE";
2885 case PT_SHLIB
: return "SHLIB";
2886 case PT_PHDR
: return "PHDR";
2887 case PT_TLS
: return "TLS";
2889 case PT_GNU_EH_FRAME
:
2890 return "GNU_EH_FRAME";
2891 case PT_GNU_STACK
: return "GNU_STACK";
2892 case PT_GNU_RELRO
: return "GNU_RELRO";
2895 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2897 const char * result
;
2899 switch (elf_header
.e_machine
)
2902 result
= get_aarch64_segment_type (p_type
);
2905 result
= get_arm_segment_type (p_type
);
2908 case EM_MIPS_RS3_LE
:
2909 result
= get_mips_segment_type (p_type
);
2912 result
= get_parisc_segment_type (p_type
);
2915 result
= get_ia64_segment_type (p_type
);
2918 result
= get_tic6x_segment_type (p_type
);
2928 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2930 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2932 const char * result
;
2934 switch (elf_header
.e_machine
)
2937 result
= get_parisc_segment_type (p_type
);
2940 result
= get_ia64_segment_type (p_type
);
2950 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2953 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2960 get_mips_section_type_name (unsigned int sh_type
)
2964 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2965 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2966 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2967 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2968 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2969 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2970 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2971 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2972 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2973 case SHT_MIPS_RELD
: return "MIPS_RELD";
2974 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2975 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2976 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2977 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2978 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2979 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2980 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2981 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2982 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2983 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2984 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2985 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2986 case SHT_MIPS_LINE
: return "MIPS_LINE";
2987 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2988 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2989 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2990 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2991 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2992 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2993 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2994 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2995 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2996 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2997 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2998 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2999 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3000 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3001 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3002 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3010 get_parisc_section_type_name (unsigned int sh_type
)
3014 case SHT_PARISC_EXT
: return "PARISC_EXT";
3015 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3016 case SHT_PARISC_DOC
: return "PARISC_DOC";
3017 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3018 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3019 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3020 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3028 get_ia64_section_type_name (unsigned int sh_type
)
3030 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3031 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3032 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3036 case SHT_IA_64_EXT
: return "IA_64_EXT";
3037 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3038 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3039 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3040 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3041 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3042 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3043 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3044 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3045 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3053 get_x86_64_section_type_name (unsigned int sh_type
)
3057 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3065 get_aarch64_section_type_name (unsigned int sh_type
)
3069 case SHT_AARCH64_ATTRIBUTES
:
3070 return "AARCH64_ATTRIBUTES";
3078 get_arm_section_type_name (unsigned int sh_type
)
3082 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3083 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3084 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3085 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3086 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3094 get_tic6x_section_type_name (unsigned int sh_type
)
3098 case SHT_C6000_UNWIND
:
3099 return "C6000_UNWIND";
3100 case SHT_C6000_PREEMPTMAP
:
3101 return "C6000_PREEMPTMAP";
3102 case SHT_C6000_ATTRIBUTES
:
3103 return "C6000_ATTRIBUTES";
3108 case SHT_TI_HANDLER
:
3109 return "TI_HANDLER";
3110 case SHT_TI_INITINFO
:
3111 return "TI_INITINFO";
3112 case SHT_TI_PHATTRS
:
3113 return "TI_PHATTRS";
3121 get_section_type_name (unsigned int sh_type
)
3123 static char buff
[32];
3127 case SHT_NULL
: return "NULL";
3128 case SHT_PROGBITS
: return "PROGBITS";
3129 case SHT_SYMTAB
: return "SYMTAB";
3130 case SHT_STRTAB
: return "STRTAB";
3131 case SHT_RELA
: return "RELA";
3132 case SHT_HASH
: return "HASH";
3133 case SHT_DYNAMIC
: return "DYNAMIC";
3134 case SHT_NOTE
: return "NOTE";
3135 case SHT_NOBITS
: return "NOBITS";
3136 case SHT_REL
: return "REL";
3137 case SHT_SHLIB
: return "SHLIB";
3138 case SHT_DYNSYM
: return "DYNSYM";
3139 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3140 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3141 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3142 case SHT_GNU_HASH
: return "GNU_HASH";
3143 case SHT_GROUP
: return "GROUP";
3144 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3145 case SHT_GNU_verdef
: return "VERDEF";
3146 case SHT_GNU_verneed
: return "VERNEED";
3147 case SHT_GNU_versym
: return "VERSYM";
3148 case 0x6ffffff0: return "VERSYM";
3149 case 0x6ffffffc: return "VERDEF";
3150 case 0x7ffffffd: return "AUXILIARY";
3151 case 0x7fffffff: return "FILTER";
3152 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3155 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3157 const char * result
;
3159 switch (elf_header
.e_machine
)
3162 case EM_MIPS_RS3_LE
:
3163 result
= get_mips_section_type_name (sh_type
);
3166 result
= get_parisc_section_type_name (sh_type
);
3169 result
= get_ia64_section_type_name (sh_type
);
3174 result
= get_x86_64_section_type_name (sh_type
);
3177 result
= get_aarch64_section_type_name (sh_type
);
3180 result
= get_arm_section_type_name (sh_type
);
3183 result
= get_tic6x_section_type_name (sh_type
);
3193 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3195 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3197 const char * result
;
3199 switch (elf_header
.e_machine
)
3202 result
= get_ia64_section_type_name (sh_type
);
3212 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3214 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3215 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3217 /* This message is probably going to be displayed in a 15
3218 character wide field, so put the hex value first. */
3219 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3225 #define OPTION_DEBUG_DUMP 512
3226 #define OPTION_DYN_SYMS 513
3227 #define OPTION_DWARF_DEPTH 514
3228 #define OPTION_DWARF_START 515
3229 #define OPTION_DWARF_CHECK 516
3231 static struct option options
[] =
3233 {"all", no_argument
, 0, 'a'},
3234 {"file-header", no_argument
, 0, 'h'},
3235 {"program-headers", no_argument
, 0, 'l'},
3236 {"headers", no_argument
, 0, 'e'},
3237 {"histogram", no_argument
, 0, 'I'},
3238 {"segments", no_argument
, 0, 'l'},
3239 {"sections", no_argument
, 0, 'S'},
3240 {"section-headers", no_argument
, 0, 'S'},
3241 {"section-groups", no_argument
, 0, 'g'},
3242 {"section-details", no_argument
, 0, 't'},
3243 {"full-section-name",no_argument
, 0, 'N'},
3244 {"symbols", no_argument
, 0, 's'},
3245 {"syms", no_argument
, 0, 's'},
3246 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3247 {"relocs", no_argument
, 0, 'r'},
3248 {"notes", no_argument
, 0, 'n'},
3249 {"dynamic", no_argument
, 0, 'd'},
3250 {"arch-specific", no_argument
, 0, 'A'},
3251 {"version-info", no_argument
, 0, 'V'},
3252 {"use-dynamic", no_argument
, 0, 'D'},
3253 {"unwind", no_argument
, 0, 'u'},
3254 {"archive-index", no_argument
, 0, 'c'},
3255 {"hex-dump", required_argument
, 0, 'x'},
3256 {"relocated-dump", required_argument
, 0, 'R'},
3257 {"string-dump", required_argument
, 0, 'p'},
3258 #ifdef SUPPORT_DISASSEMBLY
3259 {"instruction-dump", required_argument
, 0, 'i'},
3261 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3263 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3264 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3265 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3267 {"version", no_argument
, 0, 'v'},
3268 {"wide", no_argument
, 0, 'W'},
3269 {"help", no_argument
, 0, 'H'},
3270 {0, no_argument
, 0, 0}
3274 usage (FILE * stream
)
3276 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3277 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3278 fprintf (stream
, _(" Options are:\n\
3279 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3280 -h --file-header Display the ELF file header\n\
3281 -l --program-headers Display the program headers\n\
3282 --segments An alias for --program-headers\n\
3283 -S --section-headers Display the sections' header\n\
3284 --sections An alias for --section-headers\n\
3285 -g --section-groups Display the section groups\n\
3286 -t --section-details Display the section details\n\
3287 -e --headers Equivalent to: -h -l -S\n\
3288 -s --syms Display the symbol table\n\
3289 --symbols An alias for --syms\n\
3290 --dyn-syms Display the dynamic symbol table\n\
3291 -n --notes Display the core notes (if present)\n\
3292 -r --relocs Display the relocations (if present)\n\
3293 -u --unwind Display the unwind info (if present)\n\
3294 -d --dynamic Display the dynamic section (if present)\n\
3295 -V --version-info Display the version sections (if present)\n\
3296 -A --arch-specific Display architecture specific information (if any)\n\
3297 -c --archive-index Display the symbol/file index in an archive\n\
3298 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3299 -x --hex-dump=<number|name>\n\
3300 Dump the contents of section <number|name> as bytes\n\
3301 -p --string-dump=<number|name>\n\
3302 Dump the contents of section <number|name> as strings\n\
3303 -R --relocated-dump=<number|name>\n\
3304 Dump the contents of section <number|name> as relocated bytes\n\
3305 -w[lLiaprmfFsoRt] or\n\
3306 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3307 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3308 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3310 Display the contents of DWARF2 debug sections\n"));
3311 fprintf (stream
, _("\
3312 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3313 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3315 #ifdef SUPPORT_DISASSEMBLY
3316 fprintf (stream
, _("\
3317 -i --instruction-dump=<number|name>\n\
3318 Disassemble the contents of section <number|name>\n"));
3320 fprintf (stream
, _("\
3321 -I --histogram Display histogram of bucket list lengths\n\
3322 -W --wide Allow output width to exceed 80 characters\n\
3323 @<file> Read options from <file>\n\
3324 -H --help Display this information\n\
3325 -v --version Display the version number of readelf\n"));
3327 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3328 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3330 exit (stream
== stdout
? 0 : 1);
3333 /* Record the fact that the user wants the contents of section number
3334 SECTION to be displayed using the method(s) encoded as flags bits
3335 in TYPE. Note, TYPE can be zero if we are creating the array for
3339 request_dump_bynumber (unsigned int section
, dump_type type
)
3341 if (section
>= num_dump_sects
)
3343 dump_type
* new_dump_sects
;
3345 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3346 sizeof (* dump_sects
));
3348 if (new_dump_sects
== NULL
)
3349 error (_("Out of memory allocating dump request table.\n"));
3352 /* Copy current flag settings. */
3353 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3357 dump_sects
= new_dump_sects
;
3358 num_dump_sects
= section
+ 1;
3363 dump_sects
[section
] |= type
;
3368 /* Request a dump by section name. */
3371 request_dump_byname (const char * section
, dump_type type
)
3373 struct dump_list_entry
* new_request
;
3375 new_request
= (struct dump_list_entry
*)
3376 malloc (sizeof (struct dump_list_entry
));
3378 error (_("Out of memory allocating dump request table.\n"));
3380 new_request
->name
= strdup (section
);
3381 if (!new_request
->name
)
3382 error (_("Out of memory allocating dump request table.\n"));
3384 new_request
->type
= type
;
3386 new_request
->next
= dump_sects_byname
;
3387 dump_sects_byname
= new_request
;
3391 request_dump (dump_type type
)
3397 section
= strtoul (optarg
, & cp
, 0);
3399 if (! *cp
&& section
>= 0)
3400 request_dump_bynumber (section
, type
);
3402 request_dump_byname (optarg
, type
);
3407 parse_args (int argc
, char ** argv
)
3414 while ((c
= getopt_long
3415 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3433 do_section_groups
++;
3441 do_section_groups
++;
3446 do_section_details
++;
3490 request_dump (HEX_DUMP
);
3493 request_dump (STRING_DUMP
);
3496 request_dump (RELOC_DUMP
);
3503 dwarf_select_sections_all ();
3508 dwarf_select_sections_by_letters (optarg
);
3511 case OPTION_DEBUG_DUMP
:
3518 dwarf_select_sections_by_names (optarg
);
3521 case OPTION_DWARF_DEPTH
:
3525 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3528 case OPTION_DWARF_START
:
3532 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3535 case OPTION_DWARF_CHECK
:
3538 case OPTION_DYN_SYMS
:
3541 #ifdef SUPPORT_DISASSEMBLY
3543 request_dump (DISASS_DUMP
);
3547 print_version (program_name
);
3556 /* xgettext:c-format */
3557 error (_("Invalid option '-%c'\n"), c
);
3564 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3565 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3566 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3567 && !do_section_groups
&& !do_archive_index
3572 warn (_("Nothing to do.\n"));
3578 get_elf_class (unsigned int elf_class
)
3580 static char buff
[32];
3584 case ELFCLASSNONE
: return _("none");
3585 case ELFCLASS32
: return "ELF32";
3586 case ELFCLASS64
: return "ELF64";
3588 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3594 get_data_encoding (unsigned int encoding
)
3596 static char buff
[32];
3600 case ELFDATANONE
: return _("none");
3601 case ELFDATA2LSB
: return _("2's complement, little endian");
3602 case ELFDATA2MSB
: return _("2's complement, big endian");
3604 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3609 /* Decode the data held in 'elf_header'. */
3612 process_file_header (void)
3614 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3615 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3616 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3617 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3620 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3624 init_dwarf_regnames (elf_header
.e_machine
);
3630 printf (_("ELF Header:\n"));
3631 printf (_(" Magic: "));
3632 for (i
= 0; i
< EI_NIDENT
; i
++)
3633 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3635 printf (_(" Class: %s\n"),
3636 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3637 printf (_(" Data: %s\n"),
3638 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3639 printf (_(" Version: %d %s\n"),
3640 elf_header
.e_ident
[EI_VERSION
],
3641 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3643 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3644 ? _("<unknown: %lx>")
3646 printf (_(" OS/ABI: %s\n"),
3647 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3648 printf (_(" ABI Version: %d\n"),
3649 elf_header
.e_ident
[EI_ABIVERSION
]);
3650 printf (_(" Type: %s\n"),
3651 get_file_type (elf_header
.e_type
));
3652 printf (_(" Machine: %s\n"),
3653 get_machine_name (elf_header
.e_machine
));
3654 printf (_(" Version: 0x%lx\n"),
3655 (unsigned long) elf_header
.e_version
);
3657 printf (_(" Entry point address: "));
3658 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3659 printf (_("\n Start of program headers: "));
3660 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3661 printf (_(" (bytes into file)\n Start of section headers: "));
3662 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3663 printf (_(" (bytes into file)\n"));
3665 printf (_(" Flags: 0x%lx%s\n"),
3666 (unsigned long) elf_header
.e_flags
,
3667 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3668 printf (_(" Size of this header: %ld (bytes)\n"),
3669 (long) elf_header
.e_ehsize
);
3670 printf (_(" Size of program headers: %ld (bytes)\n"),
3671 (long) elf_header
.e_phentsize
);
3672 printf (_(" Number of program headers: %ld"),
3673 (long) elf_header
.e_phnum
);
3674 if (section_headers
!= NULL
3675 && elf_header
.e_phnum
== PN_XNUM
3676 && section_headers
[0].sh_info
!= 0)
3677 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3678 putc ('\n', stdout
);
3679 printf (_(" Size of section headers: %ld (bytes)\n"),
3680 (long) elf_header
.e_shentsize
);
3681 printf (_(" Number of section headers: %ld"),
3682 (long) elf_header
.e_shnum
);
3683 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3684 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3685 putc ('\n', stdout
);
3686 printf (_(" Section header string table index: %ld"),
3687 (long) elf_header
.e_shstrndx
);
3688 if (section_headers
!= NULL
3689 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3690 printf (" (%u)", section_headers
[0].sh_link
);
3691 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3692 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3693 printf (_(" <corrupt: out of range>"));
3694 putc ('\n', stdout
);
3697 if (section_headers
!= NULL
)
3699 if (elf_header
.e_phnum
== PN_XNUM
3700 && section_headers
[0].sh_info
!= 0)
3701 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3702 if (elf_header
.e_shnum
== SHN_UNDEF
)
3703 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3704 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3705 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3706 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3707 elf_header
.e_shstrndx
= SHN_UNDEF
;
3708 free (section_headers
);
3709 section_headers
= NULL
;
3717 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3719 Elf32_External_Phdr
* phdrs
;
3720 Elf32_External_Phdr
* external
;
3721 Elf_Internal_Phdr
* internal
;
3724 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3725 elf_header
.e_phentsize
,
3727 _("program headers"));
3731 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3732 i
< elf_header
.e_phnum
;
3733 i
++, internal
++, external
++)
3735 internal
->p_type
= BYTE_GET (external
->p_type
);
3736 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3737 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3738 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3739 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3740 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3741 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3742 internal
->p_align
= BYTE_GET (external
->p_align
);
3751 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3753 Elf64_External_Phdr
* phdrs
;
3754 Elf64_External_Phdr
* external
;
3755 Elf_Internal_Phdr
* internal
;
3758 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3759 elf_header
.e_phentsize
,
3761 _("program headers"));
3765 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3766 i
< elf_header
.e_phnum
;
3767 i
++, internal
++, external
++)
3769 internal
->p_type
= BYTE_GET (external
->p_type
);
3770 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3771 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3772 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3773 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3774 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3775 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3776 internal
->p_align
= BYTE_GET (external
->p_align
);
3784 /* Returns 1 if the program headers were read into `program_headers'. */
3787 get_program_headers (FILE * file
)
3789 Elf_Internal_Phdr
* phdrs
;
3791 /* Check cache of prior read. */
3792 if (program_headers
!= NULL
)
3795 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3796 sizeof (Elf_Internal_Phdr
));
3800 error (_("Out of memory\n"));
3805 ? get_32bit_program_headers (file
, phdrs
)
3806 : get_64bit_program_headers (file
, phdrs
))
3808 program_headers
= phdrs
;
3816 /* Returns 1 if the program headers were loaded. */
3819 process_program_headers (FILE * file
)
3821 Elf_Internal_Phdr
* segment
;
3824 if (elf_header
.e_phnum
== 0)
3826 /* PR binutils/12467. */
3827 if (elf_header
.e_phoff
!= 0)
3828 warn (_("possibly corrupt ELF header - it has a non-zero program"
3829 " header offset, but no program headers"));
3830 else if (do_segments
)
3831 printf (_("\nThere are no program headers in this file.\n"));
3835 if (do_segments
&& !do_header
)
3837 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3838 printf (_("Entry point "));
3839 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3840 printf (_("\nThere are %d program headers, starting at offset "),
3841 elf_header
.e_phnum
);
3842 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3846 if (! get_program_headers (file
))
3851 if (elf_header
.e_phnum
> 1)
3852 printf (_("\nProgram Headers:\n"));
3854 printf (_("\nProgram Headers:\n"));
3858 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3861 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3865 (_(" Type Offset VirtAddr PhysAddr\n"));
3867 (_(" FileSiz MemSiz Flags Align\n"));
3874 for (i
= 0, segment
= program_headers
;
3875 i
< elf_header
.e_phnum
;
3880 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3884 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3885 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3886 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3887 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3888 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3890 (segment
->p_flags
& PF_R
? 'R' : ' '),
3891 (segment
->p_flags
& PF_W
? 'W' : ' '),
3892 (segment
->p_flags
& PF_X
? 'E' : ' '));
3893 printf ("%#lx", (unsigned long) segment
->p_align
);
3897 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3898 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3901 print_vma (segment
->p_offset
, FULL_HEX
);
3905 print_vma (segment
->p_vaddr
, FULL_HEX
);
3907 print_vma (segment
->p_paddr
, FULL_HEX
);
3910 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3911 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3914 print_vma (segment
->p_filesz
, FULL_HEX
);
3918 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3919 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3922 print_vma (segment
->p_memsz
, FULL_HEX
);
3926 (segment
->p_flags
& PF_R
? 'R' : ' '),
3927 (segment
->p_flags
& PF_W
? 'W' : ' '),
3928 (segment
->p_flags
& PF_X
? 'E' : ' '));
3930 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3931 printf ("%#lx", (unsigned long) segment
->p_align
);
3934 print_vma (segment
->p_align
, PREFIX_HEX
);
3939 print_vma (segment
->p_offset
, FULL_HEX
);
3941 print_vma (segment
->p_vaddr
, FULL_HEX
);
3943 print_vma (segment
->p_paddr
, FULL_HEX
);
3945 print_vma (segment
->p_filesz
, FULL_HEX
);
3947 print_vma (segment
->p_memsz
, FULL_HEX
);
3949 (segment
->p_flags
& PF_R
? 'R' : ' '),
3950 (segment
->p_flags
& PF_W
? 'W' : ' '),
3951 (segment
->p_flags
& PF_X
? 'E' : ' '));
3952 print_vma (segment
->p_align
, HEX
);
3956 switch (segment
->p_type
)
3960 error (_("more than one dynamic segment\n"));
3962 /* By default, assume that the .dynamic section is the first
3963 section in the DYNAMIC segment. */
3964 dynamic_addr
= segment
->p_offset
;
3965 dynamic_size
= segment
->p_filesz
;
3967 /* Try to locate the .dynamic section. If there is
3968 a section header table, we can easily locate it. */
3969 if (section_headers
!= NULL
)
3971 Elf_Internal_Shdr
* sec
;
3973 sec
= find_section (".dynamic");
3974 if (sec
== NULL
|| sec
->sh_size
== 0)
3976 /* A corresponding .dynamic section is expected, but on
3977 IA-64/OpenVMS it is OK for it to be missing. */
3978 if (!is_ia64_vms ())
3979 error (_("no .dynamic section in the dynamic segment\n"));
3983 if (sec
->sh_type
== SHT_NOBITS
)
3989 dynamic_addr
= sec
->sh_offset
;
3990 dynamic_size
= sec
->sh_size
;
3992 if (dynamic_addr
< segment
->p_offset
3993 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3994 warn (_("the .dynamic section is not contained"
3995 " within the dynamic segment\n"));
3996 else if (dynamic_addr
> segment
->p_offset
)
3997 warn (_("the .dynamic section is not the first section"
3998 " in the dynamic segment.\n"));
4003 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4005 error (_("Unable to find program interpreter name\n"));
4009 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4011 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4012 error (_("Internal error: failed to create format string to display program interpreter\n"));
4014 program_interpreter
[0] = 0;
4015 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4016 error (_("Unable to read program interpreter name\n"));
4019 printf (_("\n [Requesting program interpreter: %s]"),
4020 program_interpreter
);
4026 putc ('\n', stdout
);
4029 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4031 printf (_("\n Section to Segment mapping:\n"));
4032 printf (_(" Segment Sections...\n"));
4034 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4037 Elf_Internal_Shdr
* section
;
4039 segment
= program_headers
+ i
;
4040 section
= section_headers
+ 1;
4042 printf (" %2.2d ", i
);
4044 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4046 if (!ELF_TBSS_SPECIAL (section
, segment
)
4047 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4048 printf ("%s ", SECTION_NAME (section
));
4059 /* Find the file offset corresponding to VMA by using the program headers. */
4062 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4064 Elf_Internal_Phdr
* seg
;
4066 if (! get_program_headers (file
))
4068 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4072 for (seg
= program_headers
;
4073 seg
< program_headers
+ elf_header
.e_phnum
;
4076 if (seg
->p_type
!= PT_LOAD
)
4079 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4080 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4081 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4084 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4085 (unsigned long) vma
);
4091 get_32bit_section_headers (FILE * file
, unsigned int num
)
4093 Elf32_External_Shdr
* shdrs
;
4094 Elf_Internal_Shdr
* internal
;
4097 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4098 elf_header
.e_shentsize
, num
,
4099 _("section headers"));
4103 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4104 sizeof (Elf_Internal_Shdr
));
4106 if (section_headers
== NULL
)
4108 error (_("Out of memory\n"));
4112 for (i
= 0, internal
= section_headers
;
4116 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4117 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4118 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4119 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4120 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4121 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4122 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4123 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4124 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4125 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4134 get_64bit_section_headers (FILE * file
, unsigned int num
)
4136 Elf64_External_Shdr
* shdrs
;
4137 Elf_Internal_Shdr
* internal
;
4140 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4141 elf_header
.e_shentsize
, num
,
4142 _("section headers"));
4146 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4147 sizeof (Elf_Internal_Shdr
));
4149 if (section_headers
== NULL
)
4151 error (_("Out of memory\n"));
4155 for (i
= 0, internal
= section_headers
;
4159 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4160 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4161 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4162 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4163 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4164 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4165 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4166 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4167 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4168 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4176 static Elf_Internal_Sym
*
4177 get_32bit_elf_symbols (FILE * file
,
4178 Elf_Internal_Shdr
* section
,
4179 unsigned long * num_syms_return
)
4181 unsigned long number
= 0;
4182 Elf32_External_Sym
* esyms
= NULL
;
4183 Elf_External_Sym_Shndx
* shndx
= NULL
;
4184 Elf_Internal_Sym
* isyms
= NULL
;
4185 Elf_Internal_Sym
* psym
;
4188 /* Run some sanity checks first. */
4189 if (section
->sh_entsize
== 0)
4191 error (_("sh_entsize is zero\n"));
4195 number
= section
->sh_size
/ section
->sh_entsize
;
4197 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4199 error (_("Invalid sh_entsize\n"));
4203 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4204 section
->sh_size
, _("symbols"));
4209 if (symtab_shndx_hdr
!= NULL
4210 && (symtab_shndx_hdr
->sh_link
4211 == (unsigned long) (section
- section_headers
)))
4213 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4214 symtab_shndx_hdr
->sh_offset
,
4215 1, symtab_shndx_hdr
->sh_size
,
4216 _("symbol table section indicies"));
4221 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4225 error (_("Out of memory\n"));
4229 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4231 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4232 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4233 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4234 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4235 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4237 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4238 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4239 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4240 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4241 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4250 if (num_syms_return
!= NULL
)
4251 * num_syms_return
= isyms
== NULL
? 0 : number
;
4256 static Elf_Internal_Sym
*
4257 get_64bit_elf_symbols (FILE * file
,
4258 Elf_Internal_Shdr
* section
,
4259 unsigned long * num_syms_return
)
4261 unsigned long number
= 0;
4262 Elf64_External_Sym
* esyms
= NULL
;
4263 Elf_External_Sym_Shndx
* shndx
= NULL
;
4264 Elf_Internal_Sym
* isyms
= NULL
;
4265 Elf_Internal_Sym
* psym
;
4268 /* Run some sanity checks first. */
4269 if (section
->sh_entsize
== 0)
4271 error (_("sh_entsize is zero\n"));
4275 number
= section
->sh_size
/ section
->sh_entsize
;
4277 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4279 error (_("Invalid sh_entsize\n"));
4283 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4284 section
->sh_size
, _("symbols"));
4288 if (symtab_shndx_hdr
!= NULL
4289 && (symtab_shndx_hdr
->sh_link
4290 == (unsigned long) (section
- section_headers
)))
4292 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4293 symtab_shndx_hdr
->sh_offset
,
4294 1, symtab_shndx_hdr
->sh_size
,
4295 _("symbol table section indicies"));
4300 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4304 error (_("Out of memory\n"));
4308 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4310 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4311 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4312 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4313 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4315 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4317 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4318 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4319 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4321 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4322 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4331 if (num_syms_return
!= NULL
)
4332 * num_syms_return
= isyms
== NULL
? 0 : number
;
4338 get_elf_section_flags (bfd_vma sh_flags
)
4340 static char buff
[1024];
4342 int field_size
= is_32bit_elf
? 8 : 16;
4344 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4345 bfd_vma os_flags
= 0;
4346 bfd_vma proc_flags
= 0;
4347 bfd_vma unknown_flags
= 0;
4355 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4356 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4357 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4358 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4359 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4360 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4361 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4362 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4363 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4364 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4365 /* IA-64 specific. */
4366 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4367 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4368 /* IA-64 OpenVMS specific. */
4369 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4370 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4371 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4372 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4373 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4374 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4376 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4377 /* SPARC specific. */
4378 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4381 if (do_section_details
)
4383 sprintf (buff
, "[%*.*lx]: ",
4384 field_size
, field_size
, (unsigned long) sh_flags
);
4385 p
+= field_size
+ 4;
4392 flag
= sh_flags
& - sh_flags
;
4395 if (do_section_details
)
4399 case SHF_WRITE
: sindex
= 0; break;
4400 case SHF_ALLOC
: sindex
= 1; break;
4401 case SHF_EXECINSTR
: sindex
= 2; break;
4402 case SHF_MERGE
: sindex
= 3; break;
4403 case SHF_STRINGS
: sindex
= 4; break;
4404 case SHF_INFO_LINK
: sindex
= 5; break;
4405 case SHF_LINK_ORDER
: sindex
= 6; break;
4406 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4407 case SHF_GROUP
: sindex
= 8; break;
4408 case SHF_TLS
: sindex
= 9; break;
4409 case SHF_EXCLUDE
: sindex
= 18; break;
4413 switch (elf_header
.e_machine
)
4416 if (flag
== SHF_IA_64_SHORT
)
4418 else if (flag
== SHF_IA_64_NORECOV
)
4421 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4424 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4425 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4426 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4427 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4428 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4429 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4440 case EM_OLD_SPARCV9
:
4441 case EM_SPARC32PLUS
:
4444 if (flag
== SHF_ORDERED
)
4454 if (p
!= buff
+ field_size
+ 4)
4456 if (size
< (10 + 2))
4463 size
-= flags
[sindex
].len
;
4464 p
= stpcpy (p
, flags
[sindex
].str
);
4466 else if (flag
& SHF_MASKOS
)
4468 else if (flag
& SHF_MASKPROC
)
4471 unknown_flags
|= flag
;
4477 case SHF_WRITE
: *p
= 'W'; break;
4478 case SHF_ALLOC
: *p
= 'A'; break;
4479 case SHF_EXECINSTR
: *p
= 'X'; break;
4480 case SHF_MERGE
: *p
= 'M'; break;
4481 case SHF_STRINGS
: *p
= 'S'; break;
4482 case SHF_INFO_LINK
: *p
= 'I'; break;
4483 case SHF_LINK_ORDER
: *p
= 'L'; break;
4484 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4485 case SHF_GROUP
: *p
= 'G'; break;
4486 case SHF_TLS
: *p
= 'T'; break;
4487 case SHF_EXCLUDE
: *p
= 'E'; break;
4490 if ((elf_header
.e_machine
== EM_X86_64
4491 || elf_header
.e_machine
== EM_L1OM
4492 || elf_header
.e_machine
== EM_K1OM
)
4493 && flag
== SHF_X86_64_LARGE
)
4495 else if (flag
& SHF_MASKOS
)
4498 sh_flags
&= ~ SHF_MASKOS
;
4500 else if (flag
& SHF_MASKPROC
)
4503 sh_flags
&= ~ SHF_MASKPROC
;
4513 if (do_section_details
)
4517 size
-= 5 + field_size
;
4518 if (p
!= buff
+ field_size
+ 4)
4526 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4527 (unsigned long) os_flags
);
4528 p
+= 5 + field_size
;
4532 size
-= 7 + field_size
;
4533 if (p
!= buff
+ field_size
+ 4)
4541 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4542 (unsigned long) proc_flags
);
4543 p
+= 7 + field_size
;
4547 size
-= 10 + field_size
;
4548 if (p
!= buff
+ field_size
+ 4)
4556 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4557 (unsigned long) unknown_flags
);
4558 p
+= 10 + field_size
;
4567 process_section_headers (FILE * file
)
4569 Elf_Internal_Shdr
* section
;
4572 section_headers
= NULL
;
4574 if (elf_header
.e_shnum
== 0)
4576 /* PR binutils/12467. */
4577 if (elf_header
.e_shoff
!= 0)
4578 warn (_("possibly corrupt ELF file header - it has a non-zero"
4579 " section header offset, but no section headers\n"));
4580 else if (do_sections
)
4581 printf (_("\nThere are no sections in this file.\n"));
4586 if (do_sections
&& !do_header
)
4587 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4588 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4592 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4595 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4598 /* Read in the string table, so that we have names to display. */
4599 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4600 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4602 section
= section_headers
+ elf_header
.e_shstrndx
;
4604 if (section
->sh_size
!= 0)
4606 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4607 1, section
->sh_size
,
4610 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4614 /* Scan the sections for the dynamic symbol table
4615 and dynamic string table and debug sections. */
4616 dynamic_symbols
= NULL
;
4617 dynamic_strings
= NULL
;
4618 dynamic_syminfo
= NULL
;
4619 symtab_shndx_hdr
= NULL
;
4621 eh_addr_size
= is_32bit_elf
? 4 : 8;
4622 switch (elf_header
.e_machine
)
4625 case EM_MIPS_RS3_LE
:
4626 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4627 FDE addresses. However, the ABI also has a semi-official ILP32
4628 variant for which the normal FDE address size rules apply.
4630 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4631 section, where XX is the size of longs in bits. Unfortunately,
4632 earlier compilers provided no way of distinguishing ILP32 objects
4633 from LP64 objects, so if there's any doubt, we should assume that
4634 the official LP64 form is being used. */
4635 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4636 && find_section (".gcc_compiled_long32") == NULL
)
4642 switch (elf_header
.e_flags
& EF_H8_MACH
)
4644 case E_H8_MACH_H8300
:
4645 case E_H8_MACH_H8300HN
:
4646 case E_H8_MACH_H8300SN
:
4647 case E_H8_MACH_H8300SXN
:
4650 case E_H8_MACH_H8300H
:
4651 case E_H8_MACH_H8300S
:
4652 case E_H8_MACH_H8300SX
:
4660 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4662 case EF_M32C_CPU_M16C
:
4669 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4672 size_t expected_entsize \
4673 = is_32bit_elf ? size32 : size64; \
4674 if (section->sh_entsize != expected_entsize) \
4675 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4676 i, (unsigned long int) section->sh_entsize, \
4677 (unsigned long int) expected_entsize); \
4678 section->sh_entsize = expected_entsize; \
4681 #define CHECK_ENTSIZE(section, i, type) \
4682 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4683 sizeof (Elf64_External_##type))
4685 for (i
= 0, section
= section_headers
;
4686 i
< elf_header
.e_shnum
;
4689 char * name
= SECTION_NAME (section
);
4691 if (section
->sh_type
== SHT_DYNSYM
)
4693 if (dynamic_symbols
!= NULL
)
4695 error (_("File contains multiple dynamic symbol tables\n"));
4699 CHECK_ENTSIZE (section
, i
, Sym
);
4700 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4702 else if (section
->sh_type
== SHT_STRTAB
4703 && streq (name
, ".dynstr"))
4705 if (dynamic_strings
!= NULL
)
4707 error (_("File contains multiple dynamic string tables\n"));
4711 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4712 1, section
->sh_size
,
4713 _("dynamic strings"));
4714 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4716 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4718 if (symtab_shndx_hdr
!= NULL
)
4720 error (_("File contains multiple symtab shndx tables\n"));
4723 symtab_shndx_hdr
= section
;
4725 else if (section
->sh_type
== SHT_SYMTAB
)
4726 CHECK_ENTSIZE (section
, i
, Sym
);
4727 else if (section
->sh_type
== SHT_GROUP
)
4728 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4729 else if (section
->sh_type
== SHT_REL
)
4730 CHECK_ENTSIZE (section
, i
, Rel
);
4731 else if (section
->sh_type
== SHT_RELA
)
4732 CHECK_ENTSIZE (section
, i
, Rela
);
4733 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4734 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4735 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4736 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4737 || do_debug_addr
|| do_debug_cu_index
)
4738 && (const_strneq (name
, ".debug_")
4739 || const_strneq (name
, ".zdebug_")))
4742 name
+= sizeof (".zdebug_") - 1;
4744 name
+= sizeof (".debug_") - 1;
4747 || (do_debug_info
&& const_strneq (name
, "info"))
4748 || (do_debug_info
&& const_strneq (name
, "types"))
4749 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4750 || (do_debug_lines
&& const_strneq (name
, "line"))
4751 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4752 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4753 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4754 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4755 || (do_debug_frames
&& const_strneq (name
, "frame"))
4756 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4757 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4758 || (do_debug_str
&& const_strneq (name
, "str"))
4759 || (do_debug_loc
&& const_strneq (name
, "loc"))
4760 || (do_debug_addr
&& const_strneq (name
, "addr"))
4761 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4762 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4764 request_dump_bynumber (i
, DEBUG_DUMP
);
4766 /* Linkonce section to be combined with .debug_info at link time. */
4767 else if ((do_debugging
|| do_debug_info
)
4768 && const_strneq (name
, ".gnu.linkonce.wi."))
4769 request_dump_bynumber (i
, DEBUG_DUMP
);
4770 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4771 request_dump_bynumber (i
, DEBUG_DUMP
);
4772 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4773 request_dump_bynumber (i
, DEBUG_DUMP
);
4774 /* Trace sections for Itanium VMS. */
4775 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4776 || do_trace_aranges
)
4777 && const_strneq (name
, ".trace_"))
4779 name
+= sizeof (".trace_") - 1;
4782 || (do_trace_info
&& streq (name
, "info"))
4783 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4784 || (do_trace_aranges
&& streq (name
, "aranges"))
4786 request_dump_bynumber (i
, DEBUG_DUMP
);
4794 if (elf_header
.e_shnum
> 1)
4795 printf (_("\nSection Headers:\n"));
4797 printf (_("\nSection Header:\n"));
4801 if (do_section_details
)
4803 printf (_(" [Nr] Name\n"));
4804 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4808 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4812 if (do_section_details
)
4814 printf (_(" [Nr] Name\n"));
4815 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4819 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4823 if (do_section_details
)
4825 printf (_(" [Nr] Name\n"));
4826 printf (_(" Type Address Offset Link\n"));
4827 printf (_(" Size EntSize Info Align\n"));
4831 printf (_(" [Nr] Name Type Address Offset\n"));
4832 printf (_(" Size EntSize Flags Link Info Align\n"));
4836 if (do_section_details
)
4837 printf (_(" Flags\n"));
4839 for (i
= 0, section
= section_headers
;
4840 i
< elf_header
.e_shnum
;
4843 printf (" [%2u] ", i
);
4844 if (do_section_details
)
4846 print_symbol (INT_MAX
, SECTION_NAME (section
));
4851 print_symbol (-17, SECTION_NAME (section
));
4854 printf (do_wide
? " %-15s " : " %-15.15s ",
4855 get_section_type_name (section
->sh_type
));
4859 const char * link_too_big
= NULL
;
4861 print_vma (section
->sh_addr
, LONG_HEX
);
4863 printf ( " %6.6lx %6.6lx %2.2lx",
4864 (unsigned long) section
->sh_offset
,
4865 (unsigned long) section
->sh_size
,
4866 (unsigned long) section
->sh_entsize
);
4868 if (do_section_details
)
4869 fputs (" ", stdout
);
4871 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4873 if (section
->sh_link
>= elf_header
.e_shnum
)
4876 /* The sh_link value is out of range. Normally this indicates
4877 an error but it can have special values in Solaris binaries. */
4878 switch (elf_header
.e_machine
)
4885 case EM_OLD_SPARCV9
:
4886 case EM_SPARC32PLUS
:
4889 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4890 link_too_big
= "BEFORE";
4891 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4892 link_too_big
= "AFTER";
4899 if (do_section_details
)
4901 if (link_too_big
!= NULL
&& * link_too_big
)
4902 printf ("<%s> ", link_too_big
);
4904 printf ("%2u ", section
->sh_link
);
4905 printf ("%3u %2lu\n", section
->sh_info
,
4906 (unsigned long) section
->sh_addralign
);
4909 printf ("%2u %3u %2lu\n",
4912 (unsigned long) section
->sh_addralign
);
4914 if (link_too_big
&& ! * link_too_big
)
4915 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4916 i
, section
->sh_link
);
4920 print_vma (section
->sh_addr
, LONG_HEX
);
4922 if ((long) section
->sh_offset
== section
->sh_offset
)
4923 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4927 print_vma (section
->sh_offset
, LONG_HEX
);
4930 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4931 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4935 print_vma (section
->sh_size
, LONG_HEX
);
4938 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4939 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4943 print_vma (section
->sh_entsize
, LONG_HEX
);
4946 if (do_section_details
)
4947 fputs (" ", stdout
);
4949 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4951 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4953 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4954 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4957 print_vma (section
->sh_addralign
, DEC
);
4961 else if (do_section_details
)
4963 printf (" %-15.15s ",
4964 get_section_type_name (section
->sh_type
));
4965 print_vma (section
->sh_addr
, LONG_HEX
);
4966 if ((long) section
->sh_offset
== section
->sh_offset
)
4967 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4971 print_vma (section
->sh_offset
, LONG_HEX
);
4973 printf (" %u\n ", section
->sh_link
);
4974 print_vma (section
->sh_size
, LONG_HEX
);
4976 print_vma (section
->sh_entsize
, LONG_HEX
);
4978 printf (" %-16u %lu\n",
4980 (unsigned long) section
->sh_addralign
);
4985 print_vma (section
->sh_addr
, LONG_HEX
);
4986 if ((long) section
->sh_offset
== section
->sh_offset
)
4987 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4991 print_vma (section
->sh_offset
, LONG_HEX
);
4994 print_vma (section
->sh_size
, LONG_HEX
);
4996 print_vma (section
->sh_entsize
, LONG_HEX
);
4998 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5000 printf (" %2u %3u %lu\n",
5003 (unsigned long) section
->sh_addralign
);
5006 if (do_section_details
)
5007 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5010 if (!do_section_details
)
5012 if (elf_header
.e_machine
== EM_X86_64
5013 || elf_header
.e_machine
== EM_L1OM
5014 || elf_header
.e_machine
== EM_K1OM
)
5015 printf (_("Key to Flags:\n\
5016 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5017 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5018 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5020 printf (_("Key to Flags:\n\
5021 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5022 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5023 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5030 get_group_flags (unsigned int flags
)
5032 static char buff
[32];
5042 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5049 process_section_groups (FILE * file
)
5051 Elf_Internal_Shdr
* section
;
5053 struct group
* group
;
5054 Elf_Internal_Shdr
* symtab_sec
;
5055 Elf_Internal_Shdr
* strtab_sec
;
5056 Elf_Internal_Sym
* symtab
;
5057 unsigned long num_syms
;
5061 /* Don't process section groups unless needed. */
5062 if (!do_unwind
&& !do_section_groups
)
5065 if (elf_header
.e_shnum
== 0)
5067 if (do_section_groups
)
5068 printf (_("\nThere are no sections to group in this file.\n"));
5073 if (section_headers
== NULL
)
5075 error (_("Section headers are not available!\n"));
5076 /* PR 13622: This can happen with a corrupt ELF header. */
5080 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5081 sizeof (struct group
*));
5083 if (section_headers_groups
== NULL
)
5085 error (_("Out of memory\n"));
5089 /* Scan the sections for the group section. */
5091 for (i
= 0, section
= section_headers
;
5092 i
< elf_header
.e_shnum
;
5094 if (section
->sh_type
== SHT_GROUP
)
5097 if (group_count
== 0)
5099 if (do_section_groups
)
5100 printf (_("\nThere are no section groups in this file.\n"));
5105 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5107 if (section_groups
== NULL
)
5109 error (_("Out of memory\n"));
5119 for (i
= 0, section
= section_headers
, group
= section_groups
;
5120 i
< elf_header
.e_shnum
;
5123 if (section
->sh_type
== SHT_GROUP
)
5125 char * name
= SECTION_NAME (section
);
5127 unsigned char * start
;
5128 unsigned char * indices
;
5129 unsigned int entry
, j
, size
;
5130 Elf_Internal_Shdr
* sec
;
5131 Elf_Internal_Sym
* sym
;
5133 /* Get the symbol table. */
5134 if (section
->sh_link
>= elf_header
.e_shnum
5135 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5138 error (_("Bad sh_link in group section `%s'\n"), name
);
5142 if (symtab_sec
!= sec
)
5147 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5152 error (_("Corrupt header in group section `%s'\n"), name
);
5156 if (section
->sh_info
>= num_syms
)
5158 error (_("Bad sh_info in group section `%s'\n"), name
);
5162 sym
= symtab
+ section
->sh_info
;
5164 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5166 if (sym
->st_shndx
== 0
5167 || sym
->st_shndx
>= elf_header
.e_shnum
)
5169 error (_("Bad sh_info in group section `%s'\n"), name
);
5173 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5182 /* Get the string table. */
5183 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5192 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5197 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5198 1, strtab_sec
->sh_size
,
5200 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5202 group_name
= sym
->st_name
< strtab_size
5203 ? strtab
+ sym
->st_name
: _("<corrupt>");
5206 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5207 1, section
->sh_size
,
5213 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5214 entry
= byte_get (indices
, 4);
5217 if (do_section_groups
)
5219 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5220 get_group_flags (entry
), i
, name
, group_name
, size
);
5222 printf (_(" [Index] Name\n"));
5225 group
->group_index
= i
;
5227 for (j
= 0; j
< size
; j
++)
5229 struct group_list
* g
;
5231 entry
= byte_get (indices
, 4);
5234 if (entry
>= elf_header
.e_shnum
)
5236 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5237 entry
, i
, elf_header
.e_shnum
- 1);
5241 if (section_headers_groups
[entry
] != NULL
)
5245 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5247 section_headers_groups
[entry
]->group_index
);
5252 /* Intel C/C++ compiler may put section 0 in a
5253 section group. We just warn it the first time
5254 and ignore it afterwards. */
5255 static int warned
= 0;
5258 error (_("section 0 in group section [%5u]\n"),
5259 section_headers_groups
[entry
]->group_index
);
5265 section_headers_groups
[entry
] = group
;
5267 if (do_section_groups
)
5269 sec
= section_headers
+ entry
;
5270 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5273 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5274 g
->section_index
= entry
;
5275 g
->next
= group
->root
;
5293 /* Data used to display dynamic fixups. */
5295 struct ia64_vms_dynfixup
5297 bfd_vma needed_ident
; /* Library ident number. */
5298 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5299 bfd_vma fixup_needed
; /* Index of the library. */
5300 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5301 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5304 /* Data used to display dynamic relocations. */
5306 struct ia64_vms_dynimgrela
5308 bfd_vma img_rela_cnt
; /* Number of relocations. */
5309 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5312 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5316 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5317 const char *strtab
, unsigned int strtab_sz
)
5319 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5321 const char *lib_name
;
5323 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5324 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5325 _("dynamic section image fixups"));
5329 if (fixup
->needed
< strtab_sz
)
5330 lib_name
= strtab
+ fixup
->needed
;
5333 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5334 (unsigned long) fixup
->needed
);
5337 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5338 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5340 (_("Seg Offset Type SymVec DataType\n"));
5342 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5347 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5348 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5349 type
= BYTE_GET (imfs
[i
].type
);
5350 rtype
= elf_ia64_reloc_type (type
);
5352 printf (" 0x%08x ", type
);
5354 printf (" %-32s ", rtype
);
5355 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5356 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5362 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5365 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5367 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5370 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5371 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5372 _("dynamic section image relocations"));
5376 printf (_("\nImage relocs\n"));
5378 (_("Seg Offset Type Addend Seg Sym Off\n"));
5380 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5385 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5386 printf ("%08" BFD_VMA_FMT
"x ",
5387 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5388 type
= BYTE_GET (imrs
[i
].type
);
5389 rtype
= elf_ia64_reloc_type (type
);
5391 printf ("0x%08x ", type
);
5393 printf ("%-31s ", rtype
);
5394 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5395 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5396 printf ("%08" BFD_VMA_FMT
"x\n",
5397 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5403 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5406 process_ia64_vms_dynamic_relocs (FILE *file
)
5408 struct ia64_vms_dynfixup fixup
;
5409 struct ia64_vms_dynimgrela imgrela
;
5410 Elf_Internal_Dyn
*entry
;
5412 bfd_vma strtab_off
= 0;
5413 bfd_vma strtab_sz
= 0;
5414 char *strtab
= NULL
;
5416 memset (&fixup
, 0, sizeof (fixup
));
5417 memset (&imgrela
, 0, sizeof (imgrela
));
5419 /* Note: the order of the entries is specified by the OpenVMS specs. */
5420 for (entry
= dynamic_section
;
5421 entry
< dynamic_section
+ dynamic_nent
;
5424 switch (entry
->d_tag
)
5426 case DT_IA_64_VMS_STRTAB_OFFSET
:
5427 strtab_off
= entry
->d_un
.d_val
;
5430 strtab_sz
= entry
->d_un
.d_val
;
5432 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5433 1, strtab_sz
, _("dynamic string section"));
5436 case DT_IA_64_VMS_NEEDED_IDENT
:
5437 fixup
.needed_ident
= entry
->d_un
.d_val
;
5440 fixup
.needed
= entry
->d_un
.d_val
;
5442 case DT_IA_64_VMS_FIXUP_NEEDED
:
5443 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5445 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5446 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5448 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5449 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5451 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5454 case DT_IA_64_VMS_IMG_RELA_CNT
:
5455 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5457 case DT_IA_64_VMS_IMG_RELA_OFF
:
5458 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5460 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5480 } dynamic_relocations
[] =
5482 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5483 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5484 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5487 /* Process the reloc section. */
5490 process_relocs (FILE * file
)
5492 unsigned long rel_size
;
5493 unsigned long rel_offset
;
5499 if (do_using_dynamic
)
5503 int has_dynamic_reloc
;
5506 has_dynamic_reloc
= 0;
5508 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5510 is_rela
= dynamic_relocations
[i
].rela
;
5511 name
= dynamic_relocations
[i
].name
;
5512 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5513 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5515 has_dynamic_reloc
|= rel_size
;
5517 if (is_rela
== UNKNOWN
)
5519 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5520 switch (dynamic_info
[DT_PLTREL
])
5534 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5535 name
, rel_offset
, rel_size
);
5537 dump_relocations (file
,
5538 offset_from_vma (file
, rel_offset
, rel_size
),
5540 dynamic_symbols
, num_dynamic_syms
,
5541 dynamic_strings
, dynamic_strings_length
, is_rela
);
5546 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5548 if (! has_dynamic_reloc
)
5549 printf (_("\nThere are no dynamic relocations in this file.\n"));
5553 Elf_Internal_Shdr
* section
;
5557 for (i
= 0, section
= section_headers
;
5558 i
< elf_header
.e_shnum
;
5561 if ( section
->sh_type
!= SHT_RELA
5562 && section
->sh_type
!= SHT_REL
)
5565 rel_offset
= section
->sh_offset
;
5566 rel_size
= section
->sh_size
;
5570 Elf_Internal_Shdr
* strsec
;
5573 printf (_("\nRelocation section "));
5575 if (string_table
== NULL
)
5576 printf ("%d", section
->sh_name
);
5578 printf ("'%s'", SECTION_NAME (section
));
5580 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5581 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5583 is_rela
= section
->sh_type
== SHT_RELA
;
5585 if (section
->sh_link
!= 0
5586 && section
->sh_link
< elf_header
.e_shnum
)
5588 Elf_Internal_Shdr
* symsec
;
5589 Elf_Internal_Sym
* symtab
;
5590 unsigned long nsyms
;
5591 unsigned long strtablen
= 0;
5592 char * strtab
= NULL
;
5594 symsec
= section_headers
+ section
->sh_link
;
5595 if (symsec
->sh_type
!= SHT_SYMTAB
5596 && symsec
->sh_type
!= SHT_DYNSYM
)
5599 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5604 if (symsec
->sh_link
!= 0
5605 && symsec
->sh_link
< elf_header
.e_shnum
)
5607 strsec
= section_headers
+ symsec
->sh_link
;
5609 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5612 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5615 dump_relocations (file
, rel_offset
, rel_size
,
5616 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5622 dump_relocations (file
, rel_offset
, rel_size
,
5623 NULL
, 0, NULL
, 0, is_rela
);
5630 printf (_("\nThere are no relocations in this file.\n"));
5636 /* Process the unwind section. */
5638 #include "unwind-ia64.h"
5640 /* An absolute address consists of a section and an offset. If the
5641 section is NULL, the offset itself is the address, otherwise, the
5642 address equals to LOAD_ADDRESS(section) + offset. */
5646 unsigned short section
;
5650 #define ABSADDR(a) \
5652 ? section_headers [(a).section].sh_addr + (a).offset \
5655 struct ia64_unw_table_entry
5657 struct absaddr start
;
5659 struct absaddr info
;
5662 struct ia64_unw_aux_info
5665 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5666 unsigned long table_len
; /* Length of unwind table. */
5667 unsigned char * info
; /* Unwind info. */
5668 unsigned long info_size
; /* Size of unwind info. */
5669 bfd_vma info_addr
; /* starting address of unwind info. */
5670 bfd_vma seg_base
; /* Starting address of segment. */
5671 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5672 unsigned long nsyms
; /* Number of symbols. */
5673 char * strtab
; /* The string table. */
5674 unsigned long strtab_size
; /* Size of string table. */
5678 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5679 unsigned long nsyms
,
5680 const char * strtab
,
5681 unsigned long strtab_size
,
5682 struct absaddr addr
,
5683 const char ** symname
,
5686 bfd_vma dist
= 0x100000;
5687 Elf_Internal_Sym
* sym
;
5688 Elf_Internal_Sym
* best
= NULL
;
5691 REMOVE_ARCH_BITS (addr
.offset
);
5693 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5695 bfd_vma value
= sym
->st_value
;
5697 REMOVE_ARCH_BITS (value
);
5699 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5700 && sym
->st_name
!= 0
5701 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5702 && addr
.offset
>= value
5703 && addr
.offset
- value
< dist
)
5706 dist
= addr
.offset
- value
;
5714 *symname
= (best
->st_name
>= strtab_size
5715 ? _("<corrupt>") : strtab
+ best
->st_name
);
5721 *offset
= addr
.offset
;
5725 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5727 struct ia64_unw_table_entry
* tp
;
5730 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5734 const unsigned char * dp
;
5735 const unsigned char * head
;
5736 const char * procname
;
5738 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5739 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5741 fputs ("\n<", stdout
);
5745 fputs (procname
, stdout
);
5748 printf ("+%lx", (unsigned long) offset
);
5751 fputs (">: [", stdout
);
5752 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5753 fputc ('-', stdout
);
5754 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5755 printf ("], info at +0x%lx\n",
5756 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5758 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5759 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5761 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5762 (unsigned) UNW_VER (stamp
),
5763 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5764 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5765 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5766 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5768 if (UNW_VER (stamp
) != 1)
5770 printf (_("\tUnknown version.\n"));
5775 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5776 dp
= unw_decode (dp
, in_body
, & in_body
);
5781 slurp_ia64_unwind_table (FILE * file
,
5782 struct ia64_unw_aux_info
* aux
,
5783 Elf_Internal_Shdr
* sec
)
5785 unsigned long size
, nrelas
, i
;
5786 Elf_Internal_Phdr
* seg
;
5787 struct ia64_unw_table_entry
* tep
;
5788 Elf_Internal_Shdr
* relsec
;
5789 Elf_Internal_Rela
* rela
;
5790 Elf_Internal_Rela
* rp
;
5791 unsigned char * table
;
5793 Elf_Internal_Sym
* sym
;
5794 const char * relname
;
5796 /* First, find the starting address of the segment that includes
5799 if (elf_header
.e_phnum
)
5801 if (! get_program_headers (file
))
5804 for (seg
= program_headers
;
5805 seg
< program_headers
+ elf_header
.e_phnum
;
5808 if (seg
->p_type
!= PT_LOAD
)
5811 if (sec
->sh_addr
>= seg
->p_vaddr
5812 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5814 aux
->seg_base
= seg
->p_vaddr
;
5820 /* Second, build the unwind table from the contents of the unwind section: */
5821 size
= sec
->sh_size
;
5822 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5827 aux
->table
= (struct ia64_unw_table_entry
*)
5828 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5830 for (tp
= table
; tp
< table
+ size
; ++tep
)
5832 tep
->start
.section
= SHN_UNDEF
;
5833 tep
->end
.section
= SHN_UNDEF
;
5834 tep
->info
.section
= SHN_UNDEF
;
5835 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5836 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5837 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5838 tep
->start
.offset
+= aux
->seg_base
;
5839 tep
->end
.offset
+= aux
->seg_base
;
5840 tep
->info
.offset
+= aux
->seg_base
;
5844 /* Third, apply any relocations to the unwind table: */
5845 for (relsec
= section_headers
;
5846 relsec
< section_headers
+ elf_header
.e_shnum
;
5849 if (relsec
->sh_type
!= SHT_RELA
5850 || relsec
->sh_info
>= elf_header
.e_shnum
5851 || section_headers
+ relsec
->sh_info
!= sec
)
5854 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5858 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5860 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5861 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5863 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5865 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5869 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5871 switch (rp
->r_offset
/eh_addr_size
% 3)
5874 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5875 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5878 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5879 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5882 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5883 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5893 aux
->table_len
= size
/ (3 * eh_addr_size
);
5898 ia64_process_unwind (FILE * file
)
5900 Elf_Internal_Shdr
* sec
;
5901 Elf_Internal_Shdr
* unwsec
= NULL
;
5902 Elf_Internal_Shdr
* strsec
;
5903 unsigned long i
, unwcount
= 0, unwstart
= 0;
5904 struct ia64_unw_aux_info aux
;
5906 memset (& aux
, 0, sizeof (aux
));
5908 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5910 if (sec
->sh_type
== SHT_SYMTAB
5911 && sec
->sh_link
< elf_header
.e_shnum
)
5913 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
5915 strsec
= section_headers
+ sec
->sh_link
;
5916 assert (aux
.strtab
== NULL
);
5917 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5920 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5922 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5927 printf (_("\nThere are no unwind sections in this file.\n"));
5929 while (unwcount
-- > 0)
5934 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5935 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5936 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5943 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5945 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5947 /* We need to find which section group it is in. */
5948 struct group_list
* g
= section_headers_groups
[i
]->root
;
5950 for (; g
!= NULL
; g
= g
->next
)
5952 sec
= section_headers
+ g
->section_index
;
5954 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5959 i
= elf_header
.e_shnum
;
5961 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5963 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5964 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5965 suffix
= SECTION_NAME (unwsec
) + len
;
5966 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5968 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5969 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5974 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5975 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5976 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5977 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5979 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5980 suffix
= SECTION_NAME (unwsec
) + len
;
5981 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5983 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5984 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5988 if (i
== elf_header
.e_shnum
)
5990 printf (_("\nCould not find unwind info section for "));
5992 if (string_table
== NULL
)
5993 printf ("%d", unwsec
->sh_name
);
5995 printf (_("'%s'"), SECTION_NAME (unwsec
));
5999 aux
.info_addr
= sec
->sh_addr
;
6000 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6003 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6005 printf (_("\nUnwind section "));
6007 if (string_table
== NULL
)
6008 printf ("%d", unwsec
->sh_name
);
6010 printf (_("'%s'"), SECTION_NAME (unwsec
));
6012 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6013 (unsigned long) unwsec
->sh_offset
,
6014 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6016 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6018 if (aux
.table_len
> 0)
6019 dump_ia64_unwind (& aux
);
6022 free ((char *) aux
.table
);
6024 free ((char *) aux
.info
);
6033 free ((char *) aux
.strtab
);
6036 struct hppa_unw_table_entry
6038 struct absaddr start
;
6040 unsigned int Cannot_unwind
:1; /* 0 */
6041 unsigned int Millicode
:1; /* 1 */
6042 unsigned int Millicode_save_sr0
:1; /* 2 */
6043 unsigned int Region_description
:2; /* 3..4 */
6044 unsigned int reserved1
:1; /* 5 */
6045 unsigned int Entry_SR
:1; /* 6 */
6046 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6047 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6048 unsigned int Args_stored
:1; /* 16 */
6049 unsigned int Variable_Frame
:1; /* 17 */
6050 unsigned int Separate_Package_Body
:1; /* 18 */
6051 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6052 unsigned int Stack_Overflow_Check
:1; /* 20 */
6053 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6054 unsigned int Ada_Region
:1; /* 22 */
6055 unsigned int cxx_info
:1; /* 23 */
6056 unsigned int cxx_try_catch
:1; /* 24 */
6057 unsigned int sched_entry_seq
:1; /* 25 */
6058 unsigned int reserved2
:1; /* 26 */
6059 unsigned int Save_SP
:1; /* 27 */
6060 unsigned int Save_RP
:1; /* 28 */
6061 unsigned int Save_MRP_in_frame
:1; /* 29 */
6062 unsigned int extn_ptr_defined
:1; /* 30 */
6063 unsigned int Cleanup_defined
:1; /* 31 */
6065 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6066 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6067 unsigned int Large_frame
:1; /* 2 */
6068 unsigned int Pseudo_SP_Set
:1; /* 3 */
6069 unsigned int reserved4
:1; /* 4 */
6070 unsigned int Total_frame_size
:27; /* 5..31 */
6073 struct hppa_unw_aux_info
6075 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6076 unsigned long table_len
; /* Length of unwind table. */
6077 bfd_vma seg_base
; /* Starting address of segment. */
6078 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6079 unsigned long nsyms
; /* Number of symbols. */
6080 char * strtab
; /* The string table. */
6081 unsigned long strtab_size
; /* Size of string table. */
6085 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6087 struct hppa_unw_table_entry
* tp
;
6089 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6092 const char * procname
;
6094 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6095 aux
->strtab_size
, tp
->start
, &procname
,
6098 fputs ("\n<", stdout
);
6102 fputs (procname
, stdout
);
6105 printf ("+%lx", (unsigned long) offset
);
6108 fputs (">: [", stdout
);
6109 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6110 fputc ('-', stdout
);
6111 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6114 #define PF(_m) if (tp->_m) printf (#_m " ");
6115 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6118 PF(Millicode_save_sr0
);
6119 /* PV(Region_description); */
6125 PF(Separate_Package_Body
);
6126 PF(Frame_Extension_Millicode
);
6127 PF(Stack_Overflow_Check
);
6128 PF(Two_Instruction_SP_Increment
);
6132 PF(sched_entry_seq
);
6135 PF(Save_MRP_in_frame
);
6136 PF(extn_ptr_defined
);
6137 PF(Cleanup_defined
);
6138 PF(MPE_XL_interrupt_marker
);
6139 PF(HP_UX_interrupt_marker
);
6142 PV(Total_frame_size
);
6151 slurp_hppa_unwind_table (FILE * file
,
6152 struct hppa_unw_aux_info
* aux
,
6153 Elf_Internal_Shdr
* sec
)
6155 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6156 Elf_Internal_Phdr
* seg
;
6157 struct hppa_unw_table_entry
* tep
;
6158 Elf_Internal_Shdr
* relsec
;
6159 Elf_Internal_Rela
* rela
;
6160 Elf_Internal_Rela
* rp
;
6161 unsigned char * table
;
6163 Elf_Internal_Sym
* sym
;
6164 const char * relname
;
6166 /* First, find the starting address of the segment that includes
6169 if (elf_header
.e_phnum
)
6171 if (! get_program_headers (file
))
6174 for (seg
= program_headers
;
6175 seg
< program_headers
+ elf_header
.e_phnum
;
6178 if (seg
->p_type
!= PT_LOAD
)
6181 if (sec
->sh_addr
>= seg
->p_vaddr
6182 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6184 aux
->seg_base
= seg
->p_vaddr
;
6190 /* Second, build the unwind table from the contents of the unwind
6192 size
= sec
->sh_size
;
6193 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6199 nentries
= size
/ unw_ent_size
;
6200 size
= unw_ent_size
* nentries
;
6202 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6203 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6205 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6207 unsigned int tmp1
, tmp2
;
6209 tep
->start
.section
= SHN_UNDEF
;
6210 tep
->end
.section
= SHN_UNDEF
;
6212 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6213 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6214 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6215 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6217 tep
->start
.offset
+= aux
->seg_base
;
6218 tep
->end
.offset
+= aux
->seg_base
;
6220 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6221 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6222 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6223 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6224 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6225 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6226 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6227 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6228 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6229 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6230 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6231 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6232 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6233 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6234 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6235 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6236 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6237 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6238 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6239 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6240 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6241 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6242 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6243 tep
->Cleanup_defined
= tmp1
& 0x1;
6245 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6246 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6247 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6248 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6249 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6250 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6254 /* Third, apply any relocations to the unwind table. */
6255 for (relsec
= section_headers
;
6256 relsec
< section_headers
+ elf_header
.e_shnum
;
6259 if (relsec
->sh_type
!= SHT_RELA
6260 || relsec
->sh_info
>= elf_header
.e_shnum
6261 || section_headers
+ relsec
->sh_info
!= sec
)
6264 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6268 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6270 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6271 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6273 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6274 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6276 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6280 i
= rp
->r_offset
/ unw_ent_size
;
6282 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6285 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6286 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6289 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6290 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6300 aux
->table_len
= nentries
;
6306 hppa_process_unwind (FILE * file
)
6308 struct hppa_unw_aux_info aux
;
6309 Elf_Internal_Shdr
* unwsec
= NULL
;
6310 Elf_Internal_Shdr
* strsec
;
6311 Elf_Internal_Shdr
* sec
;
6314 if (string_table
== NULL
)
6317 memset (& aux
, 0, sizeof (aux
));
6319 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6321 if (sec
->sh_type
== SHT_SYMTAB
6322 && sec
->sh_link
< elf_header
.e_shnum
)
6324 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6326 strsec
= section_headers
+ sec
->sh_link
;
6327 assert (aux
.strtab
== NULL
);
6328 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6331 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6333 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6338 printf (_("\nThere are no unwind sections in this file.\n"));
6340 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6342 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6344 printf (_("\nUnwind section "));
6345 printf (_("'%s'"), SECTION_NAME (sec
));
6347 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6348 (unsigned long) sec
->sh_offset
,
6349 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6351 slurp_hppa_unwind_table (file
, &aux
, sec
);
6352 if (aux
.table_len
> 0)
6353 dump_hppa_unwind (&aux
);
6356 free ((char *) aux
.table
);
6364 free ((char *) aux
.strtab
);
6369 unsigned char * data
; /* The unwind data. */
6370 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6371 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6372 unsigned long nrelas
; /* The number of relocations. */
6373 unsigned int rel_type
; /* REL or RELA ? */
6374 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6377 struct arm_unw_aux_info
6379 FILE * file
; /* The file containing the unwind sections. */
6380 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6381 unsigned long nsyms
; /* Number of symbols. */
6382 char * strtab
; /* The file's string table. */
6383 unsigned long strtab_size
; /* Size of string table. */
6387 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6388 bfd_vma fn
, struct absaddr addr
)
6390 const char *procname
;
6393 if (addr
.section
== SHN_UNDEF
)
6396 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6397 aux
->strtab_size
, addr
, &procname
,
6400 print_vma (fn
, PREFIX_HEX
);
6404 fputs (" <", stdout
);
6405 fputs (procname
, stdout
);
6408 printf ("+0x%lx", (unsigned long) sym_offset
);
6409 fputc ('>', stdout
);
6416 arm_free_section (struct arm_section
*arm_sec
)
6418 if (arm_sec
->data
!= NULL
)
6419 free (arm_sec
->data
);
6421 if (arm_sec
->rela
!= NULL
)
6422 free (arm_sec
->rela
);
6425 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6426 cached section and install SEC instead.
6427 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6428 and return its valued in * WORDP, relocating if necessary.
6429 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6430 relocation's offset in ADDR.
6431 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6432 into the string table of the symbol associated with the reloc. If no
6433 reloc was applied store -1 there.
6434 5) Return TRUE upon success, FALSE otherwise. */
6437 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6438 struct arm_section
* arm_sec
,
6439 Elf_Internal_Shdr
* sec
,
6440 bfd_vma word_offset
,
6441 unsigned int * wordp
,
6442 struct absaddr
* addr
,
6445 Elf_Internal_Rela
*rp
;
6446 Elf_Internal_Sym
*sym
;
6447 const char * relname
;
6449 bfd_boolean wrapped
;
6451 addr
->section
= SHN_UNDEF
;
6454 if (sym_name
!= NULL
)
6455 *sym_name
= (bfd_vma
) -1;
6457 /* If necessary, update the section cache. */
6458 if (sec
!= arm_sec
->sec
)
6460 Elf_Internal_Shdr
*relsec
;
6462 arm_free_section (arm_sec
);
6465 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6466 sec
->sh_size
, _("unwind data"));
6467 arm_sec
->rela
= NULL
;
6468 arm_sec
->nrelas
= 0;
6470 for (relsec
= section_headers
;
6471 relsec
< section_headers
+ elf_header
.e_shnum
;
6474 if (relsec
->sh_info
>= elf_header
.e_shnum
6475 || section_headers
+ relsec
->sh_info
!= sec
)
6478 arm_sec
->rel_type
= relsec
->sh_type
;
6479 if (relsec
->sh_type
== SHT_REL
)
6481 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6483 & arm_sec
->rela
, & arm_sec
->nrelas
))
6487 else if (relsec
->sh_type
== SHT_RELA
)
6489 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6491 & arm_sec
->rela
, & arm_sec
->nrelas
))
6496 warn (_("unexpected relocation type (%d) for section %d"),
6497 relsec
->sh_type
, relsec
->sh_info
);
6500 arm_sec
->next_rela
= arm_sec
->rela
;
6503 /* If there is no unwind data we can do nothing. */
6504 if (arm_sec
->data
== NULL
)
6507 /* Get the word at the required offset. */
6508 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6510 /* Look through the relocs to find the one that applies to the provided offset. */
6512 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6514 bfd_vma prelval
, offset
;
6516 if (rp
->r_offset
> word_offset
&& !wrapped
)
6521 if (rp
->r_offset
> word_offset
)
6524 if (rp
->r_offset
& 3)
6526 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6527 (unsigned long) rp
->r_offset
);
6531 if (rp
->r_offset
< word_offset
)
6534 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6536 if (arm_sec
->rel_type
== SHT_REL
)
6538 offset
= word
& 0x7fffffff;
6539 if (offset
& 0x40000000)
6540 offset
|= ~ (bfd_vma
) 0x7fffffff;
6542 else if (arm_sec
->rel_type
== SHT_RELA
)
6543 offset
= rp
->r_addend
;
6547 offset
+= sym
->st_value
;
6548 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6550 /* Check that we are processing the expected reloc type. */
6551 if (elf_header
.e_machine
== EM_ARM
)
6553 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6555 if (streq (relname
, "R_ARM_NONE"))
6558 if (! streq (relname
, "R_ARM_PREL31"))
6560 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6564 else if (elf_header
.e_machine
== EM_TI_C6000
)
6566 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6568 if (streq (relname
, "R_C6000_NONE"))
6571 if (! streq (relname
, "R_C6000_PREL31"))
6573 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6580 /* This function currently only supports ARM and TI unwinders. */
6583 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6584 addr
->section
= sym
->st_shndx
;
6585 addr
->offset
= offset
;
6587 * sym_name
= sym
->st_name
;
6592 arm_sec
->next_rela
= rp
;
6597 static const char *tic6x_unwind_regnames
[16] =
6599 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6600 "A14", "A13", "A12", "A11", "A10",
6601 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6605 decode_tic6x_unwind_regmask (unsigned int mask
)
6609 for (i
= 12; mask
; mask
>>= 1, i
--)
6613 fputs (tic6x_unwind_regnames
[i
], stdout
);
6615 fputs (", ", stdout
);
6621 if (remaining == 0 && more_words) \
6624 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6625 data_offset, & word, & addr, NULL)) \
6631 #define GET_OP(OP) \
6636 (OP) = word >> 24; \
6641 printf (_("[Truncated opcode]\n")); \
6644 printf ("0x%02x ", OP)
6647 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6648 unsigned int word
, unsigned int remaining
,
6649 unsigned int more_words
,
6650 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6651 struct arm_section
*data_arm_sec
)
6653 struct absaddr addr
;
6655 /* Decode the unwinding instructions. */
6658 unsigned int op
, op2
;
6667 printf (" 0x%02x ", op
);
6669 if ((op
& 0xc0) == 0x00)
6671 int offset
= ((op
& 0x3f) << 2) + 4;
6673 printf (" vsp = vsp + %d", offset
);
6675 else if ((op
& 0xc0) == 0x40)
6677 int offset
= ((op
& 0x3f) << 2) + 4;
6679 printf (" vsp = vsp - %d", offset
);
6681 else if ((op
& 0xf0) == 0x80)
6684 if (op
== 0x80 && op2
== 0)
6685 printf (_("Refuse to unwind"));
6688 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6693 for (i
= 0; i
< 12; i
++)
6694 if (mask
& (1 << i
))
6700 printf ("r%d", 4 + i
);
6705 else if ((op
& 0xf0) == 0x90)
6707 if (op
== 0x9d || op
== 0x9f)
6708 printf (_(" [Reserved]"));
6710 printf (" vsp = r%d", op
& 0x0f);
6712 else if ((op
& 0xf0) == 0xa0)
6714 int end
= 4 + (op
& 0x07);
6719 for (i
= 4; i
<= end
; i
++)
6735 else if (op
== 0xb0)
6736 printf (_(" finish"));
6737 else if (op
== 0xb1)
6740 if (op2
== 0 || (op2
& 0xf0) != 0)
6741 printf (_("[Spare]"));
6744 unsigned int mask
= op2
& 0x0f;
6749 for (i
= 0; i
< 12; i
++)
6750 if (mask
& (1 << i
))
6761 else if (op
== 0xb2)
6763 unsigned char buf
[9];
6764 unsigned int i
, len
;
6765 unsigned long offset
;
6767 for (i
= 0; i
< sizeof (buf
); i
++)
6770 if ((buf
[i
] & 0x80) == 0)
6773 assert (i
< sizeof (buf
));
6774 offset
= read_uleb128 (buf
, &len
);
6775 assert (len
== i
+ 1);
6776 offset
= offset
* 4 + 0x204;
6777 printf ("vsp = vsp + %ld", offset
);
6779 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6781 unsigned int first
, last
;
6788 printf ("pop {D%d", first
);
6790 printf ("-D%d", first
+ last
);
6793 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6795 unsigned int count
= op
& 0x07;
6799 printf ("-D%d", 8 + count
);
6802 else if (op
>= 0xc0 && op
<= 0xc5)
6804 unsigned int count
= op
& 0x07;
6806 printf (" pop {wR10");
6808 printf ("-wR%d", 10 + count
);
6811 else if (op
== 0xc6)
6813 unsigned int first
, last
;
6818 printf ("pop {wR%d", first
);
6820 printf ("-wR%d", first
+ last
);
6823 else if (op
== 0xc7)
6826 if (op2
== 0 || (op2
& 0xf0) != 0)
6827 printf (_("[Spare]"));
6830 unsigned int mask
= op2
& 0x0f;
6835 for (i
= 0; i
< 4; i
++)
6836 if (mask
& (1 << i
))
6842 printf ("wCGR%d", i
);
6848 printf (_(" [unsupported opcode]"));
6854 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6855 unsigned int word
, unsigned int remaining
,
6856 unsigned int more_words
,
6857 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6858 struct arm_section
*data_arm_sec
)
6860 struct absaddr addr
;
6862 /* Decode the unwinding instructions. */
6865 unsigned int op
, op2
;
6874 printf (" 0x%02x ", op
);
6876 if ((op
& 0xc0) == 0x00)
6878 int offset
= ((op
& 0x3f) << 3) + 8;
6879 printf (" sp = sp + %d", offset
);
6881 else if ((op
& 0xc0) == 0x80)
6884 if (op
== 0x80 && op2
== 0)
6885 printf (_("Refuse to unwind"));
6888 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6890 printf ("pop compact {");
6894 decode_tic6x_unwind_regmask (mask
);
6898 else if ((op
& 0xf0) == 0xc0)
6906 unsigned int offset
;
6910 /* Scan entire instruction first so that GET_OP output is not
6911 interleaved with disassembly. */
6913 for (i
= 0; nregs
< (op
& 0xf); i
++)
6919 regpos
[nregs
].offset
= i
* 2;
6920 regpos
[nregs
].reg
= reg
;
6927 regpos
[nregs
].offset
= i
* 2 + 1;
6928 regpos
[nregs
].reg
= reg
;
6933 printf (_("pop frame {"));
6935 for (i
= i
* 2; i
> 0; i
--)
6937 if (regpos
[reg
].offset
== i
- 1)
6939 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
6946 fputs (name
, stdout
);
6953 else if (op
== 0xd0)
6954 printf (" MOV FP, SP");
6955 else if (op
== 0xd1)
6956 printf (" __c6xabi_pop_rts");
6957 else if (op
== 0xd2)
6959 unsigned char buf
[9];
6960 unsigned int i
, len
;
6961 unsigned long offset
;
6963 for (i
= 0; i
< sizeof (buf
); i
++)
6966 if ((buf
[i
] & 0x80) == 0)
6969 assert (i
< sizeof (buf
));
6970 offset
= read_uleb128 (buf
, &len
);
6971 assert (len
== i
+ 1);
6972 offset
= offset
* 8 + 0x408;
6973 printf (_("sp = sp + %ld"), offset
);
6975 else if ((op
& 0xf0) == 0xe0)
6977 if ((op
& 0x0f) == 7)
6980 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
6984 printf (_(" [unsupported opcode]"));
6991 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
6995 offset
= word
& 0x7fffffff;
6996 if (offset
& 0x40000000)
6997 offset
|= ~ (bfd_vma
) 0x7fffffff;
6999 if (elf_header
.e_machine
== EM_TI_C6000
)
7002 return offset
+ where
;
7006 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7008 unsigned int remaining
,
7009 bfd_vma data_offset
,
7010 Elf_Internal_Shdr
* data_sec
,
7011 struct arm_section
* data_arm_sec
)
7014 unsigned int more_words
= 0;
7015 struct absaddr addr
;
7016 bfd_vma sym_name
= (bfd_vma
) -1;
7020 /* Fetch the first word.
7021 Note - when decoding an object file the address extracted
7022 here will always be 0. So we also pass in the sym_name
7023 parameter so that we can find the symbol associated with
7024 the personality routine. */
7025 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7026 & word
, & addr
, & sym_name
))
7032 if ((word
& 0x80000000) == 0)
7034 /* Expand prel31 for personality routine. */
7036 const char *procname
;
7038 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7039 printf (_(" Personality routine: "));
7041 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7042 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7044 procname
= aux
->strtab
+ sym_name
;
7045 print_vma (fn
, PREFIX_HEX
);
7048 fputs (" <", stdout
);
7049 fputs (procname
, stdout
);
7050 fputc ('>', stdout
);
7054 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7055 fputc ('\n', stdout
);
7057 /* The GCC personality routines use the standard compact
7058 encoding, starting with one byte giving the number of
7060 if (procname
!= NULL
7061 && (const_strneq (procname
, "__gcc_personality_v0")
7062 || const_strneq (procname
, "__gxx_personality_v0")
7063 || const_strneq (procname
, "__gcj_personality_v0")
7064 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7071 printf (_(" [Truncated data]\n"));
7074 more_words
= word
>> 24;
7084 /* ARM EHABI Section 6.3:
7086 An exception-handling table entry for the compact model looks like:
7090 1 0 index Data for personalityRoutine[index] */
7092 if (elf_header
.e_machine
== EM_ARM
7093 && (word
& 0x70000000))
7094 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7096 per_index
= (word
>> 24) & 0x7f;
7097 printf (_(" Compact model index: %d\n"), per_index
);
7104 else if (per_index
< 3)
7106 more_words
= (word
>> 16) & 0xff;
7112 switch (elf_header
.e_machine
)
7117 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7118 data_offset
, data_sec
, data_arm_sec
);
7122 warn (_("Unknown ARM compact model index encountered\n"));
7123 printf (_(" [reserved]\n"));
7130 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7131 data_offset
, data_sec
, data_arm_sec
);
7133 else if (per_index
< 5)
7135 if (((word
>> 17) & 0x7f) == 0x7f)
7136 printf (_(" Restore stack from frame pointer\n"));
7138 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7139 printf (_(" Registers restored: "));
7141 printf (" (compact) ");
7142 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7144 printf (_(" Return register: %s\n"),
7145 tic6x_unwind_regnames
[word
& 0xf]);
7148 printf (_(" [reserved (%d)]\n"), per_index
);
7152 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7153 elf_header
.e_machine
);
7156 /* Decode the descriptors. Not implemented. */
7160 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7162 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7163 unsigned int i
, exidx_len
;
7165 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7166 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7167 exidx_len
= exidx_sec
->sh_size
/ 8;
7169 for (i
= 0; i
< exidx_len
; i
++)
7171 unsigned int exidx_fn
, exidx_entry
;
7172 struct absaddr fn_addr
, entry_addr
;
7175 fputc ('\n', stdout
);
7177 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7178 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7179 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7180 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7182 arm_free_section (& exidx_arm_sec
);
7183 arm_free_section (& extab_arm_sec
);
7187 /* ARM EHABI, Section 5:
7188 An index table entry consists of 2 words.
7189 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7190 if (exidx_fn
& 0x80000000)
7191 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7193 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7195 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7196 fputs (": ", stdout
);
7198 if (exidx_entry
== 1)
7200 print_vma (exidx_entry
, PREFIX_HEX
);
7201 fputs (" [cantunwind]\n", stdout
);
7203 else if (exidx_entry
& 0x80000000)
7205 print_vma (exidx_entry
, PREFIX_HEX
);
7206 fputc ('\n', stdout
);
7207 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7211 bfd_vma table
, table_offset
= 0;
7212 Elf_Internal_Shdr
*table_sec
;
7214 fputs ("@", stdout
);
7215 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7216 print_vma (table
, PREFIX_HEX
);
7219 /* Locate the matching .ARM.extab. */
7220 if (entry_addr
.section
!= SHN_UNDEF
7221 && entry_addr
.section
< elf_header
.e_shnum
)
7223 table_sec
= section_headers
+ entry_addr
.section
;
7224 table_offset
= entry_addr
.offset
;
7228 table_sec
= find_section_by_address (table
);
7229 if (table_sec
!= NULL
)
7230 table_offset
= table
- table_sec
->sh_addr
;
7232 if (table_sec
== NULL
)
7234 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7235 (unsigned long) table
);
7238 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7245 arm_free_section (&exidx_arm_sec
);
7246 arm_free_section (&extab_arm_sec
);
7249 /* Used for both ARM and C6X unwinding tables. */
7252 arm_process_unwind (FILE *file
)
7254 struct arm_unw_aux_info aux
;
7255 Elf_Internal_Shdr
*unwsec
= NULL
;
7256 Elf_Internal_Shdr
*strsec
;
7257 Elf_Internal_Shdr
*sec
;
7259 unsigned int sec_type
;
7261 switch (elf_header
.e_machine
)
7264 sec_type
= SHT_ARM_EXIDX
;
7268 sec_type
= SHT_C6000_UNWIND
;
7272 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7273 elf_header
.e_machine
);
7277 if (string_table
== NULL
)
7280 memset (& aux
, 0, sizeof (aux
));
7283 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7285 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7287 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7289 strsec
= section_headers
+ sec
->sh_link
;
7290 assert (aux
.strtab
== NULL
);
7291 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7292 1, strsec
->sh_size
, _("string table"));
7293 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7295 else if (sec
->sh_type
== sec_type
)
7300 printf (_("\nThere are no unwind sections in this file.\n"));
7302 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7304 if (sec
->sh_type
== sec_type
)
7306 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7308 (unsigned long) sec
->sh_offset
,
7309 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7311 dump_arm_unwind (&aux
, sec
);
7318 free ((char *) aux
.strtab
);
7322 process_unwind (FILE * file
)
7324 struct unwind_handler
7327 void (* handler
)(FILE *);
7330 { EM_ARM
, arm_process_unwind
},
7331 { EM_IA_64
, ia64_process_unwind
},
7332 { EM_PARISC
, hppa_process_unwind
},
7333 { EM_TI_C6000
, arm_process_unwind
},
7341 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7342 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7343 return handlers
[i
].handler (file
);
7345 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7346 get_machine_name (elf_header
.e_machine
));
7350 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7352 switch (entry
->d_tag
)
7355 if (entry
->d_un
.d_val
== 0)
7359 static const char * opts
[] =
7361 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7362 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7363 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7364 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7370 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7371 if (entry
->d_un
.d_val
& (1 << cnt
))
7373 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7379 case DT_MIPS_IVERSION
:
7380 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7381 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7383 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7386 case DT_MIPS_TIME_STAMP
:
7391 time_t atime
= entry
->d_un
.d_val
;
7392 tmp
= gmtime (&atime
);
7393 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7394 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7395 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7396 printf (_("Time Stamp: %s"), timebuf
);
7400 case DT_MIPS_RLD_VERSION
:
7401 case DT_MIPS_LOCAL_GOTNO
:
7402 case DT_MIPS_CONFLICTNO
:
7403 case DT_MIPS_LIBLISTNO
:
7404 case DT_MIPS_SYMTABNO
:
7405 case DT_MIPS_UNREFEXTNO
:
7406 case DT_MIPS_HIPAGENO
:
7407 case DT_MIPS_DELTA_CLASS_NO
:
7408 case DT_MIPS_DELTA_INSTANCE_NO
:
7409 case DT_MIPS_DELTA_RELOC_NO
:
7410 case DT_MIPS_DELTA_SYM_NO
:
7411 case DT_MIPS_DELTA_CLASSSYM_NO
:
7412 case DT_MIPS_COMPACT_SIZE
:
7413 print_vma (entry
->d_un
.d_ptr
, DEC
);
7417 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7423 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7425 switch (entry
->d_tag
)
7427 case DT_HP_DLD_FLAGS
:
7436 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7437 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7438 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7439 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7440 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7441 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7442 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7443 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7444 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7445 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7446 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7447 { DT_HP_GST
, "HP_GST" },
7448 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7449 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7450 { DT_HP_NODELETE
, "HP_NODELETE" },
7451 { DT_HP_GROUP
, "HP_GROUP" },
7452 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7456 bfd_vma val
= entry
->d_un
.d_val
;
7458 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7459 if (val
& flags
[cnt
].bit
)
7463 fputs (flags
[cnt
].str
, stdout
);
7465 val
^= flags
[cnt
].bit
;
7468 if (val
!= 0 || first
)
7472 print_vma (val
, HEX
);
7478 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7486 /* VMS vs Unix time offset and factor. */
7488 #define VMS_EPOCH_OFFSET 35067168000000000LL
7489 #define VMS_GRANULARITY_FACTOR 10000000
7491 /* Display a VMS time in a human readable format. */
7494 print_vms_time (bfd_int64_t vmstime
)
7499 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7500 tm
= gmtime (&unxtime
);
7501 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7502 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7503 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7508 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7510 switch (entry
->d_tag
)
7512 case DT_IA_64_PLT_RESERVE
:
7513 /* First 3 slots reserved. */
7514 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7516 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7519 case DT_IA_64_VMS_LINKTIME
:
7521 print_vms_time (entry
->d_un
.d_val
);
7525 case DT_IA_64_VMS_LNKFLAGS
:
7526 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7527 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7528 printf (" CALL_DEBUG");
7529 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7530 printf (" NOP0BUFS");
7531 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7532 printf (" P0IMAGE");
7533 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7534 printf (" MKTHREADS");
7535 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7536 printf (" UPCALLS");
7537 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7539 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7540 printf (" INITIALIZE");
7541 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7543 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7544 printf (" EXE_INIT");
7545 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7546 printf (" TBK_IN_IMG");
7547 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7548 printf (" DBG_IN_IMG");
7549 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7550 printf (" TBK_IN_DSF");
7551 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7552 printf (" DBG_IN_DSF");
7553 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7554 printf (" SIGNATURES");
7555 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7556 printf (" REL_SEG_OFF");
7560 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7567 get_32bit_dynamic_section (FILE * file
)
7569 Elf32_External_Dyn
* edyn
;
7570 Elf32_External_Dyn
* ext
;
7571 Elf_Internal_Dyn
* entry
;
7573 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7574 dynamic_size
, _("dynamic section"));
7578 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7579 might not have the luxury of section headers. Look for the DT_NULL
7580 terminator to determine the number of entries. */
7581 for (ext
= edyn
, dynamic_nent
= 0;
7582 (char *) ext
< (char *) edyn
+ dynamic_size
;
7586 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7590 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7592 if (dynamic_section
== NULL
)
7594 error (_("Out of memory\n"));
7599 for (ext
= edyn
, entry
= dynamic_section
;
7600 entry
< dynamic_section
+ dynamic_nent
;
7603 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7604 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7613 get_64bit_dynamic_section (FILE * file
)
7615 Elf64_External_Dyn
* edyn
;
7616 Elf64_External_Dyn
* ext
;
7617 Elf_Internal_Dyn
* entry
;
7619 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7620 dynamic_size
, _("dynamic section"));
7624 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7625 might not have the luxury of section headers. Look for the DT_NULL
7626 terminator to determine the number of entries. */
7627 for (ext
= edyn
, dynamic_nent
= 0;
7628 (char *) ext
< (char *) edyn
+ dynamic_size
;
7632 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7636 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7638 if (dynamic_section
== NULL
)
7640 error (_("Out of memory\n"));
7645 for (ext
= edyn
, entry
= dynamic_section
;
7646 entry
< dynamic_section
+ dynamic_nent
;
7649 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7650 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7659 print_dynamic_flags (bfd_vma flags
)
7667 flag
= flags
& - flags
;
7677 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7678 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7679 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7680 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7681 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7682 default: fputs (_("unknown"), stdout
); break;
7688 /* Parse and display the contents of the dynamic section. */
7691 process_dynamic_section (FILE * file
)
7693 Elf_Internal_Dyn
* entry
;
7695 if (dynamic_size
== 0)
7698 printf (_("\nThere is no dynamic section in this file.\n"));
7705 if (! get_32bit_dynamic_section (file
))
7708 else if (! get_64bit_dynamic_section (file
))
7711 /* Find the appropriate symbol table. */
7712 if (dynamic_symbols
== NULL
)
7714 for (entry
= dynamic_section
;
7715 entry
< dynamic_section
+ dynamic_nent
;
7718 Elf_Internal_Shdr section
;
7720 if (entry
->d_tag
!= DT_SYMTAB
)
7723 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7725 /* Since we do not know how big the symbol table is,
7726 we default to reading in the entire file (!) and
7727 processing that. This is overkill, I know, but it
7729 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7731 if (archive_file_offset
!= 0)
7732 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7735 if (fseek (file
, 0, SEEK_END
))
7736 error (_("Unable to seek to end of file!\n"));
7738 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7742 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7744 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7746 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7747 if (num_dynamic_syms
< 1)
7749 error (_("Unable to determine the number of symbols to load\n"));
7755 /* Similarly find a string table. */
7756 if (dynamic_strings
== NULL
)
7758 for (entry
= dynamic_section
;
7759 entry
< dynamic_section
+ dynamic_nent
;
7762 unsigned long offset
;
7765 if (entry
->d_tag
!= DT_STRTAB
)
7768 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7770 /* Since we do not know how big the string table is,
7771 we default to reading in the entire file (!) and
7772 processing that. This is overkill, I know, but it
7775 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7777 if (archive_file_offset
!= 0)
7778 str_tab_len
= archive_file_size
- offset
;
7781 if (fseek (file
, 0, SEEK_END
))
7782 error (_("Unable to seek to end of file\n"));
7783 str_tab_len
= ftell (file
) - offset
;
7786 if (str_tab_len
< 1)
7789 (_("Unable to determine the length of the dynamic string table\n"));
7793 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7795 _("dynamic string table"));
7796 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7801 /* And find the syminfo section if available. */
7802 if (dynamic_syminfo
== NULL
)
7804 unsigned long syminsz
= 0;
7806 for (entry
= dynamic_section
;
7807 entry
< dynamic_section
+ dynamic_nent
;
7810 if (entry
->d_tag
== DT_SYMINENT
)
7812 /* Note: these braces are necessary to avoid a syntax
7813 error from the SunOS4 C compiler. */
7814 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7816 else if (entry
->d_tag
== DT_SYMINSZ
)
7817 syminsz
= entry
->d_un
.d_val
;
7818 else if (entry
->d_tag
== DT_SYMINFO
)
7819 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7823 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7825 Elf_External_Syminfo
* extsyminfo
;
7826 Elf_External_Syminfo
* extsym
;
7827 Elf_Internal_Syminfo
* syminfo
;
7829 /* There is a syminfo section. Read the data. */
7830 extsyminfo
= (Elf_External_Syminfo
*)
7831 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7832 _("symbol information"));
7836 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7837 if (dynamic_syminfo
== NULL
)
7839 error (_("Out of memory\n"));
7843 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7844 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7845 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7846 ++syminfo
, ++extsym
)
7848 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7849 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7856 if (do_dynamic
&& dynamic_addr
)
7857 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7858 dynamic_addr
, dynamic_nent
);
7860 printf (_(" Tag Type Name/Value\n"));
7862 for (entry
= dynamic_section
;
7863 entry
< dynamic_section
+ dynamic_nent
;
7871 print_vma (entry
->d_tag
, FULL_HEX
);
7872 dtype
= get_dynamic_type (entry
->d_tag
);
7873 printf (" (%s)%*s", dtype
,
7874 ((is_32bit_elf
? 27 : 19)
7875 - (int) strlen (dtype
)),
7879 switch (entry
->d_tag
)
7883 print_dynamic_flags (entry
->d_un
.d_val
);
7893 switch (entry
->d_tag
)
7896 printf (_("Auxiliary library"));
7900 printf (_("Filter library"));
7904 printf (_("Configuration file"));
7908 printf (_("Dependency audit library"));
7912 printf (_("Audit library"));
7916 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7917 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7921 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7930 printf (_("Flags:"));
7932 if (entry
->d_un
.d_val
== 0)
7933 printf (_(" None\n"));
7936 unsigned long int val
= entry
->d_un
.d_val
;
7938 if (val
& DTF_1_PARINIT
)
7940 printf (" PARINIT");
7941 val
^= DTF_1_PARINIT
;
7943 if (val
& DTF_1_CONFEXP
)
7945 printf (" CONFEXP");
7946 val
^= DTF_1_CONFEXP
;
7949 printf (" %lx", val
);
7958 printf (_("Flags:"));
7960 if (entry
->d_un
.d_val
== 0)
7961 printf (_(" None\n"));
7964 unsigned long int val
= entry
->d_un
.d_val
;
7966 if (val
& DF_P1_LAZYLOAD
)
7968 printf (" LAZYLOAD");
7969 val
^= DF_P1_LAZYLOAD
;
7971 if (val
& DF_P1_GROUPPERM
)
7973 printf (" GROUPPERM");
7974 val
^= DF_P1_GROUPPERM
;
7977 printf (" %lx", val
);
7986 printf (_("Flags:"));
7987 if (entry
->d_un
.d_val
== 0)
7988 printf (_(" None\n"));
7991 unsigned long int val
= entry
->d_un
.d_val
;
7998 if (val
& DF_1_GLOBAL
)
8003 if (val
& DF_1_GROUP
)
8008 if (val
& DF_1_NODELETE
)
8010 printf (" NODELETE");
8011 val
^= DF_1_NODELETE
;
8013 if (val
& DF_1_LOADFLTR
)
8015 printf (" LOADFLTR");
8016 val
^= DF_1_LOADFLTR
;
8018 if (val
& DF_1_INITFIRST
)
8020 printf (" INITFIRST");
8021 val
^= DF_1_INITFIRST
;
8023 if (val
& DF_1_NOOPEN
)
8028 if (val
& DF_1_ORIGIN
)
8033 if (val
& DF_1_DIRECT
)
8038 if (val
& DF_1_TRANS
)
8043 if (val
& DF_1_INTERPOSE
)
8045 printf (" INTERPOSE");
8046 val
^= DF_1_INTERPOSE
;
8048 if (val
& DF_1_NODEFLIB
)
8050 printf (" NODEFLIB");
8051 val
^= DF_1_NODEFLIB
;
8053 if (val
& DF_1_NODUMP
)
8058 if (val
& DF_1_CONLFAT
)
8060 printf (" CONLFAT");
8061 val
^= DF_1_CONLFAT
;
8064 printf (" %lx", val
);
8071 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8073 puts (get_dynamic_type (entry
->d_un
.d_val
));
8093 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8099 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8100 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8106 switch (entry
->d_tag
)
8109 printf (_("Shared library: [%s]"), name
);
8111 if (streq (name
, program_interpreter
))
8112 printf (_(" program interpreter"));
8116 printf (_("Library soname: [%s]"), name
);
8120 printf (_("Library rpath: [%s]"), name
);
8124 printf (_("Library runpath: [%s]"), name
);
8128 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8133 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8146 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8150 case DT_INIT_ARRAYSZ
:
8151 case DT_FINI_ARRAYSZ
:
8152 case DT_GNU_CONFLICTSZ
:
8153 case DT_GNU_LIBLISTSZ
:
8156 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8157 printf (_(" (bytes)\n"));
8167 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8180 if (entry
->d_tag
== DT_USED
8181 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8183 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8187 printf (_("Not needed object: [%s]\n"), name
);
8192 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8198 /* The value of this entry is ignored. */
8203 case DT_GNU_PRELINKED
:
8207 time_t atime
= entry
->d_un
.d_val
;
8209 tmp
= gmtime (&atime
);
8210 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8211 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8212 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8218 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8221 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8227 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8228 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8233 switch (elf_header
.e_machine
)
8236 case EM_MIPS_RS3_LE
:
8237 dynamic_section_mips_val (entry
);
8240 dynamic_section_parisc_val (entry
);
8243 dynamic_section_ia64_val (entry
);
8246 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8258 get_ver_flags (unsigned int flags
)
8260 static char buff
[32];
8267 if (flags
& VER_FLG_BASE
)
8268 strcat (buff
, "BASE ");
8270 if (flags
& VER_FLG_WEAK
)
8272 if (flags
& VER_FLG_BASE
)
8273 strcat (buff
, "| ");
8275 strcat (buff
, "WEAK ");
8278 if (flags
& VER_FLG_INFO
)
8280 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8281 strcat (buff
, "| ");
8283 strcat (buff
, "INFO ");
8286 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8287 strcat (buff
, _("| <unknown>"));
8292 /* Display the contents of the version sections. */
8295 process_version_sections (FILE * file
)
8297 Elf_Internal_Shdr
* section
;
8304 for (i
= 0, section
= section_headers
;
8305 i
< elf_header
.e_shnum
;
8308 switch (section
->sh_type
)
8310 case SHT_GNU_verdef
:
8312 Elf_External_Verdef
* edefs
;
8320 (_("\nVersion definition section '%s' contains %u entries:\n"),
8321 SECTION_NAME (section
), section
->sh_info
);
8323 printf (_(" Addr: 0x"));
8324 printf_vma (section
->sh_addr
);
8325 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8326 (unsigned long) section
->sh_offset
, section
->sh_link
,
8327 section
->sh_link
< elf_header
.e_shnum
8328 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8331 edefs
= (Elf_External_Verdef
*)
8332 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8333 _("version definition section"));
8336 endbuf
= (char *) edefs
+ section
->sh_size
;
8338 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8341 Elf_External_Verdef
* edef
;
8342 Elf_Internal_Verdef ent
;
8343 Elf_External_Verdaux
* eaux
;
8344 Elf_Internal_Verdaux aux
;
8348 /* Check for negative or very large indicies. */
8349 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
8352 vstart
= ((char *) edefs
) + idx
;
8353 if (vstart
+ sizeof (*edef
) > endbuf
)
8356 edef
= (Elf_External_Verdef
*) vstart
;
8358 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8359 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8360 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8361 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8362 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8363 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8364 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8366 printf (_(" %#06x: Rev: %d Flags: %s"),
8367 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8369 printf (_(" Index: %d Cnt: %d "),
8370 ent
.vd_ndx
, ent
.vd_cnt
);
8372 /* Check for overflow. */
8373 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
8374 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
8377 vstart
+= ent
.vd_aux
;
8379 eaux
= (Elf_External_Verdaux
*) vstart
;
8381 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8382 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8384 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8385 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8387 printf (_("Name index: %ld\n"), aux
.vda_name
);
8389 isum
= idx
+ ent
.vd_aux
;
8391 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8393 /* Check for overflow. */
8394 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
8395 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
8398 isum
+= aux
.vda_next
;
8399 vstart
+= aux
.vda_next
;
8401 eaux
= (Elf_External_Verdaux
*) vstart
;
8402 if (vstart
+ sizeof (*eaux
) > endbuf
)
8405 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8406 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8408 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8409 printf (_(" %#06x: Parent %d: %s\n"),
8410 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8412 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8413 isum
, j
, aux
.vda_name
);
8417 printf (_(" Version def aux past end of section\n"));
8422 if (cnt
< section
->sh_info
)
8423 printf (_(" Version definition past end of section\n"));
8429 case SHT_GNU_verneed
:
8431 Elf_External_Verneed
* eneed
;
8438 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8439 SECTION_NAME (section
), section
->sh_info
);
8441 printf (_(" Addr: 0x"));
8442 printf_vma (section
->sh_addr
);
8443 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8444 (unsigned long) section
->sh_offset
, section
->sh_link
,
8445 section
->sh_link
< elf_header
.e_shnum
8446 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8449 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8450 section
->sh_offset
, 1,
8452 _("Version Needs section"));
8455 endbuf
= (char *) eneed
+ section
->sh_size
;
8457 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8459 Elf_External_Verneed
* entry
;
8460 Elf_Internal_Verneed ent
;
8465 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
8468 vstart
= ((char *) eneed
) + idx
;
8469 if (vstart
+ sizeof (*entry
) > endbuf
)
8472 entry
= (Elf_External_Verneed
*) vstart
;
8474 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8475 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8476 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8477 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8478 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8480 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8482 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8483 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8485 printf (_(" File: %lx"), ent
.vn_file
);
8487 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8489 /* Check for overflow. */
8490 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
8491 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
8494 vstart
+= ent
.vn_aux
;
8496 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8498 Elf_External_Vernaux
* eaux
;
8499 Elf_Internal_Vernaux aux
;
8501 if (vstart
+ sizeof (*eaux
) > endbuf
)
8503 eaux
= (Elf_External_Vernaux
*) vstart
;
8505 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8506 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8507 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8508 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8509 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8511 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8512 printf (_(" %#06x: Name: %s"),
8513 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8515 printf (_(" %#06x: Name index: %lx"),
8516 isum
, aux
.vna_name
);
8518 printf (_(" Flags: %s Version: %d\n"),
8519 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8521 /* Check for overflow. */
8522 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
8523 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
8526 isum
+= aux
.vna_next
;
8527 vstart
+= aux
.vna_next
;
8531 warn (_("Missing Version Needs auxillary information\n"));
8536 if (cnt
< section
->sh_info
)
8537 warn (_("Missing Version Needs information\n"));
8543 case SHT_GNU_versym
:
8545 Elf_Internal_Shdr
* link_section
;
8548 unsigned char * edata
;
8549 unsigned short * data
;
8551 Elf_Internal_Sym
* symbols
;
8552 Elf_Internal_Shdr
* string_sec
;
8553 unsigned long num_syms
;
8556 if (section
->sh_link
>= elf_header
.e_shnum
)
8559 link_section
= section_headers
+ section
->sh_link
;
8560 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8562 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8567 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8568 if (symbols
== NULL
)
8571 string_sec
= section_headers
+ link_section
->sh_link
;
8573 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8574 string_sec
->sh_size
,
8575 _("version string table"));
8582 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8583 SECTION_NAME (section
), total
);
8585 printf (_(" Addr: "));
8586 printf_vma (section
->sh_addr
);
8587 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8588 (unsigned long) section
->sh_offset
, section
->sh_link
,
8589 SECTION_NAME (link_section
));
8591 off
= offset_from_vma (file
,
8592 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8593 total
* sizeof (short));
8594 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8596 _("version symbol data"));
8604 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8606 for (cnt
= total
; cnt
--;)
8607 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8612 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8615 int check_def
, check_need
;
8618 printf (" %03x:", cnt
);
8620 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8621 switch (data
[cnt
+ j
])
8624 fputs (_(" 0 (*local*) "), stdout
);
8628 fputs (_(" 1 (*global*) "), stdout
);
8632 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8633 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8635 /* If this index value is greater than the size of the symbols
8636 array, break to avoid an out-of-bounds read. */
8637 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8639 warn (_("invalid index into symbol array\n"));
8645 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8646 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8649 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8656 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8658 Elf_Internal_Verneed ivn
;
8659 unsigned long offset
;
8661 offset
= offset_from_vma
8662 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8663 sizeof (Elf_External_Verneed
));
8667 Elf_Internal_Vernaux ivna
;
8668 Elf_External_Verneed evn
;
8669 Elf_External_Vernaux evna
;
8670 unsigned long a_off
;
8672 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8673 _("version need")) == NULL
)
8676 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8677 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8679 a_off
= offset
+ ivn
.vn_aux
;
8683 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8684 1, _("version need aux (2)")) == NULL
)
8691 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8692 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8695 a_off
+= ivna
.vna_next
;
8697 while (ivna
.vna_other
!= data
[cnt
+ j
]
8698 && ivna
.vna_next
!= 0);
8700 if (ivna
.vna_other
== data
[cnt
+ j
])
8702 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8704 if (ivna
.vna_name
>= string_sec
->sh_size
)
8705 name
= _("*invalid*");
8707 name
= strtab
+ ivna
.vna_name
;
8708 nn
+= printf ("(%s%-*s",
8710 12 - (int) strlen (name
),
8716 offset
+= ivn
.vn_next
;
8718 while (ivn
.vn_next
);
8721 if (check_def
&& data
[cnt
+ j
] != 0x8001
8722 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8724 Elf_Internal_Verdef ivd
;
8725 Elf_External_Verdef evd
;
8726 unsigned long offset
;
8728 offset
= offset_from_vma
8729 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8734 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8735 _("version def")) == NULL
)
8742 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8743 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8746 offset
+= ivd
.vd_next
;
8748 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8749 && ivd
.vd_next
!= 0);
8751 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8753 Elf_External_Verdaux evda
;
8754 Elf_Internal_Verdaux ivda
;
8756 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8758 if (get_data (&evda
, file
,
8759 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8761 _("version def aux")) == NULL
)
8764 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8766 if (ivda
.vda_name
>= string_sec
->sh_size
)
8767 name
= _("*invalid*");
8769 name
= strtab
+ ivda
.vda_name
;
8770 nn
+= printf ("(%s%-*s",
8772 12 - (int) strlen (name
),
8778 printf ("%*c", 18 - nn
, ' ');
8796 printf (_("\nNo version information found in this file.\n"));
8802 get_symbol_binding (unsigned int binding
)
8804 static char buff
[32];
8808 case STB_LOCAL
: return "LOCAL";
8809 case STB_GLOBAL
: return "GLOBAL";
8810 case STB_WEAK
: return "WEAK";
8812 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8813 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8815 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8817 if (binding
== STB_GNU_UNIQUE
8818 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8819 /* GNU is still using the default value 0. */
8820 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8822 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8825 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8831 get_symbol_type (unsigned int type
)
8833 static char buff
[32];
8837 case STT_NOTYPE
: return "NOTYPE";
8838 case STT_OBJECT
: return "OBJECT";
8839 case STT_FUNC
: return "FUNC";
8840 case STT_SECTION
: return "SECTION";
8841 case STT_FILE
: return "FILE";
8842 case STT_COMMON
: return "COMMON";
8843 case STT_TLS
: return "TLS";
8844 case STT_RELC
: return "RELC";
8845 case STT_SRELC
: return "SRELC";
8847 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8849 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8850 return "THUMB_FUNC";
8852 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8855 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8856 return "PARISC_MILLI";
8858 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8860 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8862 if (elf_header
.e_machine
== EM_PARISC
)
8864 if (type
== STT_HP_OPAQUE
)
8866 if (type
== STT_HP_STUB
)
8870 if (type
== STT_GNU_IFUNC
8871 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8872 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
8873 /* GNU is still using the default value 0. */
8874 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8877 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8880 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8886 get_symbol_visibility (unsigned int visibility
)
8890 case STV_DEFAULT
: return "DEFAULT";
8891 case STV_INTERNAL
: return "INTERNAL";
8892 case STV_HIDDEN
: return "HIDDEN";
8893 case STV_PROTECTED
: return "PROTECTED";
8899 get_mips_symbol_other (unsigned int other
)
8911 case STO_MICROMIPS
| STO_MIPS_PIC
:
8912 return "MICROMIPS, MIPS PIC";
8921 get_ia64_symbol_other (unsigned int other
)
8925 static char res
[32];
8929 /* Function types is for images and .STB files only. */
8930 switch (elf_header
.e_type
)
8934 switch (VMS_ST_FUNC_TYPE (other
))
8936 case VMS_SFT_CODE_ADDR
:
8937 strcat (res
, " CA");
8939 case VMS_SFT_SYMV_IDX
:
8940 strcat (res
, " VEC");
8943 strcat (res
, " FD");
8945 case VMS_SFT_RESERVE
:
8946 strcat (res
, " RSV");
8955 switch (VMS_ST_LINKAGE (other
))
8957 case VMS_STL_IGNORE
:
8958 strcat (res
, " IGN");
8960 case VMS_STL_RESERVE
:
8961 strcat (res
, " RSV");
8964 strcat (res
, " STD");
8967 strcat (res
, " LNK");
8982 get_symbol_other (unsigned int other
)
8984 const char * result
= NULL
;
8985 static char buff
[32];
8990 switch (elf_header
.e_machine
)
8993 result
= get_mips_symbol_other (other
);
8996 result
= get_ia64_symbol_other (other
);
9005 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9010 get_symbol_index_type (unsigned int type
)
9012 static char buff
[32];
9016 case SHN_UNDEF
: return "UND";
9017 case SHN_ABS
: return "ABS";
9018 case SHN_COMMON
: return "COM";
9020 if (type
== SHN_IA_64_ANSI_COMMON
9021 && elf_header
.e_machine
== EM_IA_64
9022 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9024 else if ((elf_header
.e_machine
== EM_X86_64
9025 || elf_header
.e_machine
== EM_L1OM
9026 || elf_header
.e_machine
== EM_K1OM
)
9027 && type
== SHN_X86_64_LCOMMON
)
9029 else if ((type
== SHN_MIPS_SCOMMON
9030 && elf_header
.e_machine
== EM_MIPS
)
9031 || (type
== SHN_TIC6X_SCOMMON
9032 && elf_header
.e_machine
== EM_TI_C6000
))
9034 else if (type
== SHN_MIPS_SUNDEFINED
9035 && elf_header
.e_machine
== EM_MIPS
)
9037 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9038 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9039 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9040 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9041 else if (type
>= SHN_LORESERVE
)
9042 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9043 else if (type
>= elf_header
.e_shnum
)
9044 sprintf (buff
, "bad section index[%3d]", type
);
9046 sprintf (buff
, "%3d", type
);
9054 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9056 unsigned char * e_data
;
9059 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9063 error (_("Out of memory\n"));
9067 if (fread (e_data
, ent_size
, number
, file
) != number
)
9069 error (_("Unable to read in dynamic data\n"));
9073 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9077 error (_("Out of memory\n"));
9083 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9091 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9093 Elf_Internal_Sym
* psym
;
9096 psym
= dynamic_symbols
+ si
;
9098 n
= print_vma (si
, DEC_5
);
9100 fputs (" " + n
, stdout
);
9101 printf (" %3lu: ", hn
);
9102 print_vma (psym
->st_value
, LONG_HEX
);
9104 print_vma (psym
->st_size
, DEC_5
);
9106 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9107 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9108 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9109 /* Check to see if any other bits in the st_other field are set.
9110 Note - displaying this information disrupts the layout of the
9111 table being generated, but for the moment this case is very
9113 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9114 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9115 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9116 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9117 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9119 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9123 /* Dump the symbol table. */
9125 process_symbol_table (FILE * file
)
9127 Elf_Internal_Shdr
* section
;
9128 bfd_vma nbuckets
= 0;
9129 bfd_vma nchains
= 0;
9130 bfd_vma
* buckets
= NULL
;
9131 bfd_vma
* chains
= NULL
;
9132 bfd_vma ngnubuckets
= 0;
9133 bfd_vma
* gnubuckets
= NULL
;
9134 bfd_vma
* gnuchains
= NULL
;
9135 bfd_vma gnusymidx
= 0;
9137 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9140 if (dynamic_info
[DT_HASH
]
9142 || (do_using_dynamic
9144 && dynamic_strings
!= NULL
)))
9146 unsigned char nb
[8];
9147 unsigned char nc
[8];
9148 int hash_ent_size
= 4;
9150 if ((elf_header
.e_machine
== EM_ALPHA
9151 || elf_header
.e_machine
== EM_S390
9152 || elf_header
.e_machine
== EM_S390_OLD
)
9153 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9157 (archive_file_offset
9158 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9159 sizeof nb
+ sizeof nc
)),
9162 error (_("Unable to seek to start of dynamic information\n"));
9166 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9168 error (_("Failed to read in number of buckets\n"));
9172 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9174 error (_("Failed to read in number of chains\n"));
9178 nbuckets
= byte_get (nb
, hash_ent_size
);
9179 nchains
= byte_get (nc
, hash_ent_size
);
9181 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9182 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9185 if (buckets
== NULL
|| chains
== NULL
)
9187 if (do_using_dynamic
)
9198 if (dynamic_info_DT_GNU_HASH
9200 || (do_using_dynamic
9202 && dynamic_strings
!= NULL
)))
9204 unsigned char nb
[16];
9205 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9206 bfd_vma buckets_vma
;
9209 (archive_file_offset
9210 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9214 error (_("Unable to seek to start of dynamic information\n"));
9218 if (fread (nb
, 16, 1, file
) != 1)
9220 error (_("Failed to read in number of buckets\n"));
9224 ngnubuckets
= byte_get (nb
, 4);
9225 gnusymidx
= byte_get (nb
+ 4, 4);
9226 bitmaskwords
= byte_get (nb
+ 8, 4);
9227 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9229 buckets_vma
+= bitmaskwords
* 4;
9231 buckets_vma
+= bitmaskwords
* 8;
9234 (archive_file_offset
9235 + offset_from_vma (file
, buckets_vma
, 4)),
9238 error (_("Unable to seek to start of dynamic information\n"));
9242 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9244 if (gnubuckets
== NULL
)
9247 for (i
= 0; i
< ngnubuckets
; i
++)
9248 if (gnubuckets
[i
] != 0)
9250 if (gnubuckets
[i
] < gnusymidx
)
9253 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9254 maxchain
= gnubuckets
[i
];
9257 if (maxchain
== 0xffffffff)
9260 maxchain
-= gnusymidx
;
9263 (archive_file_offset
9264 + offset_from_vma (file
, buckets_vma
9265 + 4 * (ngnubuckets
+ maxchain
), 4)),
9268 error (_("Unable to seek to start of dynamic information\n"));
9274 if (fread (nb
, 4, 1, file
) != 1)
9276 error (_("Failed to determine last chain length\n"));
9280 if (maxchain
+ 1 == 0)
9285 while ((byte_get (nb
, 4) & 1) == 0);
9288 (archive_file_offset
9289 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9292 error (_("Unable to seek to start of dynamic information\n"));
9296 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9299 if (gnuchains
== NULL
)
9304 if (do_using_dynamic
)
9309 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9312 && dynamic_strings
!= NULL
)
9316 if (dynamic_info
[DT_HASH
])
9320 printf (_("\nSymbol table for image:\n"));
9322 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9324 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9326 for (hn
= 0; hn
< nbuckets
; hn
++)
9331 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9332 print_dynamic_symbol (si
, hn
);
9336 if (dynamic_info_DT_GNU_HASH
)
9338 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9340 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9342 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9344 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9345 if (gnubuckets
[hn
] != 0)
9347 bfd_vma si
= gnubuckets
[hn
];
9348 bfd_vma off
= si
- gnusymidx
;
9352 print_dynamic_symbol (si
, hn
);
9355 while ((gnuchains
[off
++] & 1) == 0);
9359 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9363 for (i
= 0, section
= section_headers
;
9364 i
< elf_header
.e_shnum
;
9368 char * strtab
= NULL
;
9369 unsigned long int strtab_size
= 0;
9370 Elf_Internal_Sym
* symtab
;
9371 Elf_Internal_Sym
* psym
;
9372 unsigned long num_syms
;
9374 if ((section
->sh_type
!= SHT_SYMTAB
9375 && section
->sh_type
!= SHT_DYNSYM
)
9377 && section
->sh_type
== SHT_SYMTAB
))
9380 if (section
->sh_entsize
== 0)
9382 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9383 SECTION_NAME (section
));
9387 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9388 SECTION_NAME (section
),
9389 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9392 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9394 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9396 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9400 if (section
->sh_link
== elf_header
.e_shstrndx
)
9402 strtab
= string_table
;
9403 strtab_size
= string_table_length
;
9405 else if (section
->sh_link
< elf_header
.e_shnum
)
9407 Elf_Internal_Shdr
* string_sec
;
9409 string_sec
= section_headers
+ section
->sh_link
;
9411 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9412 1, string_sec
->sh_size
,
9414 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9417 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9419 printf ("%6d: ", si
);
9420 print_vma (psym
->st_value
, LONG_HEX
);
9422 print_vma (psym
->st_size
, DEC_5
);
9423 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9424 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9425 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9426 /* Check to see if any other bits in the st_other field are set.
9427 Note - displaying this information disrupts the layout of the
9428 table being generated, but for the moment this case is very rare. */
9429 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9430 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9431 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9432 print_symbol (25, psym
->st_name
< strtab_size
9433 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9435 if (section
->sh_type
== SHT_DYNSYM
9436 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9438 unsigned char data
[2];
9439 unsigned short vers_data
;
9440 unsigned long offset
;
9444 offset
= offset_from_vma
9445 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9446 sizeof data
+ si
* sizeof (vers_data
));
9448 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9449 sizeof (data
), 1, _("version data")) == NULL
)
9452 vers_data
= byte_get (data
, 2);
9454 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9455 && section_headers
[psym
->st_shndx
].sh_type
9458 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9460 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9462 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9463 && (is_nobits
|| ! check_def
))
9465 Elf_External_Verneed evn
;
9466 Elf_Internal_Verneed ivn
;
9467 Elf_Internal_Vernaux ivna
;
9469 /* We must test both. */
9470 offset
= offset_from_vma
9471 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9476 unsigned long vna_off
;
9478 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9479 _("version need")) == NULL
)
9487 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9488 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9490 vna_off
= offset
+ ivn
.vn_aux
;
9494 Elf_External_Vernaux evna
;
9496 if (get_data (&evna
, file
, vna_off
,
9498 _("version need aux (3)")) == NULL
)
9506 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9507 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9508 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9511 vna_off
+= ivna
.vna_next
;
9513 while (ivna
.vna_other
!= vers_data
9514 && ivna
.vna_next
!= 0);
9516 if (ivna
.vna_other
== vers_data
)
9519 offset
+= ivn
.vn_next
;
9521 while (ivn
.vn_next
!= 0);
9523 if (ivna
.vna_other
== vers_data
)
9526 ivna
.vna_name
< strtab_size
9527 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9531 else if (! is_nobits
)
9532 error (_("bad dynamic symbol\n"));
9539 if (vers_data
!= 0x8001
9540 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9542 Elf_Internal_Verdef ivd
;
9543 Elf_Internal_Verdaux ivda
;
9544 Elf_External_Verdaux evda
;
9547 off
= offset_from_vma
9549 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9550 sizeof (Elf_External_Verdef
));
9554 Elf_External_Verdef evd
;
9556 if (get_data (&evd
, file
, off
, sizeof (evd
),
9557 1, _("version def")) == NULL
)
9565 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9566 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9567 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9572 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9573 && ivd
.vd_next
!= 0);
9578 if (get_data (&evda
, file
, off
, sizeof (evda
),
9579 1, _("version def aux")) == NULL
)
9582 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9584 if (psym
->st_name
!= ivda
.vda_name
)
9585 printf ((vers_data
& VERSYM_HIDDEN
)
9587 ivda
.vda_name
< strtab_size
9588 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9598 if (strtab
!= string_table
)
9604 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9606 if (do_histogram
&& buckets
!= NULL
)
9608 unsigned long * lengths
;
9609 unsigned long * counts
;
9612 unsigned long maxlength
= 0;
9613 unsigned long nzero_counts
= 0;
9614 unsigned long nsyms
= 0;
9616 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9617 (unsigned long) nbuckets
);
9618 printf (_(" Length Number %% of total Coverage\n"));
9620 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9621 if (lengths
== NULL
)
9623 error (_("Out of memory\n"));
9626 for (hn
= 0; hn
< nbuckets
; ++hn
)
9628 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9631 if (maxlength
< ++lengths
[hn
])
9636 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9639 error (_("Out of memory\n"));
9643 for (hn
= 0; hn
< nbuckets
; ++hn
)
9644 ++counts
[lengths
[hn
]];
9649 printf (" 0 %-10lu (%5.1f%%)\n",
9650 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9651 for (i
= 1; i
<= maxlength
; ++i
)
9653 nzero_counts
+= counts
[i
] * i
;
9654 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9655 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9656 (nzero_counts
* 100.0) / nsyms
);
9664 if (buckets
!= NULL
)
9670 if (do_histogram
&& gnubuckets
!= NULL
)
9672 unsigned long * lengths
;
9673 unsigned long * counts
;
9675 unsigned long maxlength
= 0;
9676 unsigned long nzero_counts
= 0;
9677 unsigned long nsyms
= 0;
9679 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9680 if (lengths
== NULL
)
9682 error (_("Out of memory\n"));
9686 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9687 (unsigned long) ngnubuckets
);
9688 printf (_(" Length Number %% of total Coverage\n"));
9690 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9691 if (gnubuckets
[hn
] != 0)
9693 bfd_vma off
, length
= 1;
9695 for (off
= gnubuckets
[hn
] - gnusymidx
;
9696 (gnuchains
[off
] & 1) == 0; ++off
)
9698 lengths
[hn
] = length
;
9699 if (length
> maxlength
)
9704 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9707 error (_("Out of memory\n"));
9711 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9712 ++counts
[lengths
[hn
]];
9714 if (ngnubuckets
> 0)
9717 printf (" 0 %-10lu (%5.1f%%)\n",
9718 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9719 for (j
= 1; j
<= maxlength
; ++j
)
9721 nzero_counts
+= counts
[j
] * j
;
9722 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9723 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9724 (nzero_counts
* 100.0) / nsyms
);
9738 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9742 if (dynamic_syminfo
== NULL
9744 /* No syminfo, this is ok. */
9747 /* There better should be a dynamic symbol section. */
9748 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9752 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9753 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9755 printf (_(" Num: Name BoundTo Flags\n"));
9756 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9758 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9760 printf ("%4d: ", i
);
9761 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9762 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9764 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9767 switch (dynamic_syminfo
[i
].si_boundto
)
9769 case SYMINFO_BT_SELF
:
9770 fputs ("SELF ", stdout
);
9772 case SYMINFO_BT_PARENT
:
9773 fputs ("PARENT ", stdout
);
9776 if (dynamic_syminfo
[i
].si_boundto
> 0
9777 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9778 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9780 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9784 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9788 if (flags
& SYMINFO_FLG_DIRECT
)
9790 if (flags
& SYMINFO_FLG_PASSTHRU
)
9791 printf (" PASSTHRU");
9792 if (flags
& SYMINFO_FLG_COPY
)
9794 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9795 printf (" LAZYLOAD");
9803 /* Check to see if the given reloc needs to be handled in a target specific
9804 manner. If so then process the reloc and return TRUE otherwise return
9808 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9809 unsigned char * start
,
9810 Elf_Internal_Sym
* symtab
)
9812 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9814 switch (elf_header
.e_machine
)
9817 case EM_CYGNUS_MN10300
:
9819 static Elf_Internal_Sym
* saved_sym
= NULL
;
9823 case 34: /* R_MN10300_ALIGN */
9825 case 33: /* R_MN10300_SYM_DIFF */
9826 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9828 case 1: /* R_MN10300_32 */
9829 case 2: /* R_MN10300_16 */
9830 if (saved_sym
!= NULL
)
9834 value
= reloc
->r_addend
9835 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9836 - saved_sym
->st_value
);
9838 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9845 if (saved_sym
!= NULL
)
9846 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9856 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9857 DWARF debug sections. This is a target specific test. Note - we do not
9858 go through the whole including-target-headers-multiple-times route, (as
9859 we have already done with <elf/h8.h>) because this would become very
9860 messy and even then this function would have to contain target specific
9861 information (the names of the relocs instead of their numeric values).
9862 FIXME: This is not the correct way to solve this problem. The proper way
9863 is to have target specific reloc sizing and typing functions created by
9864 the reloc-macros.h header, in the same way that it already creates the
9865 reloc naming functions. */
9868 is_32bit_abs_reloc (unsigned int reloc_type
)
9870 switch (elf_header
.e_machine
)
9874 return reloc_type
== 1; /* R_386_32. */
9876 return reloc_type
== 1; /* R_68K_32. */
9878 return reloc_type
== 1; /* R_860_32. */
9880 return reloc_type
== 2; /* R_960_32. */
9882 return reloc_type
== 258; /* R_AARCH64_ABS32 */
9884 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
9886 return reloc_type
== 1; /* R_ARC_32. */
9888 return reloc_type
== 2; /* R_ARM_ABS32 */
9891 return reloc_type
== 1;
9892 case EM_ADAPTEVA_EPIPHANY
:
9893 return reloc_type
== 3;
9895 return reloc_type
== 0x12; /* R_byte4_data. */
9897 return reloc_type
== 3; /* R_CRIS_32. */
9899 return reloc_type
== 3; /* R_CR16_NUM32. */
9901 return reloc_type
== 15; /* R_CRX_NUM32. */
9903 return reloc_type
== 1;
9904 case EM_CYGNUS_D10V
:
9906 return reloc_type
== 6; /* R_D10V_32. */
9907 case EM_CYGNUS_D30V
:
9909 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9911 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9912 case EM_CYGNUS_FR30
:
9914 return reloc_type
== 3; /* R_FR30_32. */
9918 return reloc_type
== 1; /* R_H8_DIR32. */
9920 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9923 return reloc_type
== 2; /* R_IP2K_32. */
9925 return reloc_type
== 2; /* R_IQ2000_32. */
9926 case EM_LATTICEMICO32
:
9927 return reloc_type
== 3; /* R_LM32_32. */
9930 return reloc_type
== 3; /* R_M32C_32. */
9932 return reloc_type
== 34; /* R_M32R_32_RELA. */
9934 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9936 return reloc_type
== 4; /* R_MEP_32. */
9938 return reloc_type
== 1; /* R_MICROBLAZE_32. */
9940 return reloc_type
== 2; /* R_MIPS_32. */
9942 return reloc_type
== 4; /* R_MMIX_32. */
9943 case EM_CYGNUS_MN10200
:
9945 return reloc_type
== 1; /* R_MN10200_32. */
9946 case EM_CYGNUS_MN10300
:
9948 return reloc_type
== 1; /* R_MN10300_32. */
9950 return reloc_type
== 1; /* R_MOXIE_32. */
9953 return reloc_type
== 1; /* R_MSP43_32. */
9955 return reloc_type
== 2; /* R_MT_32. */
9956 case EM_ALTERA_NIOS2
:
9958 return reloc_type
== 1; /* R_NIOS_32. */
9961 return reloc_type
== 1; /* R_OR32_32. */
9963 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9964 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9967 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9969 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9971 return reloc_type
== 1; /* R_PPC_ADDR32. */
9973 return reloc_type
== 1; /* R_RL78_DIR32. */
9975 return reloc_type
== 1; /* R_RX_DIR32. */
9977 return reloc_type
== 1; /* R_I370_ADDR31. */
9980 return reloc_type
== 4; /* R_S390_32. */
9982 return reloc_type
== 8; /* R_SCORE_ABS32. */
9984 return reloc_type
== 1; /* R_SH_DIR32. */
9985 case EM_SPARC32PLUS
:
9988 return reloc_type
== 3 /* R_SPARC_32. */
9989 || reloc_type
== 23; /* R_SPARC_UA32. */
9991 return reloc_type
== 6; /* R_SPU_ADDR32 */
9993 return reloc_type
== 1; /* R_C6000_ABS32. */
9995 return reloc_type
== 2; /* R_TILEGX_32. */
9997 return reloc_type
== 1; /* R_TILEPRO_32. */
9998 case EM_CYGNUS_V850
:
10000 return reloc_type
== 6; /* R_V850_ABS32. */
10002 return reloc_type
== 1; /* R_VAX_32. */
10006 return reloc_type
== 10; /* R_X86_64_32. */
10009 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10011 return reloc_type
== 4; /* R_XGATE_32. */
10013 return reloc_type
== 1; /* R_XSTROMY16_32. */
10014 case EM_XTENSA_OLD
:
10016 return reloc_type
== 1; /* R_XTENSA_32. */
10018 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10019 elf_header
.e_machine
);
10024 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10025 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10028 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10030 switch (elf_header
.e_machine
)
10034 return reloc_type
== 2; /* R_386_PC32. */
10036 return reloc_type
== 4; /* R_68K_PC32. */
10038 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10039 case EM_ADAPTEVA_EPIPHANY
:
10040 return reloc_type
== 6;
10042 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10044 return reloc_type
== 3; /* R_ARM_REL32 */
10045 case EM_MICROBLAZE
:
10046 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10048 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10050 return reloc_type
== 26; /* R_PPC_REL32. */
10052 return reloc_type
== 26; /* R_PPC64_REL32. */
10055 return reloc_type
== 5; /* R_390_PC32. */
10057 return reloc_type
== 2; /* R_SH_REL32. */
10058 case EM_SPARC32PLUS
:
10061 return reloc_type
== 6; /* R_SPARC_DISP32. */
10063 return reloc_type
== 13; /* R_SPU_REL32. */
10065 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10067 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10071 return reloc_type
== 2; /* R_X86_64_PC32. */
10072 case EM_XTENSA_OLD
:
10074 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10076 /* Do not abort or issue an error message here. Not all targets use
10077 pc-relative 32-bit relocs in their DWARF debug information and we
10078 have already tested for target coverage in is_32bit_abs_reloc. A
10079 more helpful warning message will be generated by apply_relocations
10080 anyway, so just return. */
10085 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10086 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10089 is_64bit_abs_reloc (unsigned int reloc_type
)
10091 switch (elf_header
.e_machine
)
10094 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10096 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10098 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10100 return reloc_type
== 80; /* R_PARISC_DIR64. */
10102 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10103 case EM_SPARC32PLUS
:
10106 return reloc_type
== 54; /* R_SPARC_UA64. */
10110 return reloc_type
== 1; /* R_X86_64_64. */
10113 return reloc_type
== 22; /* R_S390_64. */
10115 return reloc_type
== 1; /* R_TILEGX_64. */
10117 return reloc_type
== 18; /* R_MIPS_64. */
10123 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10124 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10127 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10129 switch (elf_header
.e_machine
)
10132 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10134 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10136 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10138 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10140 return reloc_type
== 44; /* R_PPC64_REL64. */
10141 case EM_SPARC32PLUS
:
10144 return reloc_type
== 46; /* R_SPARC_DISP64. */
10148 return reloc_type
== 24; /* R_X86_64_PC64. */
10151 return reloc_type
== 23; /* R_S390_PC64. */
10153 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10159 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10160 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10163 is_24bit_abs_reloc (unsigned int reloc_type
)
10165 switch (elf_header
.e_machine
)
10167 case EM_CYGNUS_MN10200
:
10169 return reloc_type
== 4; /* R_MN10200_24. */
10175 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10176 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10179 is_16bit_abs_reloc (unsigned int reloc_type
)
10181 switch (elf_header
.e_machine
)
10185 return reloc_type
== 4; /* R_AVR_16. */
10186 case EM_ADAPTEVA_EPIPHANY
:
10187 return reloc_type
== 5;
10188 case EM_CYGNUS_D10V
:
10190 return reloc_type
== 3; /* R_D10V_16. */
10194 return reloc_type
== R_H8_DIR16
;
10197 return reloc_type
== 1; /* R_IP2K_16. */
10200 return reloc_type
== 1; /* R_M32C_16 */
10201 case EM_MSP430_OLD
:
10203 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10204 case EM_ALTERA_NIOS2
:
10206 return reloc_type
== 9; /* R_NIOS_16. */
10208 return reloc_type
== 2; /* R_C6000_ABS16. */
10211 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10212 case EM_CYGNUS_MN10200
:
10214 return reloc_type
== 2; /* R_MN10200_16. */
10215 case EM_CYGNUS_MN10300
:
10217 return reloc_type
== 2; /* R_MN10300_16. */
10219 return reloc_type
== 3; /* R_XGATE_16. */
10225 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10226 relocation entries (possibly formerly used for SHT_GROUP sections). */
10229 is_none_reloc (unsigned int reloc_type
)
10231 switch (elf_header
.e_machine
)
10233 case EM_68K
: /* R_68K_NONE. */
10234 case EM_386
: /* R_386_NONE. */
10235 case EM_SPARC32PLUS
:
10237 case EM_SPARC
: /* R_SPARC_NONE. */
10238 case EM_MIPS
: /* R_MIPS_NONE. */
10239 case EM_PARISC
: /* R_PARISC_NONE. */
10240 case EM_ALPHA
: /* R_ALPHA_NONE. */
10241 case EM_ADAPTEVA_EPIPHANY
:
10242 case EM_PPC
: /* R_PPC_NONE. */
10243 case EM_PPC64
: /* R_PPC64_NONE. */
10244 case EM_ARM
: /* R_ARM_NONE. */
10245 case EM_IA_64
: /* R_IA64_NONE. */
10246 case EM_SH
: /* R_SH_NONE. */
10248 case EM_S390
: /* R_390_NONE. */
10249 case EM_CRIS
: /* R_CRIS_NONE. */
10250 case EM_X86_64
: /* R_X86_64_NONE. */
10251 case EM_L1OM
: /* R_X86_64_NONE. */
10252 case EM_K1OM
: /* R_X86_64_NONE. */
10253 case EM_MN10300
: /* R_MN10300_NONE. */
10254 case EM_MOXIE
: /* R_MOXIE_NONE. */
10255 case EM_M32R
: /* R_M32R_NONE. */
10256 case EM_TI_C6000
:/* R_C6000_NONE. */
10257 case EM_TILEGX
: /* R_TILEGX_NONE. */
10258 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10260 case EM_C166
: /* R_XC16X_NONE. */
10261 return reloc_type
== 0;
10263 return reloc_type
== 0 || reloc_type
== 256;
10264 case EM_XTENSA_OLD
:
10266 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10267 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10268 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10269 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10274 /* Apply relocations to a section.
10275 Note: So far support has been added only for those relocations
10276 which can be found in debug sections.
10277 FIXME: Add support for more relocations ? */
10280 apply_relocations (void * file
,
10281 Elf_Internal_Shdr
* section
,
10282 unsigned char * start
)
10284 Elf_Internal_Shdr
* relsec
;
10285 unsigned char * end
= start
+ section
->sh_size
;
10287 if (elf_header
.e_type
!= ET_REL
)
10290 /* Find the reloc section associated with the section. */
10291 for (relsec
= section_headers
;
10292 relsec
< section_headers
+ elf_header
.e_shnum
;
10295 bfd_boolean is_rela
;
10296 unsigned long num_relocs
;
10297 Elf_Internal_Rela
* relocs
;
10298 Elf_Internal_Rela
* rp
;
10299 Elf_Internal_Shdr
* symsec
;
10300 Elf_Internal_Sym
* symtab
;
10301 unsigned long num_syms
;
10302 Elf_Internal_Sym
* sym
;
10304 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10305 || relsec
->sh_info
>= elf_header
.e_shnum
10306 || section_headers
+ relsec
->sh_info
!= section
10307 || relsec
->sh_size
== 0
10308 || relsec
->sh_link
>= elf_header
.e_shnum
)
10311 is_rela
= relsec
->sh_type
== SHT_RELA
;
10315 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10316 relsec
->sh_size
, & relocs
, & num_relocs
))
10321 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10322 relsec
->sh_size
, & relocs
, & num_relocs
))
10326 /* SH uses RELA but uses in place value instead of the addend field. */
10327 if (elf_header
.e_machine
== EM_SH
)
10330 symsec
= section_headers
+ relsec
->sh_link
;
10331 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10333 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10336 unsigned int reloc_type
;
10337 unsigned int reloc_size
;
10338 unsigned char * rloc
;
10339 unsigned long sym_index
;
10341 reloc_type
= get_reloc_type (rp
->r_info
);
10343 if (target_specific_reloc_handling (rp
, start
, symtab
))
10345 else if (is_none_reloc (reloc_type
))
10347 else if (is_32bit_abs_reloc (reloc_type
)
10348 || is_32bit_pcrel_reloc (reloc_type
))
10350 else if (is_64bit_abs_reloc (reloc_type
)
10351 || is_64bit_pcrel_reloc (reloc_type
))
10353 else if (is_24bit_abs_reloc (reloc_type
))
10355 else if (is_16bit_abs_reloc (reloc_type
))
10359 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10360 reloc_type
, SECTION_NAME (section
));
10364 rloc
= start
+ rp
->r_offset
;
10365 if ((rloc
+ reloc_size
) > end
)
10367 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10368 (unsigned long) rp
->r_offset
,
10369 SECTION_NAME (section
));
10373 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10374 if (sym_index
>= num_syms
)
10376 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10377 sym_index
, SECTION_NAME (section
));
10380 sym
= symtab
+ sym_index
;
10382 /* If the reloc has a symbol associated with it,
10383 make sure that it is of an appropriate type.
10385 Relocations against symbols without type can happen.
10386 Gcc -feliminate-dwarf2-dups may generate symbols
10387 without type for debug info.
10389 Icc generates relocations against function symbols
10390 instead of local labels.
10392 Relocations against object symbols can happen, eg when
10393 referencing a global array. For an example of this see
10394 the _clz.o binary in libgcc.a. */
10396 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10398 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10399 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10400 (long int)(rp
- relocs
),
10401 SECTION_NAME (relsec
));
10407 addend
+= rp
->r_addend
;
10408 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10409 partial_inplace. */
10411 || (elf_header
.e_machine
== EM_XTENSA
10412 && reloc_type
== 1)
10413 || ((elf_header
.e_machine
== EM_PJ
10414 || elf_header
.e_machine
== EM_PJ_OLD
)
10415 && reloc_type
== 1)
10416 || ((elf_header
.e_machine
== EM_D30V
10417 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10418 && reloc_type
== 12))
10419 addend
+= byte_get (rloc
, reloc_size
);
10421 if (is_32bit_pcrel_reloc (reloc_type
)
10422 || is_64bit_pcrel_reloc (reloc_type
))
10424 /* On HPPA, all pc-relative relocations are biased by 8. */
10425 if (elf_header
.e_machine
== EM_PARISC
)
10427 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10431 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10440 #ifdef SUPPORT_DISASSEMBLY
10442 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10444 printf (_("\nAssembly dump of section %s\n"),
10445 SECTION_NAME (section
));
10447 /* XXX -- to be done --- XXX */
10453 /* Reads in the contents of SECTION from FILE, returning a pointer
10454 to a malloc'ed buffer or NULL if something went wrong. */
10457 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10459 bfd_size_type num_bytes
;
10461 num_bytes
= section
->sh_size
;
10463 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10465 printf (_("\nSection '%s' has no data to dump.\n"),
10466 SECTION_NAME (section
));
10470 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10471 _("section contents"));
10476 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10478 Elf_Internal_Shdr
* relsec
;
10479 bfd_size_type num_bytes
;
10483 char * name
= SECTION_NAME (section
);
10484 bfd_boolean some_strings_shown
;
10486 start
= get_section_contents (section
, file
);
10490 printf (_("\nString dump of section '%s':\n"), name
);
10492 /* If the section being dumped has relocations against it the user might
10493 be expecting these relocations to have been applied. Check for this
10494 case and issue a warning message in order to avoid confusion.
10495 FIXME: Maybe we ought to have an option that dumps a section with
10496 relocs applied ? */
10497 for (relsec
= section_headers
;
10498 relsec
< section_headers
+ elf_header
.e_shnum
;
10501 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10502 || relsec
->sh_info
>= elf_header
.e_shnum
10503 || section_headers
+ relsec
->sh_info
!= section
10504 || relsec
->sh_size
== 0
10505 || relsec
->sh_link
>= elf_header
.e_shnum
)
10508 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10512 num_bytes
= section
->sh_size
;
10514 end
= start
+ num_bytes
;
10515 some_strings_shown
= FALSE
;
10519 while (!ISPRINT (* data
))
10520 if (++ data
>= end
)
10526 /* PR 11128: Use two separate invocations in order to work
10527 around bugs in the Solaris 8 implementation of printf. */
10528 printf (" [%6tx] ", data
- start
);
10529 printf ("%s\n", data
);
10531 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10533 data
+= strlen (data
);
10534 some_strings_shown
= TRUE
;
10538 if (! some_strings_shown
)
10539 printf (_(" No strings found in this section."));
10547 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10549 bfd_boolean relocate
)
10551 Elf_Internal_Shdr
* relsec
;
10552 bfd_size_type bytes
;
10554 unsigned char * data
;
10555 unsigned char * start
;
10557 start
= (unsigned char *) get_section_contents (section
, file
);
10561 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10565 apply_relocations (file
, section
, start
);
10569 /* If the section being dumped has relocations against it the user might
10570 be expecting these relocations to have been applied. Check for this
10571 case and issue a warning message in order to avoid confusion.
10572 FIXME: Maybe we ought to have an option that dumps a section with
10573 relocs applied ? */
10574 for (relsec
= section_headers
;
10575 relsec
< section_headers
+ elf_header
.e_shnum
;
10578 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10579 || relsec
->sh_info
>= elf_header
.e_shnum
10580 || section_headers
+ relsec
->sh_info
!= section
10581 || relsec
->sh_size
== 0
10582 || relsec
->sh_link
>= elf_header
.e_shnum
)
10585 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10590 addr
= section
->sh_addr
;
10591 bytes
= section
->sh_size
;
10600 lbytes
= (bytes
> 16 ? 16 : bytes
);
10602 printf (" 0x%8.8lx ", (unsigned long) addr
);
10604 for (j
= 0; j
< 16; j
++)
10607 printf ("%2.2x", data
[j
]);
10615 for (j
= 0; j
< lbytes
; j
++)
10618 if (k
>= ' ' && k
< 0x7f)
10636 /* Uncompresses a section that was compressed using zlib, in place. */
10639 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10640 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10642 #ifndef HAVE_ZLIB_H
10645 dwarf_size_type compressed_size
= *size
;
10646 unsigned char * compressed_buffer
= *buffer
;
10647 dwarf_size_type uncompressed_size
;
10648 unsigned char * uncompressed_buffer
;
10651 dwarf_size_type header_size
= 12;
10653 /* Read the zlib header. In this case, it should be "ZLIB" followed
10654 by the uncompressed section size, 8 bytes in big-endian order. */
10655 if (compressed_size
< header_size
10656 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10659 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10660 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10661 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10662 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10663 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10664 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10665 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10666 uncompressed_size
+= compressed_buffer
[11];
10668 /* It is possible the section consists of several compressed
10669 buffers concatenated together, so we uncompress in a loop. */
10670 strm
.zalloc
= NULL
;
10672 strm
.opaque
= NULL
;
10673 strm
.avail_in
= compressed_size
- header_size
;
10674 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10675 strm
.avail_out
= uncompressed_size
;
10676 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10678 rc
= inflateInit (& strm
);
10679 while (strm
.avail_in
> 0)
10683 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10684 + (uncompressed_size
- strm
.avail_out
));
10685 rc
= inflate (&strm
, Z_FINISH
);
10686 if (rc
!= Z_STREAM_END
)
10688 rc
= inflateReset (& strm
);
10690 rc
= inflateEnd (& strm
);
10692 || strm
.avail_out
!= 0)
10695 free (compressed_buffer
);
10696 *buffer
= uncompressed_buffer
;
10697 *size
= uncompressed_size
;
10701 free (uncompressed_buffer
);
10702 /* Indicate decompression failure. */
10705 #endif /* HAVE_ZLIB_H */
10709 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10710 Elf_Internal_Shdr
* sec
, void * file
)
10712 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10715 /* If it is already loaded, do nothing. */
10716 if (section
->start
!= NULL
)
10719 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10720 section
->address
= sec
->sh_addr
;
10721 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10723 sec
->sh_size
, buf
);
10724 if (section
->start
== NULL
)
10728 section
->size
= sec
->sh_size
;
10729 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10730 sec
->sh_size
= section
->size
;
10733 if (section
->start
== NULL
)
10736 if (debug_displays
[debug
].relocate
)
10737 apply_relocations ((FILE *) file
, sec
, section
->start
);
10742 /* If this is not NULL, load_debug_section will only look for sections
10743 within the list of sections given here. */
10744 unsigned int *section_subset
= NULL
;
10747 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10749 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10750 Elf_Internal_Shdr
* sec
;
10752 /* Locate the debug section. */
10753 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10755 section
->name
= section
->uncompressed_name
;
10758 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10760 section
->name
= section
->compressed_name
;
10765 /* If we're loading from a subset of sections, and we've loaded
10766 a section matching this name before, it's likely that it's a
10768 if (section_subset
!= NULL
)
10769 free_debug_section (debug
);
10771 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10775 free_debug_section (enum dwarf_section_display_enum debug
)
10777 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10779 if (section
->start
== NULL
)
10782 free ((char *) section
->start
);
10783 section
->start
= NULL
;
10784 section
->address
= 0;
10789 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10791 char * name
= SECTION_NAME (section
);
10792 bfd_size_type length
;
10796 length
= section
->sh_size
;
10799 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10802 if (section
->sh_type
== SHT_NOBITS
)
10804 /* There is no point in dumping the contents of a debugging section
10805 which has the NOBITS type - the bits in the file will be random.
10806 This can happen when a file containing a .eh_frame section is
10807 stripped with the --only-keep-debug command line option. */
10808 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10812 if (const_strneq (name
, ".gnu.linkonce.wi."))
10813 name
= ".debug_info";
10815 /* See if we know how to display the contents of this section. */
10816 for (i
= 0; i
< max
; i
++)
10817 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10818 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10820 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10821 int secondary
= (section
!= find_section (name
));
10824 free_debug_section ((enum dwarf_section_display_enum
) i
);
10826 if (streq (sec
->uncompressed_name
, name
))
10827 sec
->name
= sec
->uncompressed_name
;
10829 sec
->name
= sec
->compressed_name
;
10830 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10833 /* If this debug section is part of a CU/TU set in a .dwp file,
10834 restrict load_debug_section to the sections in that set. */
10835 section_subset
= find_cu_tu_set (file
, shndx
);
10837 result
&= debug_displays
[i
].display (sec
, file
);
10839 section_subset
= NULL
;
10841 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10842 free_debug_section ((enum dwarf_section_display_enum
) i
);
10850 printf (_("Unrecognized debug section: %s\n"), name
);
10857 /* Set DUMP_SECTS for all sections where dumps were requested
10858 based on section name. */
10861 initialise_dumps_byname (void)
10863 struct dump_list_entry
* cur
;
10865 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10870 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10871 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10873 request_dump_bynumber (i
, cur
->type
);
10878 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10884 process_section_contents (FILE * file
)
10886 Elf_Internal_Shdr
* section
;
10892 initialise_dumps_byname ();
10894 for (i
= 0, section
= section_headers
;
10895 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10898 #ifdef SUPPORT_DISASSEMBLY
10899 if (dump_sects
[i
] & DISASS_DUMP
)
10900 disassemble_section (section
, file
);
10902 if (dump_sects
[i
] & HEX_DUMP
)
10903 dump_section_as_bytes (section
, file
, FALSE
);
10905 if (dump_sects
[i
] & RELOC_DUMP
)
10906 dump_section_as_bytes (section
, file
, TRUE
);
10908 if (dump_sects
[i
] & STRING_DUMP
)
10909 dump_section_as_strings (section
, file
);
10911 if (dump_sects
[i
] & DEBUG_DUMP
)
10912 display_debug_section (i
, section
, file
);
10915 /* Check to see if the user requested a
10916 dump of a section that does not exist. */
10917 while (i
++ < num_dump_sects
)
10919 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10923 process_mips_fpe_exception (int mask
)
10928 if (mask
& OEX_FPU_INEX
)
10929 fputs ("INEX", stdout
), first
= 0;
10930 if (mask
& OEX_FPU_UFLO
)
10931 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10932 if (mask
& OEX_FPU_OFLO
)
10933 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10934 if (mask
& OEX_FPU_DIV0
)
10935 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10936 if (mask
& OEX_FPU_INVAL
)
10937 printf ("%sINVAL", first
? "" : "|");
10940 fputs ("0", stdout
);
10943 /* ARM EABI attributes section. */
10948 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10950 const char ** table
;
10951 } arm_attr_public_tag
;
10953 static const char * arm_attr_tag_CPU_arch
[] =
10954 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10955 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
10956 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10957 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10958 {"No", "Thumb-1", "Thumb-2"};
10959 static const char * arm_attr_tag_FP_arch
[] =
10960 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
10962 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10963 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10964 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
10965 static const char * arm_attr_tag_PCS_config
[] =
10966 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10967 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10968 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10969 {"V6", "SB", "TLS", "Unused"};
10970 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10971 {"Absolute", "PC-relative", "SB-relative", "None"};
10972 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10973 {"Absolute", "PC-relative", "None"};
10974 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10975 {"None", "direct", "GOT-indirect"};
10976 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10977 {"None", "??? 1", "2", "??? 3", "4"};
10978 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10979 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10980 {"Unused", "Needed", "Sign only"};
10981 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10982 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10983 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10984 {"Unused", "Finite", "RTABI", "IEEE 754"};
10985 static const char * arm_attr_tag_ABI_enum_size
[] =
10986 {"Unused", "small", "int", "forced to int"};
10987 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10988 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10989 static const char * arm_attr_tag_ABI_VFP_args
[] =
10990 {"AAPCS", "VFP registers", "custom"};
10991 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10992 {"AAPCS", "WMMX registers", "custom"};
10993 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10994 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10995 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10996 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10997 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10998 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10999 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11000 static const char * arm_attr_tag_FP_HP_extension
[] =
11001 {"Not Allowed", "Allowed"};
11002 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11003 {"None", "IEEE 754", "Alternative Format"};
11004 static const char * arm_attr_tag_MPextension_use
[] =
11005 {"Not Allowed", "Allowed"};
11006 static const char * arm_attr_tag_DIV_use
[] =
11007 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11008 "Allowed in v7-A with integer division extension"};
11009 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11010 static const char * arm_attr_tag_Virtualization_use
[] =
11011 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11012 "TrustZone and Virtualization Extensions"};
11013 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11014 {"Not Allowed", "Allowed"};
11016 #define LOOKUP(id, name) \
11017 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11018 static arm_attr_public_tag arm_attr_public_tags
[] =
11020 {4, "CPU_raw_name", 1, NULL
},
11021 {5, "CPU_name", 1, NULL
},
11022 LOOKUP(6, CPU_arch
),
11023 {7, "CPU_arch_profile", 0, NULL
},
11024 LOOKUP(8, ARM_ISA_use
),
11025 LOOKUP(9, THUMB_ISA_use
),
11026 LOOKUP(10, FP_arch
),
11027 LOOKUP(11, WMMX_arch
),
11028 LOOKUP(12, Advanced_SIMD_arch
),
11029 LOOKUP(13, PCS_config
),
11030 LOOKUP(14, ABI_PCS_R9_use
),
11031 LOOKUP(15, ABI_PCS_RW_data
),
11032 LOOKUP(16, ABI_PCS_RO_data
),
11033 LOOKUP(17, ABI_PCS_GOT_use
),
11034 LOOKUP(18, ABI_PCS_wchar_t
),
11035 LOOKUP(19, ABI_FP_rounding
),
11036 LOOKUP(20, ABI_FP_denormal
),
11037 LOOKUP(21, ABI_FP_exceptions
),
11038 LOOKUP(22, ABI_FP_user_exceptions
),
11039 LOOKUP(23, ABI_FP_number_model
),
11040 {24, "ABI_align_needed", 0, NULL
},
11041 {25, "ABI_align_preserved", 0, NULL
},
11042 LOOKUP(26, ABI_enum_size
),
11043 LOOKUP(27, ABI_HardFP_use
),
11044 LOOKUP(28, ABI_VFP_args
),
11045 LOOKUP(29, ABI_WMMX_args
),
11046 LOOKUP(30, ABI_optimization_goals
),
11047 LOOKUP(31, ABI_FP_optimization_goals
),
11048 {32, "compatibility", 0, NULL
},
11049 LOOKUP(34, CPU_unaligned_access
),
11050 LOOKUP(36, FP_HP_extension
),
11051 LOOKUP(38, ABI_FP_16bit_format
),
11052 LOOKUP(42, MPextension_use
),
11053 LOOKUP(44, DIV_use
),
11054 {64, "nodefaults", 0, NULL
},
11055 {65, "also_compatible_with", 0, NULL
},
11056 LOOKUP(66, T2EE_use
),
11057 {67, "conformance", 1, NULL
},
11058 LOOKUP(68, Virtualization_use
),
11059 LOOKUP(70, MPextension_use_legacy
)
11063 static unsigned char *
11064 display_arm_attribute (unsigned char * p
)
11069 arm_attr_public_tag
* attr
;
11073 tag
= read_uleb128 (p
, &len
);
11076 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11078 if (arm_attr_public_tags
[i
].tag
== tag
)
11080 attr
= &arm_attr_public_tags
[i
];
11087 printf (" Tag_%s: ", attr
->name
);
11088 switch (attr
->type
)
11093 case 7: /* Tag_CPU_arch_profile. */
11094 val
= read_uleb128 (p
, &len
);
11098 case 0: printf (_("None\n")); break;
11099 case 'A': printf (_("Application\n")); break;
11100 case 'R': printf (_("Realtime\n")); break;
11101 case 'M': printf (_("Microcontroller\n")); break;
11102 case 'S': printf (_("Application or Realtime\n")); break;
11103 default: printf ("??? (%d)\n", val
); break;
11107 case 24: /* Tag_align_needed. */
11108 val
= read_uleb128 (p
, &len
);
11112 case 0: printf (_("None\n")); break;
11113 case 1: printf (_("8-byte\n")); break;
11114 case 2: printf (_("4-byte\n")); break;
11115 case 3: printf ("??? 3\n"); break;
11118 printf (_("8-byte and up to %d-byte extended\n"),
11121 printf ("??? (%d)\n", val
);
11126 case 25: /* Tag_align_preserved. */
11127 val
= read_uleb128 (p
, &len
);
11131 case 0: printf (_("None\n")); break;
11132 case 1: printf (_("8-byte, except leaf SP\n")); break;
11133 case 2: printf (_("8-byte\n")); break;
11134 case 3: printf ("??? 3\n"); break;
11137 printf (_("8-byte and up to %d-byte extended\n"),
11140 printf ("??? (%d)\n", val
);
11145 case 32: /* Tag_compatibility. */
11146 val
= read_uleb128 (p
, &len
);
11148 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11149 p
+= strlen ((char *) p
) + 1;
11152 case 64: /* Tag_nodefaults. */
11154 printf (_("True\n"));
11157 case 65: /* Tag_also_compatible_with. */
11158 val
= read_uleb128 (p
, &len
);
11160 if (val
== 6 /* Tag_CPU_arch. */)
11162 val
= read_uleb128 (p
, &len
);
11164 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11165 printf ("??? (%d)\n", val
);
11167 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11171 while (*(p
++) != '\0' /* NUL terminator. */);
11185 assert (attr
->type
& 0x80);
11186 val
= read_uleb128 (p
, &len
);
11188 type
= attr
->type
& 0x7f;
11190 printf ("??? (%d)\n", val
);
11192 printf ("%s\n", attr
->table
[val
]);
11199 type
= 1; /* String. */
11201 type
= 2; /* uleb128. */
11202 printf (" Tag_unknown_%d: ", tag
);
11207 printf ("\"%s\"\n", p
);
11208 p
+= strlen ((char *) p
) + 1;
11212 val
= read_uleb128 (p
, &len
);
11214 printf ("%d (0x%x)\n", val
, val
);
11220 static unsigned char *
11221 display_gnu_attribute (unsigned char * p
,
11222 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11229 tag
= read_uleb128 (p
, &len
);
11232 /* Tag_compatibility is the only generic GNU attribute defined at
11236 val
= read_uleb128 (p
, &len
);
11238 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11239 p
+= strlen ((char *) p
) + 1;
11243 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11244 return display_proc_gnu_attribute (p
, tag
);
11247 type
= 1; /* String. */
11249 type
= 2; /* uleb128. */
11250 printf (" Tag_unknown_%d: ", tag
);
11254 printf ("\"%s\"\n", p
);
11255 p
+= strlen ((char *) p
) + 1;
11259 val
= read_uleb128 (p
, &len
);
11261 printf ("%d (0x%x)\n", val
, val
);
11267 static unsigned char *
11268 display_power_gnu_attribute (unsigned char * p
, int tag
)
11274 if (tag
== Tag_GNU_Power_ABI_FP
)
11276 val
= read_uleb128 (p
, &len
);
11278 printf (" Tag_GNU_Power_ABI_FP: ");
11283 printf (_("Hard or soft float\n"));
11286 printf (_("Hard float\n"));
11289 printf (_("Soft float\n"));
11292 printf (_("Single-precision hard float\n"));
11295 printf ("??? (%d)\n", val
);
11301 if (tag
== Tag_GNU_Power_ABI_Vector
)
11303 val
= read_uleb128 (p
, &len
);
11305 printf (" Tag_GNU_Power_ABI_Vector: ");
11309 printf (_("Any\n"));
11312 printf (_("Generic\n"));
11315 printf ("AltiVec\n");
11321 printf ("??? (%d)\n", val
);
11327 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11329 val
= read_uleb128 (p
, &len
);
11331 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11335 printf (_("Any\n"));
11338 printf ("r3/r4\n");
11341 printf (_("Memory\n"));
11344 printf ("??? (%d)\n", val
);
11351 type
= 1; /* String. */
11353 type
= 2; /* uleb128. */
11354 printf (" Tag_unknown_%d: ", tag
);
11358 printf ("\"%s\"\n", p
);
11359 p
+= strlen ((char *) p
) + 1;
11363 val
= read_uleb128 (p
, &len
);
11365 printf ("%d (0x%x)\n", val
, val
);
11372 display_sparc_hwcaps (int mask
)
11377 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11378 fputs ("mul32", stdout
), first
= 0;
11379 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11380 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11381 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11382 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11383 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11384 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11385 if (mask
& ELF_SPARC_HWCAP_POPC
)
11386 printf ("%spopc", first
? "" : "|"), first
= 0;
11387 if (mask
& ELF_SPARC_HWCAP_VIS
)
11388 printf ("%svis", first
? "" : "|"), first
= 0;
11389 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11390 printf ("%svis2", first
? "" : "|"), first
= 0;
11391 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11392 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11393 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11394 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11395 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11396 printf ("%svis3", first
? "" : "|"), first
= 0;
11397 if (mask
& ELF_SPARC_HWCAP_HPC
)
11398 printf ("%shpc", first
? "" : "|"), first
= 0;
11399 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11400 printf ("%srandom", first
? "" : "|"), first
= 0;
11401 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11402 printf ("%strans", first
? "" : "|"), first
= 0;
11403 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11404 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11405 if (mask
& ELF_SPARC_HWCAP_IMA
)
11406 printf ("%sima", first
? "" : "|"), first
= 0;
11407 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11408 printf ("%scspare", first
? "" : "|"), first
= 0;
11411 fputc('0', stdout
);
11412 fputc('\n', stdout
);
11415 static unsigned char *
11416 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11422 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11424 val
= read_uleb128 (p
, &len
);
11426 printf (" Tag_GNU_Sparc_HWCAPS: ");
11428 display_sparc_hwcaps (val
);
11433 type
= 1; /* String. */
11435 type
= 2; /* uleb128. */
11436 printf (" Tag_unknown_%d: ", tag
);
11440 printf ("\"%s\"\n", p
);
11441 p
+= strlen ((char *) p
) + 1;
11445 val
= read_uleb128 (p
, &len
);
11447 printf ("%d (0x%x)\n", val
, val
);
11453 static unsigned char *
11454 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11460 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11462 val
= read_uleb128 (p
, &len
);
11464 printf (" Tag_GNU_MIPS_ABI_FP: ");
11469 printf (_("Hard or soft float\n"));
11472 printf (_("Hard float (double precision)\n"));
11475 printf (_("Hard float (single precision)\n"));
11478 printf (_("Soft float\n"));
11481 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11484 printf ("??? (%d)\n", val
);
11491 type
= 1; /* String. */
11493 type
= 2; /* uleb128. */
11494 printf (" Tag_unknown_%d: ", tag
);
11498 printf ("\"%s\"\n", p
);
11499 p
+= strlen ((char *) p
) + 1;
11503 val
= read_uleb128 (p
, &len
);
11505 printf ("%d (0x%x)\n", val
, val
);
11511 static unsigned char *
11512 display_tic6x_attribute (unsigned char * p
)
11518 tag
= read_uleb128 (p
, &len
);
11524 val
= read_uleb128 (p
, &len
);
11526 printf (" Tag_ISA: ");
11530 case C6XABI_Tag_ISA_none
:
11531 printf (_("None\n"));
11533 case C6XABI_Tag_ISA_C62X
:
11536 case C6XABI_Tag_ISA_C67X
:
11539 case C6XABI_Tag_ISA_C67XP
:
11540 printf ("C67x+\n");
11542 case C6XABI_Tag_ISA_C64X
:
11545 case C6XABI_Tag_ISA_C64XP
:
11546 printf ("C64x+\n");
11548 case C6XABI_Tag_ISA_C674X
:
11549 printf ("C674x\n");
11552 printf ("??? (%d)\n", val
);
11557 case Tag_ABI_wchar_t
:
11558 val
= read_uleb128 (p
, &len
);
11560 printf (" Tag_ABI_wchar_t: ");
11564 printf (_("Not used\n"));
11567 printf (_("2 bytes\n"));
11570 printf (_("4 bytes\n"));
11573 printf ("??? (%d)\n", val
);
11578 case Tag_ABI_stack_align_needed
:
11579 val
= read_uleb128 (p
, &len
);
11581 printf (" Tag_ABI_stack_align_needed: ");
11585 printf (_("8-byte\n"));
11588 printf (_("16-byte\n"));
11591 printf ("??? (%d)\n", val
);
11596 case Tag_ABI_stack_align_preserved
:
11597 val
= read_uleb128 (p
, &len
);
11599 printf (" Tag_ABI_stack_align_preserved: ");
11603 printf (_("8-byte\n"));
11606 printf (_("16-byte\n"));
11609 printf ("??? (%d)\n", val
);
11615 val
= read_uleb128 (p
, &len
);
11617 printf (" Tag_ABI_DSBT: ");
11621 printf (_("DSBT addressing not used\n"));
11624 printf (_("DSBT addressing used\n"));
11627 printf ("??? (%d)\n", val
);
11633 val
= read_uleb128 (p
, &len
);
11635 printf (" Tag_ABI_PID: ");
11639 printf (_("Data addressing position-dependent\n"));
11642 printf (_("Data addressing position-independent, GOT near DP\n"));
11645 printf (_("Data addressing position-independent, GOT far from DP\n"));
11648 printf ("??? (%d)\n", val
);
11654 val
= read_uleb128 (p
, &len
);
11656 printf (" Tag_ABI_PIC: ");
11660 printf (_("Code addressing position-dependent\n"));
11663 printf (_("Code addressing position-independent\n"));
11666 printf ("??? (%d)\n", val
);
11671 case Tag_ABI_array_object_alignment
:
11672 val
= read_uleb128 (p
, &len
);
11674 printf (" Tag_ABI_array_object_alignment: ");
11678 printf (_("8-byte\n"));
11681 printf (_("4-byte\n"));
11684 printf (_("16-byte\n"));
11687 printf ("??? (%d)\n", val
);
11692 case Tag_ABI_array_object_align_expected
:
11693 val
= read_uleb128 (p
, &len
);
11695 printf (" Tag_ABI_array_object_align_expected: ");
11699 printf (_("8-byte\n"));
11702 printf (_("4-byte\n"));
11705 printf (_("16-byte\n"));
11708 printf ("??? (%d)\n", val
);
11713 case Tag_ABI_compatibility
:
11714 val
= read_uleb128 (p
, &len
);
11716 printf (" Tag_ABI_compatibility: ");
11717 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11718 p
+= strlen ((char *) p
) + 1;
11721 case Tag_ABI_conformance
:
11722 printf (" Tag_ABI_conformance: ");
11723 printf ("\"%s\"\n", p
);
11724 p
+= strlen ((char *) p
) + 1;
11728 printf (" Tag_unknown_%d: ", tag
);
11732 printf ("\"%s\"\n", p
);
11733 p
+= strlen ((char *) p
) + 1;
11737 val
= read_uleb128 (p
, &len
);
11739 printf ("%d (0x%x)\n", val
, val
);
11746 process_attributes (FILE * file
,
11747 const char * public_name
,
11748 unsigned int proc_type
,
11749 unsigned char * (* display_pub_attribute
) (unsigned char *),
11750 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11752 Elf_Internal_Shdr
* sect
;
11753 unsigned char * contents
;
11755 unsigned char * end
;
11756 bfd_vma section_len
;
11760 /* Find the section header so that we get the size. */
11761 for (i
= 0, sect
= section_headers
;
11762 i
< elf_header
.e_shnum
;
11765 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11768 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11769 sect
->sh_size
, _("attributes"));
11770 if (contents
== NULL
)
11776 len
= sect
->sh_size
- 1;
11782 bfd_boolean public_section
;
11783 bfd_boolean gnu_section
;
11785 section_len
= byte_get (p
, 4);
11788 if (section_len
> len
)
11790 printf (_("ERROR: Bad section length (%d > %d)\n"),
11791 (int) section_len
, (int) len
);
11795 len
-= section_len
;
11796 printf (_("Attribute Section: %s\n"), p
);
11798 if (public_name
&& streq ((char *) p
, public_name
))
11799 public_section
= TRUE
;
11801 public_section
= FALSE
;
11803 if (streq ((char *) p
, "gnu"))
11804 gnu_section
= TRUE
;
11806 gnu_section
= FALSE
;
11808 namelen
= strlen ((char *) p
) + 1;
11810 section_len
-= namelen
+ 4;
11812 while (section_len
> 0)
11818 size
= byte_get (p
, 4);
11819 if (size
> section_len
)
11821 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11822 (int) size
, (int) section_len
);
11823 size
= section_len
;
11826 section_len
-= size
;
11827 end
= p
+ size
- 1;
11833 printf (_("File Attributes\n"));
11836 printf (_("Section Attributes:"));
11839 printf (_("Symbol Attributes:"));
11845 val
= read_uleb128 (p
, &j
);
11849 printf (" %d", val
);
11854 printf (_("Unknown tag: %d\n"), tag
);
11855 public_section
= FALSE
;
11859 if (public_section
)
11862 p
= display_pub_attribute (p
);
11864 else if (gnu_section
)
11867 p
= display_gnu_attribute (p
,
11868 display_proc_gnu_attribute
);
11872 /* ??? Do something sensible, like dump hex. */
11873 printf (_(" Unknown section contexts\n"));
11880 printf (_("Unknown format '%c'\n"), *p
);
11888 process_arm_specific (FILE * file
)
11890 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
11891 display_arm_attribute
, NULL
);
11895 process_power_specific (FILE * file
)
11897 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11898 display_power_gnu_attribute
);
11902 process_sparc_specific (FILE * file
)
11904 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11905 display_sparc_gnu_attribute
);
11909 process_tic6x_specific (FILE * file
)
11911 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
11912 display_tic6x_attribute
, NULL
);
11915 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11916 Print the Address, Access and Initial fields of an entry at VMA ADDR
11917 and return the VMA of the next entry. */
11920 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11923 print_vma (addr
, LONG_HEX
);
11925 if (addr
< pltgot
+ 0xfff0)
11926 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
11928 printf ("%10s", "");
11931 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11936 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11937 print_vma (entry
, LONG_HEX
);
11939 return addr
+ (is_32bit_elf
? 4 : 8);
11942 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11943 PLTGOT. Print the Address and Initial fields of an entry at VMA
11944 ADDR and return the VMA of the next entry. */
11947 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11950 print_vma (addr
, LONG_HEX
);
11953 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11958 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11959 print_vma (entry
, LONG_HEX
);
11961 return addr
+ (is_32bit_elf
? 4 : 8);
11965 process_mips_specific (FILE * file
)
11967 Elf_Internal_Dyn
* entry
;
11968 size_t liblist_offset
= 0;
11969 size_t liblistno
= 0;
11970 size_t conflictsno
= 0;
11971 size_t options_offset
= 0;
11972 size_t conflicts_offset
= 0;
11973 size_t pltrelsz
= 0;
11975 bfd_vma pltgot
= 0;
11976 bfd_vma mips_pltgot
= 0;
11977 bfd_vma jmprel
= 0;
11978 bfd_vma local_gotno
= 0;
11979 bfd_vma gotsym
= 0;
11980 bfd_vma symtabno
= 0;
11982 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11983 display_mips_gnu_attribute
);
11985 /* We have a lot of special sections. Thanks SGI! */
11986 if (dynamic_section
== NULL
)
11987 /* No information available. */
11990 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11991 switch (entry
->d_tag
)
11993 case DT_MIPS_LIBLIST
:
11995 = offset_from_vma (file
, entry
->d_un
.d_val
,
11996 liblistno
* sizeof (Elf32_External_Lib
));
11998 case DT_MIPS_LIBLISTNO
:
11999 liblistno
= entry
->d_un
.d_val
;
12001 case DT_MIPS_OPTIONS
:
12002 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12004 case DT_MIPS_CONFLICT
:
12006 = offset_from_vma (file
, entry
->d_un
.d_val
,
12007 conflictsno
* sizeof (Elf32_External_Conflict
));
12009 case DT_MIPS_CONFLICTNO
:
12010 conflictsno
= entry
->d_un
.d_val
;
12013 pltgot
= entry
->d_un
.d_ptr
;
12015 case DT_MIPS_LOCAL_GOTNO
:
12016 local_gotno
= entry
->d_un
.d_val
;
12018 case DT_MIPS_GOTSYM
:
12019 gotsym
= entry
->d_un
.d_val
;
12021 case DT_MIPS_SYMTABNO
:
12022 symtabno
= entry
->d_un
.d_val
;
12024 case DT_MIPS_PLTGOT
:
12025 mips_pltgot
= entry
->d_un
.d_ptr
;
12028 pltrel
= entry
->d_un
.d_val
;
12031 pltrelsz
= entry
->d_un
.d_val
;
12034 jmprel
= entry
->d_un
.d_ptr
;
12040 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12042 Elf32_External_Lib
* elib
;
12045 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12047 sizeof (Elf32_External_Lib
),
12048 _("liblist section data"));
12051 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12052 (unsigned long) liblistno
);
12053 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12056 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12063 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12064 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12065 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12066 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12067 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12069 tmp
= gmtime (&atime
);
12070 snprintf (timebuf
, sizeof (timebuf
),
12071 "%04u-%02u-%02uT%02u:%02u:%02u",
12072 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12073 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12075 printf ("%3lu: ", (unsigned long) cnt
);
12076 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12077 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12079 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12080 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12081 liblist
.l_version
);
12083 if (liblist
.l_flags
== 0)
12087 static const struct
12094 { " EXACT_MATCH", LL_EXACT_MATCH
},
12095 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12096 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12097 { " EXPORTS", LL_EXPORTS
},
12098 { " DELAY_LOAD", LL_DELAY_LOAD
},
12099 { " DELTA", LL_DELTA
}
12101 int flags
= liblist
.l_flags
;
12104 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12105 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12107 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12108 flags
^= l_flags_vals
[fcnt
].bit
;
12111 printf (" %#x", (unsigned int) flags
);
12121 if (options_offset
!= 0)
12123 Elf_External_Options
* eopt
;
12124 Elf_Internal_Shdr
* sect
= section_headers
;
12125 Elf_Internal_Options
* iopt
;
12126 Elf_Internal_Options
* option
;
12130 /* Find the section header so that we get the size. */
12131 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12134 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12135 sect
->sh_size
, _("options"));
12138 iopt
= (Elf_Internal_Options
*)
12139 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12142 error (_("Out of memory\n"));
12149 while (offset
< sect
->sh_size
)
12151 Elf_External_Options
* eoption
;
12153 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12155 option
->kind
= BYTE_GET (eoption
->kind
);
12156 option
->size
= BYTE_GET (eoption
->size
);
12157 option
->section
= BYTE_GET (eoption
->section
);
12158 option
->info
= BYTE_GET (eoption
->info
);
12160 offset
+= option
->size
;
12166 printf (_("\nSection '%s' contains %d entries:\n"),
12167 SECTION_NAME (sect
), cnt
);
12175 switch (option
->kind
)
12178 /* This shouldn't happen. */
12179 printf (" NULL %d %lx", option
->section
, option
->info
);
12182 printf (" REGINFO ");
12183 if (elf_header
.e_machine
== EM_MIPS
)
12186 Elf32_External_RegInfo
* ereg
;
12187 Elf32_RegInfo reginfo
;
12189 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12190 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12191 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12192 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12193 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12194 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12195 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12197 printf ("GPR %08lx GP 0x%lx\n",
12198 reginfo
.ri_gprmask
,
12199 (unsigned long) reginfo
.ri_gp_value
);
12200 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12201 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12202 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12207 Elf64_External_RegInfo
* ereg
;
12208 Elf64_Internal_RegInfo reginfo
;
12210 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12211 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12212 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12213 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12214 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12215 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12216 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12218 printf ("GPR %08lx GP 0x",
12219 reginfo
.ri_gprmask
);
12220 printf_vma (reginfo
.ri_gp_value
);
12223 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12224 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12225 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12229 case ODK_EXCEPTIONS
:
12230 fputs (" EXCEPTIONS fpe_min(", stdout
);
12231 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12232 fputs (") fpe_max(", stdout
);
12233 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12234 fputs (")", stdout
);
12236 if (option
->info
& OEX_PAGE0
)
12237 fputs (" PAGE0", stdout
);
12238 if (option
->info
& OEX_SMM
)
12239 fputs (" SMM", stdout
);
12240 if (option
->info
& OEX_FPDBUG
)
12241 fputs (" FPDBUG", stdout
);
12242 if (option
->info
& OEX_DISMISS
)
12243 fputs (" DISMISS", stdout
);
12246 fputs (" PAD ", stdout
);
12247 if (option
->info
& OPAD_PREFIX
)
12248 fputs (" PREFIX", stdout
);
12249 if (option
->info
& OPAD_POSTFIX
)
12250 fputs (" POSTFIX", stdout
);
12251 if (option
->info
& OPAD_SYMBOL
)
12252 fputs (" SYMBOL", stdout
);
12255 fputs (" HWPATCH ", stdout
);
12256 if (option
->info
& OHW_R4KEOP
)
12257 fputs (" R4KEOP", stdout
);
12258 if (option
->info
& OHW_R8KPFETCH
)
12259 fputs (" R8KPFETCH", stdout
);
12260 if (option
->info
& OHW_R5KEOP
)
12261 fputs (" R5KEOP", stdout
);
12262 if (option
->info
& OHW_R5KCVTL
)
12263 fputs (" R5KCVTL", stdout
);
12266 fputs (" FILL ", stdout
);
12267 /* XXX Print content of info word? */
12270 fputs (" TAGS ", stdout
);
12271 /* XXX Print content of info word? */
12274 fputs (" HWAND ", stdout
);
12275 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12276 fputs (" R4KEOP_CHECKED", stdout
);
12277 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12278 fputs (" R4KEOP_CLEAN", stdout
);
12281 fputs (" HWOR ", stdout
);
12282 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12283 fputs (" R4KEOP_CHECKED", stdout
);
12284 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12285 fputs (" R4KEOP_CLEAN", stdout
);
12288 printf (" GP_GROUP %#06lx self-contained %#06lx",
12289 option
->info
& OGP_GROUP
,
12290 (option
->info
& OGP_SELF
) >> 16);
12293 printf (" IDENT %#06lx self-contained %#06lx",
12294 option
->info
& OGP_GROUP
,
12295 (option
->info
& OGP_SELF
) >> 16);
12298 /* This shouldn't happen. */
12299 printf (" %3d ??? %d %lx",
12300 option
->kind
, option
->section
, option
->info
);
12304 len
= sizeof (* eopt
);
12305 while (len
< option
->size
)
12306 if (((char *) option
)[len
] >= ' '
12307 && ((char *) option
)[len
] < 0x7f)
12308 printf ("%c", ((char *) option
)[len
++]);
12310 printf ("\\%03o", ((char *) option
)[len
++]);
12312 fputs ("\n", stdout
);
12320 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12322 Elf32_Conflict
* iconf
;
12325 if (dynamic_symbols
== NULL
)
12327 error (_("conflict list found without a dynamic symbol table\n"));
12331 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12334 error (_("Out of memory\n"));
12340 Elf32_External_Conflict
* econf32
;
12342 econf32
= (Elf32_External_Conflict
*)
12343 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12344 sizeof (* econf32
), _("conflict"));
12348 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12349 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12355 Elf64_External_Conflict
* econf64
;
12357 econf64
= (Elf64_External_Conflict
*)
12358 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12359 sizeof (* econf64
), _("conflict"));
12363 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12364 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12369 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12370 (unsigned long) conflictsno
);
12371 puts (_(" Num: Index Value Name"));
12373 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12375 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12377 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12378 print_vma (psym
->st_value
, FULL_HEX
);
12380 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12381 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12383 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12390 if (pltgot
!= 0 && local_gotno
!= 0)
12392 bfd_vma ent
, local_end
, global_end
;
12394 unsigned char * data
;
12398 addr_size
= (is_32bit_elf
? 4 : 8);
12399 local_end
= pltgot
+ local_gotno
* addr_size
;
12400 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12402 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12403 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12404 global_end
- pltgot
, 1,
12405 _("Global Offset Table data"));
12409 printf (_("\nPrimary GOT:\n"));
12410 printf (_(" Canonical gp value: "));
12411 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12414 printf (_(" Reserved entries:\n"));
12415 printf (_(" %*s %10s %*s Purpose\n"),
12416 addr_size
* 2, _("Address"), _("Access"),
12417 addr_size
* 2, _("Initial"));
12418 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12419 printf (_(" Lazy resolver\n"));
12421 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12422 >> (addr_size
* 8 - 1)) != 0)
12424 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12425 printf (_(" Module pointer (GNU extension)\n"));
12429 if (ent
< local_end
)
12431 printf (_(" Local entries:\n"));
12432 printf (" %*s %10s %*s\n",
12433 addr_size
* 2, _("Address"), _("Access"),
12434 addr_size
* 2, _("Initial"));
12435 while (ent
< local_end
)
12437 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12443 if (gotsym
< symtabno
)
12447 printf (_(" Global entries:\n"));
12448 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12449 addr_size
* 2, _("Address"),
12451 addr_size
* 2, _("Initial"),
12452 addr_size
* 2, _("Sym.Val."),
12454 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12455 _("Ndx"), _("Name"));
12457 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12458 for (i
= gotsym
; i
< symtabno
; i
++)
12460 Elf_Internal_Sym
* psym
;
12462 psym
= dynamic_symbols
+ i
;
12463 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12465 print_vma (psym
->st_value
, LONG_HEX
);
12466 printf (" %-7s %3s ",
12467 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12468 get_symbol_index_type (psym
->st_shndx
));
12469 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12470 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12472 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12482 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12485 size_t offset
, rel_offset
;
12486 unsigned long count
, i
;
12487 unsigned char * data
;
12488 int addr_size
, sym_width
;
12489 Elf_Internal_Rela
* rels
;
12491 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12492 if (pltrel
== DT_RELA
)
12494 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12499 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12504 addr_size
= (is_32bit_elf
? 4 : 8);
12505 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12507 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12508 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12509 1, _("Procedure Linkage Table data"));
12513 printf ("\nPLT GOT:\n\n");
12514 printf (_(" Reserved entries:\n"));
12515 printf (_(" %*s %*s Purpose\n"),
12516 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12517 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12518 printf (_(" PLT lazy resolver\n"));
12519 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12520 printf (_(" Module pointer\n"));
12523 printf (_(" Entries:\n"));
12524 printf (" %*s %*s %*s %-7s %3s %s\n",
12525 addr_size
* 2, _("Address"),
12526 addr_size
* 2, _("Initial"),
12527 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12528 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12529 for (i
= 0; i
< count
; i
++)
12531 Elf_Internal_Sym
* psym
;
12533 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12534 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12536 print_vma (psym
->st_value
, LONG_HEX
);
12537 printf (" %-7s %3s ",
12538 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12539 get_symbol_index_type (psym
->st_shndx
));
12540 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12541 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12543 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12557 process_gnu_liblist (FILE * file
)
12559 Elf_Internal_Shdr
* section
;
12560 Elf_Internal_Shdr
* string_sec
;
12561 Elf32_External_Lib
* elib
;
12563 size_t strtab_size
;
12570 for (i
= 0, section
= section_headers
;
12571 i
< elf_header
.e_shnum
;
12574 switch (section
->sh_type
)
12576 case SHT_GNU_LIBLIST
:
12577 if (section
->sh_link
>= elf_header
.e_shnum
)
12580 elib
= (Elf32_External_Lib
*)
12581 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12582 _("liblist section data"));
12586 string_sec
= section_headers
+ section
->sh_link
;
12588 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12589 string_sec
->sh_size
,
12590 _("liblist string table"));
12592 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12598 strtab_size
= string_sec
->sh_size
;
12600 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12601 SECTION_NAME (section
),
12602 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12604 puts (_(" Library Time Stamp Checksum Version Flags"));
12606 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12614 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12615 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12616 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12617 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12618 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12620 tmp
= gmtime (&atime
);
12621 snprintf (timebuf
, sizeof (timebuf
),
12622 "%04u-%02u-%02uT%02u:%02u:%02u",
12623 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12624 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12626 printf ("%3lu: ", (unsigned long) cnt
);
12628 printf ("%-20s", liblist
.l_name
< strtab_size
12629 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12631 printf ("%-20.20s", liblist
.l_name
< strtab_size
12632 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12633 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12634 liblist
.l_version
, liblist
.l_flags
);
12645 static const char *
12646 get_note_type (unsigned e_type
)
12648 static char buff
[64];
12650 if (elf_header
.e_type
== ET_CORE
)
12654 return _("NT_AUXV (auxiliary vector)");
12656 return _("NT_PRSTATUS (prstatus structure)");
12658 return _("NT_FPREGSET (floating point registers)");
12660 return _("NT_PRPSINFO (prpsinfo structure)");
12661 case NT_TASKSTRUCT
:
12662 return _("NT_TASKSTRUCT (task structure)");
12664 return _("NT_PRXFPREG (user_xfpregs structure)");
12666 return _("NT_PPC_VMX (ppc Altivec registers)");
12668 return _("NT_PPC_VSX (ppc VSX registers)");
12669 case NT_X86_XSTATE
:
12670 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12671 case NT_S390_HIGH_GPRS
:
12672 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12673 case NT_S390_TIMER
:
12674 return _("NT_S390_TIMER (s390 timer register)");
12675 case NT_S390_TODCMP
:
12676 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12677 case NT_S390_TODPREG
:
12678 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12680 return _("NT_S390_CTRS (s390 control registers)");
12681 case NT_S390_PREFIX
:
12682 return _("NT_S390_PREFIX (s390 prefix register)");
12684 return _("NT_ARM_VFP (arm VFP registers)");
12686 return _("NT_PSTATUS (pstatus structure)");
12688 return _("NT_FPREGS (floating point registers)");
12690 return _("NT_PSINFO (psinfo structure)");
12692 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12694 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12695 case NT_WIN32PSTATUS
:
12696 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12698 return _("NT_SIGINFO (siginfo_t data)");
12700 return _("NT_FILE (mapped files)");
12708 return _("NT_VERSION (version)");
12710 return _("NT_ARCH (architecture)");
12715 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12720 print_core_note (Elf_Internal_Note
*pnote
)
12722 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12723 bfd_vma count
, page_size
;
12724 unsigned char *descdata
, *filenames
, *descend
;
12726 if (pnote
->type
!= NT_FILE
)
12732 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12733 /* Still "successful". */
12738 if (pnote
->descsz
< 2 * addr_size
)
12740 printf (_(" Malformed note - too short for header\n"));
12744 descdata
= (unsigned char *) pnote
->descdata
;
12745 descend
= descdata
+ pnote
->descsz
;
12747 if (descdata
[pnote
->descsz
- 1] != '\0')
12749 printf (_(" Malformed note - does not end with \\0\n"));
12753 count
= byte_get (descdata
, addr_size
);
12754 descdata
+= addr_size
;
12756 page_size
= byte_get (descdata
, addr_size
);
12757 descdata
+= addr_size
;
12759 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12761 printf (_(" Malformed note - too short for supplied file count\n"));
12765 printf (_(" Page size: "));
12766 print_vma (page_size
, DEC
);
12769 printf (_(" %*s%*s%*s\n"),
12770 (int) (2 + 2 * addr_size
), _("Start"),
12771 (int) (4 + 2 * addr_size
), _("End"),
12772 (int) (4 + 2 * addr_size
), _("Page Offset"));
12773 filenames
= descdata
+ count
* 3 * addr_size
;
12774 while (--count
> 0)
12776 bfd_vma start
, end
, file_ofs
;
12778 if (filenames
== descend
)
12780 printf (_(" Malformed note - filenames end too early\n"));
12784 start
= byte_get (descdata
, addr_size
);
12785 descdata
+= addr_size
;
12786 end
= byte_get (descdata
, addr_size
);
12787 descdata
+= addr_size
;
12788 file_ofs
= byte_get (descdata
, addr_size
);
12789 descdata
+= addr_size
;
12792 print_vma (start
, FULL_HEX
);
12794 print_vma (end
, FULL_HEX
);
12796 print_vma (file_ofs
, FULL_HEX
);
12797 printf ("\n %s\n", filenames
);
12799 filenames
+= 1 + strlen ((char *) filenames
);
12805 static const char *
12806 get_gnu_elf_note_type (unsigned e_type
)
12808 static char buff
[64];
12812 case NT_GNU_ABI_TAG
:
12813 return _("NT_GNU_ABI_TAG (ABI version tag)");
12815 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12816 case NT_GNU_BUILD_ID
:
12817 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12818 case NT_GNU_GOLD_VERSION
:
12819 return _("NT_GNU_GOLD_VERSION (gold version)");
12824 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12829 print_gnu_note (Elf_Internal_Note
*pnote
)
12831 switch (pnote
->type
)
12833 case NT_GNU_BUILD_ID
:
12837 printf (_(" Build ID: "));
12838 for (i
= 0; i
< pnote
->descsz
; ++i
)
12839 printf ("%02x", pnote
->descdata
[i
] & 0xff);
12844 case NT_GNU_ABI_TAG
:
12846 unsigned long os
, major
, minor
, subminor
;
12847 const char *osname
;
12849 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
12850 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
12851 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
12852 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
12856 case GNU_ABI_TAG_LINUX
:
12859 case GNU_ABI_TAG_HURD
:
12862 case GNU_ABI_TAG_SOLARIS
:
12863 osname
= "Solaris";
12865 case GNU_ABI_TAG_FREEBSD
:
12866 osname
= "FreeBSD";
12868 case GNU_ABI_TAG_NETBSD
:
12872 osname
= "Unknown";
12876 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
12877 major
, minor
, subminor
);
12885 static const char *
12886 get_netbsd_elfcore_note_type (unsigned e_type
)
12888 static char buff
[64];
12890 if (e_type
== NT_NETBSDCORE_PROCINFO
)
12892 /* NetBSD core "procinfo" structure. */
12893 return _("NetBSD procinfo structure");
12896 /* As of Jan 2002 there are no other machine-independent notes
12897 defined for NetBSD core files. If the note type is less
12898 than the start of the machine-dependent note types, we don't
12901 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
12903 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12907 switch (elf_header
.e_machine
)
12909 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12910 and PT_GETFPREGS == mach+2. */
12915 case EM_SPARC32PLUS
:
12919 case NT_NETBSDCORE_FIRSTMACH
+ 0:
12920 return _("PT_GETREGS (reg structure)");
12921 case NT_NETBSDCORE_FIRSTMACH
+ 2:
12922 return _("PT_GETFPREGS (fpreg structure)");
12928 /* On all other arch's, PT_GETREGS == mach+1 and
12929 PT_GETFPREGS == mach+3. */
12933 case NT_NETBSDCORE_FIRSTMACH
+ 1:
12934 return _("PT_GETREGS (reg structure)");
12935 case NT_NETBSDCORE_FIRSTMACH
+ 3:
12936 return _("PT_GETFPREGS (fpreg structure)");
12942 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
12943 e_type
- NT_NETBSDCORE_FIRSTMACH
);
12947 static const char *
12948 get_stapsdt_note_type (unsigned e_type
)
12950 static char buff
[64];
12955 return _("NT_STAPSDT (SystemTap probe descriptors)");
12961 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12966 print_stapsdt_note (Elf_Internal_Note
*pnote
)
12968 int addr_size
= is_32bit_elf
? 4 : 8;
12969 char *data
= pnote
->descdata
;
12970 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
12971 bfd_vma pc
, base_addr
, semaphore
;
12972 char *provider
, *probe
, *arg_fmt
;
12974 pc
= byte_get ((unsigned char *) data
, addr_size
);
12976 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
12978 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
12982 data
+= strlen (data
) + 1;
12984 data
+= strlen (data
) + 1;
12986 data
+= strlen (data
) + 1;
12988 printf (_(" Provider: %s\n"), provider
);
12989 printf (_(" Name: %s\n"), probe
);
12990 printf (_(" Location: "));
12991 print_vma (pc
, FULL_HEX
);
12992 printf (_(", Base: "));
12993 print_vma (base_addr
, FULL_HEX
);
12994 printf (_(", Semaphore: "));
12995 print_vma (semaphore
, FULL_HEX
);
12997 printf (_(" Arguments: %s\n"), arg_fmt
);
12999 return data
== data_end
;
13002 static const char *
13003 get_ia64_vms_note_type (unsigned e_type
)
13005 static char buff
[64];
13010 return _("NT_VMS_MHD (module header)");
13012 return _("NT_VMS_LNM (language name)");
13014 return _("NT_VMS_SRC (source files)");
13016 return "NT_VMS_TITLE";
13018 return _("NT_VMS_EIDC (consistency check)");
13019 case NT_VMS_FPMODE
:
13020 return _("NT_VMS_FPMODE (FP mode)");
13021 case NT_VMS_LINKTIME
:
13022 return "NT_VMS_LINKTIME";
13023 case NT_VMS_IMGNAM
:
13024 return _("NT_VMS_IMGNAM (image name)");
13026 return _("NT_VMS_IMGID (image id)");
13027 case NT_VMS_LINKID
:
13028 return _("NT_VMS_LINKID (link id)");
13029 case NT_VMS_IMGBID
:
13030 return _("NT_VMS_IMGBID (build id)");
13031 case NT_VMS_GSTNAM
:
13032 return _("NT_VMS_GSTNAM (sym table name)");
13033 case NT_VMS_ORIG_DYN
:
13034 return "NT_VMS_ORIG_DYN";
13035 case NT_VMS_PATCHTIME
:
13036 return "NT_VMS_PATCHTIME";
13038 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13044 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13046 switch (pnote
->type
)
13049 if (pnote
->descsz
> 36)
13051 size_t l
= strlen (pnote
->descdata
+ 34);
13052 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13053 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13054 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13055 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13058 printf (_(" Invalid size\n"));
13061 printf (_(" Language: %s\n"), pnote
->descdata
);
13064 case NT_VMS_FPMODE
:
13065 printf (_(" Floating Point mode: "));
13066 printf ("0x%016" BFD_VMA_FMT
"x\n",
13067 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13069 case NT_VMS_LINKTIME
:
13070 printf (_(" Link time: "));
13072 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13075 case NT_VMS_PATCHTIME
:
13076 printf (_(" Patch time: "));
13078 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13081 case NT_VMS_ORIG_DYN
:
13082 printf (_(" Major id: %u, minor id: %u\n"),
13083 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13084 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13085 printf (_(" Last modified : "));
13087 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13088 printf (_("\n Link flags : "));
13089 printf ("0x%016" BFD_VMA_FMT
"x\n",
13090 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13091 printf (_(" Header flags: 0x%08x\n"),
13092 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13093 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13096 case NT_VMS_IMGNAM
:
13097 printf (_(" Image name: %s\n"), pnote
->descdata
);
13099 case NT_VMS_GSTNAM
:
13100 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13103 printf (_(" Image id: %s\n"), pnote
->descdata
);
13105 case NT_VMS_LINKID
:
13106 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13114 /* Note that by the ELF standard, the name field is already null byte
13115 terminated, and namesz includes the terminating null byte.
13116 I.E. the value of namesz for the name "FSF" is 4.
13118 If the value of namesz is zero, there is no name present. */
13120 process_note (Elf_Internal_Note
* pnote
)
13122 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13125 if (pnote
->namesz
== 0)
13126 /* If there is no note name, then use the default set of
13127 note type strings. */
13128 nt
= get_note_type (pnote
->type
);
13130 else if (const_strneq (pnote
->namedata
, "GNU"))
13131 /* GNU-specific object file notes. */
13132 nt
= get_gnu_elf_note_type (pnote
->type
);
13134 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13135 /* NetBSD-specific core file notes. */
13136 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13138 else if (strneq (pnote
->namedata
, "SPU/", 4))
13140 /* SPU-specific core file notes. */
13141 nt
= pnote
->namedata
+ 4;
13145 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13146 /* VMS/ia64-specific file notes. */
13147 nt
= get_ia64_vms_note_type (pnote
->type
);
13149 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13150 nt
= get_stapsdt_note_type (pnote
->type
);
13153 /* Don't recognize this note name; just use the default set of
13154 note type strings. */
13155 nt
= get_note_type (pnote
->type
);
13157 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13159 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13160 return print_ia64_vms_note (pnote
);
13161 else if (const_strneq (pnote
->namedata
, "GNU"))
13162 return print_gnu_note (pnote
);
13163 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13164 return print_stapsdt_note (pnote
);
13165 else if (const_strneq (pnote
->namedata
, "CORE"))
13166 return print_core_note (pnote
);
13173 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13175 Elf_External_Note
* pnotes
;
13176 Elf_External_Note
* external
;
13182 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13184 if (pnotes
== NULL
)
13189 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13190 (unsigned long) offset
, (unsigned long) length
);
13191 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13193 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13195 Elf_External_Note
* next
;
13196 Elf_Internal_Note inote
;
13197 char * temp
= NULL
;
13199 if (!is_ia64_vms ())
13201 inote
.type
= BYTE_GET (external
->type
);
13202 inote
.namesz
= BYTE_GET (external
->namesz
);
13203 inote
.namedata
= external
->name
;
13204 inote
.descsz
= BYTE_GET (external
->descsz
);
13205 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13206 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13208 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13212 Elf64_External_VMS_Note
*vms_external
;
13214 vms_external
= (Elf64_External_VMS_Note
*)external
;
13215 inote
.type
= BYTE_GET (vms_external
->type
);
13216 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13217 inote
.namedata
= vms_external
->name
;
13218 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13219 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13220 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13222 next
= (Elf_External_Note
*)
13223 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13226 if ( ((char *) next
> ((char *) pnotes
) + length
)
13227 || ((char *) next
< (char *) pnotes
))
13229 warn (_("corrupt note found at offset %lx into core notes\n"),
13230 (unsigned long) ((char *) external
- (char *) pnotes
));
13231 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13232 inote
.type
, inote
.namesz
, inote
.descsz
);
13238 /* Prevent out-of-bounds indexing. */
13239 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13240 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13242 warn (_("corrupt note found at offset %lx into core notes\n"),
13243 (unsigned long) ((char *) external
- (char *) pnotes
));
13244 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13245 inote
.type
, inote
.namesz
, inote
.descsz
);
13249 /* Verify that name is null terminated. It appears that at least
13250 one version of Linux (RedHat 6.0) generates corefiles that don't
13251 comply with the ELF spec by failing to include the null byte in
13253 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13255 temp
= (char *) malloc (inote
.namesz
+ 1);
13259 error (_("Out of memory\n"));
13264 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13265 temp
[inote
.namesz
] = 0;
13267 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13268 inote
.namedata
= temp
;
13271 res
&= process_note (& inote
);
13286 process_corefile_note_segments (FILE * file
)
13288 Elf_Internal_Phdr
* segment
;
13292 if (! get_program_headers (file
))
13295 for (i
= 0, segment
= program_headers
;
13296 i
< elf_header
.e_phnum
;
13299 if (segment
->p_type
== PT_NOTE
)
13300 res
&= process_corefile_note_segment (file
,
13301 (bfd_vma
) segment
->p_offset
,
13302 (bfd_vma
) segment
->p_filesz
);
13309 process_note_sections (FILE * file
)
13311 Elf_Internal_Shdr
* section
;
13315 for (i
= 0, section
= section_headers
;
13316 i
< elf_header
.e_shnum
&& section
!= NULL
;
13318 if (section
->sh_type
== SHT_NOTE
)
13319 res
&= process_corefile_note_segment (file
,
13320 (bfd_vma
) section
->sh_offset
,
13321 (bfd_vma
) section
->sh_size
);
13327 process_notes (FILE * file
)
13329 /* If we have not been asked to display the notes then do nothing. */
13333 if (elf_header
.e_type
!= ET_CORE
)
13334 return process_note_sections (file
);
13336 /* No program headers means no NOTE segment. */
13337 if (elf_header
.e_phnum
> 0)
13338 return process_corefile_note_segments (file
);
13340 printf (_("No note segments present in the core file.\n"));
13345 process_arch_specific (FILE * file
)
13350 switch (elf_header
.e_machine
)
13353 return process_arm_specific (file
);
13355 case EM_MIPS_RS3_LE
:
13356 return process_mips_specific (file
);
13359 return process_power_specific (file
);
13362 case EM_SPARC32PLUS
:
13364 return process_sparc_specific (file
);
13367 return process_tic6x_specific (file
);
13376 get_file_header (FILE * file
)
13378 /* Read in the identity array. */
13379 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13382 /* Determine how to read the rest of the header. */
13383 switch (elf_header
.e_ident
[EI_DATA
])
13385 default: /* fall through */
13386 case ELFDATANONE
: /* fall through */
13388 byte_get
= byte_get_little_endian
;
13389 byte_put
= byte_put_little_endian
;
13392 byte_get
= byte_get_big_endian
;
13393 byte_put
= byte_put_big_endian
;
13397 /* For now we only support 32 bit and 64 bit ELF files. */
13398 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13400 /* Read in the rest of the header. */
13403 Elf32_External_Ehdr ehdr32
;
13405 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13408 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13409 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13410 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13411 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13412 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13413 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13414 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13415 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13416 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13417 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13418 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13419 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13420 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13424 Elf64_External_Ehdr ehdr64
;
13426 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13427 we will not be able to cope with the 64bit data found in
13428 64 ELF files. Detect this now and abort before we start
13429 overwriting things. */
13430 if (sizeof (bfd_vma
) < 8)
13432 error (_("This instance of readelf has been built without support for a\n\
13433 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13437 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13440 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13441 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13442 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13443 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13444 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13445 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13446 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13447 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13448 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13449 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13450 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13451 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13452 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13455 if (elf_header
.e_shoff
)
13457 /* There may be some extensions in the first section header. Don't
13458 bomb if we can't read it. */
13460 get_32bit_section_headers (file
, 1);
13462 get_64bit_section_headers (file
, 1);
13468 /* Process one ELF object file according to the command line options.
13469 This file may actually be stored in an archive. The file is
13470 positioned at the start of the ELF object. */
13473 process_object (char * file_name
, FILE * file
)
13477 if (! get_file_header (file
))
13479 error (_("%s: Failed to read file header\n"), file_name
);
13483 /* Initialise per file variables. */
13484 for (i
= ARRAY_SIZE (version_info
); i
--;)
13485 version_info
[i
] = 0;
13487 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13488 dynamic_info
[i
] = 0;
13489 dynamic_info_DT_GNU_HASH
= 0;
13491 /* Process the file. */
13493 printf (_("\nFile: %s\n"), file_name
);
13495 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13496 Note we do this even if cmdline_dump_sects is empty because we
13497 must make sure that the dump_sets array is zeroed out before each
13498 object file is processed. */
13499 if (num_dump_sects
> num_cmdline_dump_sects
)
13500 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13502 if (num_cmdline_dump_sects
> 0)
13504 if (num_dump_sects
== 0)
13505 /* A sneaky way of allocating the dump_sects array. */
13506 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13508 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13509 memcpy (dump_sects
, cmdline_dump_sects
,
13510 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13513 if (! process_file_header ())
13516 if (! process_section_headers (file
))
13518 /* Without loaded section headers we cannot process lots of
13520 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13522 if (! do_using_dynamic
)
13523 do_syms
= do_dyn_syms
= do_reloc
= 0;
13526 if (! process_section_groups (file
))
13528 /* Without loaded section groups we cannot process unwind. */
13532 if (process_program_headers (file
))
13533 process_dynamic_section (file
);
13535 process_relocs (file
);
13537 process_unwind (file
);
13539 process_symbol_table (file
);
13541 process_syminfo (file
);
13543 process_version_sections (file
);
13545 process_section_contents (file
);
13547 process_notes (file
);
13549 process_gnu_liblist (file
);
13551 process_arch_specific (file
);
13553 if (program_headers
)
13555 free (program_headers
);
13556 program_headers
= NULL
;
13559 if (section_headers
)
13561 free (section_headers
);
13562 section_headers
= NULL
;
13567 free (string_table
);
13568 string_table
= NULL
;
13569 string_table_length
= 0;
13572 if (dynamic_strings
)
13574 free (dynamic_strings
);
13575 dynamic_strings
= NULL
;
13576 dynamic_strings_length
= 0;
13579 if (dynamic_symbols
)
13581 free (dynamic_symbols
);
13582 dynamic_symbols
= NULL
;
13583 num_dynamic_syms
= 0;
13586 if (dynamic_syminfo
)
13588 free (dynamic_syminfo
);
13589 dynamic_syminfo
= NULL
;
13592 if (dynamic_section
)
13594 free (dynamic_section
);
13595 dynamic_section
= NULL
;
13598 if (section_headers_groups
)
13600 free (section_headers_groups
);
13601 section_headers_groups
= NULL
;
13604 if (section_groups
)
13606 struct group_list
* g
;
13607 struct group_list
* next
;
13609 for (i
= 0; i
< group_count
; i
++)
13611 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13618 free (section_groups
);
13619 section_groups
= NULL
;
13622 free_debug_memory ();
13627 /* Process an ELF archive.
13628 On entry the file is positioned just after the ARMAG string. */
13631 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13633 struct archive_info arch
;
13634 struct archive_info nested_arch
;
13640 /* The ARCH structure is used to hold information about this archive. */
13641 arch
.file_name
= NULL
;
13643 arch
.index_array
= NULL
;
13644 arch
.sym_table
= NULL
;
13645 arch
.longnames
= NULL
;
13647 /* The NESTED_ARCH structure is used as a single-item cache of information
13648 about a nested archive (when members of a thin archive reside within
13649 another regular archive file). */
13650 nested_arch
.file_name
= NULL
;
13651 nested_arch
.file
= NULL
;
13652 nested_arch
.index_array
= NULL
;
13653 nested_arch
.sym_table
= NULL
;
13654 nested_arch
.longnames
= NULL
;
13656 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13662 if (do_archive_index
)
13664 if (arch
.sym_table
== NULL
)
13665 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13669 unsigned long current_pos
;
13671 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13672 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13673 current_pos
= ftell (file
);
13675 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13677 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13679 char * member_name
;
13681 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13683 if (member_name
!= NULL
)
13685 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13687 if (qualified_name
!= NULL
)
13689 printf (_("Contents of binary %s at offset "), qualified_name
);
13690 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13692 free (qualified_name
);
13697 if (l
>= arch
.sym_size
)
13699 error (_("%s: end of the symbol table reached before the end of the index\n"),
13703 printf ("\t%s\n", arch
.sym_table
+ l
);
13704 l
+= strlen (arch
.sym_table
+ l
) + 1;
13707 if (arch
.uses_64bit_indicies
)
13712 if (l
< arch
.sym_size
)
13713 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13714 file_name
, arch
.sym_size
- l
);
13716 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13718 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13724 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13725 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13726 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13727 && !do_section_groups
&& !do_dyn_syms
)
13729 ret
= 0; /* Archive index only. */
13740 char * qualified_name
;
13742 /* Read the next archive header. */
13743 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13745 error (_("%s: failed to seek to next archive header\n"), file_name
);
13748 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13749 if (got
!= sizeof arch
.arhdr
)
13753 error (_("%s: failed to read archive header\n"), file_name
);
13757 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13759 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13764 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13766 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13767 if (archive_file_size
& 01)
13768 ++archive_file_size
;
13770 name
= get_archive_member_name (&arch
, &nested_arch
);
13773 error (_("%s: bad archive file name\n"), file_name
);
13777 namelen
= strlen (name
);
13779 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13780 if (qualified_name
== NULL
)
13782 error (_("%s: bad archive file name\n"), file_name
);
13787 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13789 /* This is a proxy for an external member of a thin archive. */
13790 FILE * member_file
;
13791 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13792 if (member_file_name
== NULL
)
13798 member_file
= fopen (member_file_name
, "rb");
13799 if (member_file
== NULL
)
13801 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13802 free (member_file_name
);
13807 archive_file_offset
= arch
.nested_member_origin
;
13809 ret
|= process_object (qualified_name
, member_file
);
13811 fclose (member_file
);
13812 free (member_file_name
);
13814 else if (is_thin_archive
)
13816 /* This is a proxy for a member of a nested archive. */
13817 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13819 /* The nested archive file will have been opened and setup by
13820 get_archive_member_name. */
13821 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13823 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13828 ret
|= process_object (qualified_name
, nested_arch
.file
);
13832 archive_file_offset
= arch
.next_arhdr_offset
;
13833 arch
.next_arhdr_offset
+= archive_file_size
;
13835 ret
|= process_object (qualified_name
, file
);
13838 if (dump_sects
!= NULL
)
13842 num_dump_sects
= 0;
13845 free (qualified_name
);
13849 if (nested_arch
.file
!= NULL
)
13850 fclose (nested_arch
.file
);
13851 release_archive (&nested_arch
);
13852 release_archive (&arch
);
13858 process_file (char * file_name
)
13861 struct stat statbuf
;
13862 char armag
[SARMAG
];
13865 if (stat (file_name
, &statbuf
) < 0)
13867 if (errno
== ENOENT
)
13868 error (_("'%s': No such file\n"), file_name
);
13870 error (_("Could not locate '%s'. System error message: %s\n"),
13871 file_name
, strerror (errno
));
13875 if (! S_ISREG (statbuf
.st_mode
))
13877 error (_("'%s' is not an ordinary file\n"), file_name
);
13881 file
= fopen (file_name
, "rb");
13884 error (_("Input file '%s' is not readable.\n"), file_name
);
13888 if (fread (armag
, SARMAG
, 1, file
) != 1)
13890 error (_("%s: Failed to read file's magic number\n"), file_name
);
13895 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
13896 ret
= process_archive (file_name
, file
, FALSE
);
13897 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
13898 ret
= process_archive (file_name
, file
, TRUE
);
13901 if (do_archive_index
)
13902 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13906 archive_file_size
= archive_file_offset
= 0;
13907 ret
= process_object (file_name
, file
);
13915 #ifdef SUPPORT_DISASSEMBLY
13916 /* Needed by the i386 disassembler. For extra credit, someone could
13917 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13921 print_address (unsigned int addr
, FILE * outfile
)
13923 fprintf (outfile
,"0x%8.8x", addr
);
13926 /* Needed by the i386 disassembler. */
13928 db_task_printsym (unsigned int addr
)
13930 print_address (addr
, stderr
);
13935 main (int argc
, char ** argv
)
13939 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13940 setlocale (LC_MESSAGES
, "");
13942 #if defined (HAVE_SETLOCALE)
13943 setlocale (LC_CTYPE
, "");
13945 bindtextdomain (PACKAGE
, LOCALEDIR
);
13946 textdomain (PACKAGE
);
13948 expandargv (&argc
, &argv
);
13950 parse_args (argc
, argv
);
13952 if (num_dump_sects
> 0)
13954 /* Make a copy of the dump_sects array. */
13955 cmdline_dump_sects
= (dump_type
*)
13956 malloc (num_dump_sects
* sizeof (* dump_sects
));
13957 if (cmdline_dump_sects
== NULL
)
13958 error (_("Out of memory allocating dump request table.\n"));
13961 memcpy (cmdline_dump_sects
, dump_sects
,
13962 num_dump_sects
* sizeof (* dump_sects
));
13963 num_cmdline_dump_sects
= num_dump_sects
;
13967 if (optind
< (argc
- 1))
13971 while (optind
< argc
)
13972 err
|= process_file (argv
[optind
++]);
13974 if (dump_sects
!= NULL
)
13976 if (cmdline_dump_sects
!= NULL
)
13977 free (cmdline_dump_sects
);