1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998-2013 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/or32.h"
137 #include "elf/ppc64.h"
138 #include "elf/rl78.h"
140 #include "elf/s390.h"
141 #include "elf/score.h"
143 #include "elf/sparc.h"
145 #include "elf/tic6x.h"
146 #include "elf/tilegx.h"
147 #include "elf/tilepro.h"
148 #include "elf/v850.h"
150 #include "elf/x86-64.h"
151 #include "elf/xc16x.h"
152 #include "elf/xgate.h"
153 #include "elf/xstormy16.h"
154 #include "elf/xtensa.h"
156 #include "elf/nios2.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
163 char * program_name
= "readelf";
164 static long archive_file_offset
;
165 static unsigned long archive_file_size
;
166 static unsigned long dynamic_addr
;
167 static bfd_size_type dynamic_size
;
168 static unsigned int dynamic_nent
;
169 static char * dynamic_strings
;
170 static unsigned long dynamic_strings_length
;
171 static char * string_table
;
172 static unsigned long string_table_length
;
173 static unsigned long num_dynamic_syms
;
174 static Elf_Internal_Sym
* dynamic_symbols
;
175 static Elf_Internal_Syminfo
* dynamic_syminfo
;
176 static unsigned long dynamic_syminfo_offset
;
177 static unsigned int dynamic_syminfo_nent
;
178 static char program_interpreter
[PATH_MAX
];
179 static bfd_vma dynamic_info
[DT_ENCODING
];
180 static bfd_vma dynamic_info_DT_GNU_HASH
;
181 static bfd_vma version_info
[16];
182 static Elf_Internal_Ehdr elf_header
;
183 static Elf_Internal_Shdr
* section_headers
;
184 static Elf_Internal_Phdr
* program_headers
;
185 static Elf_Internal_Dyn
* dynamic_section
;
186 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
187 static int show_name
;
188 static int do_dynamic
;
190 static int do_dyn_syms
;
192 static int do_sections
;
193 static int do_section_groups
;
194 static int do_section_details
;
195 static int do_segments
;
196 static int do_unwind
;
197 static int do_using_dynamic
;
198 static int do_header
;
200 static int do_version
;
201 static int do_histogram
;
202 static int do_debugging
;
205 static int do_archive_index
;
206 static int is_32bit_elf
;
210 struct group_list
* next
;
211 unsigned int section_index
;
216 struct group_list
* root
;
217 unsigned int group_index
;
220 static size_t group_count
;
221 static struct group
* section_groups
;
222 static struct group
** section_headers_groups
;
225 /* Flag bits indicating particular types of dump. */
226 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
227 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
230 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
232 typedef unsigned char dump_type
;
234 /* A linked list of the section names for which dumps were requested. */
235 struct dump_list_entry
239 struct dump_list_entry
* next
;
241 static struct dump_list_entry
* dump_sects_byname
;
243 /* A dynamic array of flags indicating for which sections a dump
244 has been requested via command line switches. */
245 static dump_type
* cmdline_dump_sects
= NULL
;
246 static unsigned int num_cmdline_dump_sects
= 0;
248 /* A dynamic array of flags indicating for which sections a dump of
249 some kind has been requested. It is reset on a per-object file
250 basis and then initialised from the cmdline_dump_sects array,
251 the results of interpreting the -w switch, and the
252 dump_sects_byname list. */
253 static dump_type
* dump_sects
= NULL
;
254 static unsigned int num_dump_sects
= 0;
257 /* How to print a vma value. */
258 typedef enum print_mode
272 #define SECTION_NAME(X) \
273 ((X) == NULL ? _("<none>") \
274 : string_table == NULL ? _("<no-name>") \
275 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
276 : string_table + (X)->sh_name))
278 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
280 #define GET_ELF_SYMBOLS(file, section, sym_count) \
281 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
282 : get_64bit_elf_symbols (file, section, sym_count))
284 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
285 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
286 already been called and verified that the string exists. */
287 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
289 #define REMOVE_ARCH_BITS(ADDR) \
292 if (elf_header.e_machine == EM_ARM) \
297 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
298 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
299 using malloc and fill that. In either case return the pointer to the start of
300 the retrieved data or NULL if something went wrong. If something does go wrong
301 emit an error message using REASON as part of the context. */
304 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
309 if (size
== 0 || nmemb
== 0)
312 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
314 error (_("Unable to seek to 0x%lx for %s\n"),
315 (unsigned long) archive_file_offset
+ offset
, reason
);
322 /* Check for overflow. */
323 if (nmemb
< (~(size_t) 0 - 1) / size
)
324 /* + 1 so that we can '\0' terminate invalid string table sections. */
325 mvar
= malloc (size
* nmemb
+ 1);
329 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
330 (unsigned long)(size
* nmemb
), reason
);
334 ((char *) mvar
)[size
* nmemb
] = '\0';
337 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
339 error (_("Unable to read in 0x%lx bytes of %s\n"),
340 (unsigned long)(size
* nmemb
), reason
);
349 /* Print a VMA value. */
352 print_vma (bfd_vma vma
, print_mode mode
)
365 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
372 return printf ("%5" BFD_VMA_FMT
"d", vma
);
380 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
383 return printf ("%" BFD_VMA_FMT
"d", vma
);
386 return printf ("%" BFD_VMA_FMT
"u", vma
);
391 /* Display a symbol on stdout. Handles the display of control characters and
392 multibye characters (assuming the host environment supports them).
394 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
396 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
397 padding as necessary.
399 Returns the number of emitted characters. */
402 print_symbol (int width
, const char *symbol
)
404 bfd_boolean extra_padding
= FALSE
;
406 #ifdef HAVE_MBSTATE_T
413 /* Keep the width positive. This also helps. */
415 extra_padding
= TRUE
;
419 /* Set the remaining width to a very large value.
420 This simplifies the code below. */
421 width_remaining
= INT_MAX
;
423 width_remaining
= width
;
425 #ifdef HAVE_MBSTATE_T
426 /* Initialise the multibyte conversion state. */
427 memset (& state
, 0, sizeof (state
));
430 while (width_remaining
)
433 const char c
= *symbol
++;
438 /* Do not print control characters directly as they can affect terminal
439 settings. Such characters usually appear in the names generated
440 by the assembler for local labels. */
443 if (width_remaining
< 2)
446 printf ("^%c", c
+ 0x40);
447 width_remaining
-= 2;
450 else if (ISPRINT (c
))
458 #ifdef HAVE_MBSTATE_T
461 /* Let printf do the hard work of displaying multibyte characters. */
462 printf ("%.1s", symbol
- 1);
466 #ifdef HAVE_MBSTATE_T
467 /* Try to find out how many bytes made up the character that was
468 just printed. Advance the symbol pointer past the bytes that
470 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
474 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
479 if (extra_padding
&& num_printed
< width
)
481 /* Fill in the remaining spaces. */
482 printf ("%-*s", width
- num_printed
, " ");
489 /* Return a pointer to section NAME, or NULL if no such section exists. */
491 static Elf_Internal_Shdr
*
492 find_section (const char * name
)
496 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
497 if (streq (SECTION_NAME (section_headers
+ i
), name
))
498 return section_headers
+ i
;
503 /* Return a pointer to a section containing ADDR, or NULL if no such
506 static Elf_Internal_Shdr
*
507 find_section_by_address (bfd_vma addr
)
511 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
513 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
514 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
521 /* Return a pointer to section NAME, or NULL if no such section exists,
522 restricted to the list of sections given in SET. */
524 static Elf_Internal_Shdr
*
525 find_section_in_set (const char * name
, unsigned int * set
)
531 while ((i
= *set
++) > 0)
532 if (streq (SECTION_NAME (section_headers
+ i
), name
))
533 return section_headers
+ i
;
536 return find_section (name
);
539 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
543 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
545 return read_leb128 (data
, length_return
, 0);
548 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
549 This OS has so many departures from the ELF standard that we test it at
555 return elf_header
.e_machine
== EM_IA_64
556 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
559 /* Guess the relocation size commonly used by the specific machines. */
562 guess_is_rela (unsigned int e_machine
)
566 /* Targets that use REL relocations. */
583 /* Targets that use RELA relocations. */
587 case EM_ADAPTEVA_EPIPHANY
:
589 case EM_ALTERA_NIOS2
:
608 case EM_LATTICEMICO32
:
617 case EM_CYGNUS_MN10200
:
619 case EM_CYGNUS_MN10300
:
650 case EM_MICROBLAZE_OLD
:
671 warn (_("Don't know about relocations on this machine architecture\n"));
677 slurp_rela_relocs (FILE * file
,
678 unsigned long rel_offset
,
679 unsigned long rel_size
,
680 Elf_Internal_Rela
** relasp
,
681 unsigned long * nrelasp
)
683 Elf_Internal_Rela
* relas
;
684 unsigned long nrelas
;
689 Elf32_External_Rela
* erelas
;
691 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
692 rel_size
, _("32-bit relocation data"));
696 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
698 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
699 sizeof (Elf_Internal_Rela
));
704 error (_("out of memory parsing relocs\n"));
708 for (i
= 0; i
< nrelas
; i
++)
710 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
711 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
712 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
719 Elf64_External_Rela
* erelas
;
721 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
722 rel_size
, _("64-bit relocation data"));
726 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
728 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
729 sizeof (Elf_Internal_Rela
));
734 error (_("out of memory parsing relocs\n"));
738 for (i
= 0; i
< nrelas
; i
++)
740 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
741 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
742 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
744 /* The #ifdef BFD64 below is to prevent a compile time
745 warning. We know that if we do not have a 64 bit data
746 type that we will never execute this code anyway. */
748 if (elf_header
.e_machine
== EM_MIPS
749 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
751 /* In little-endian objects, r_info isn't really a
752 64-bit little-endian value: it has a 32-bit
753 little-endian symbol index followed by four
754 individual byte fields. Reorder INFO
756 bfd_vma inf
= relas
[i
].r_info
;
757 inf
= (((inf
& 0xffffffff) << 32)
758 | ((inf
>> 56) & 0xff)
759 | ((inf
>> 40) & 0xff00)
760 | ((inf
>> 24) & 0xff0000)
761 | ((inf
>> 8) & 0xff000000));
762 relas
[i
].r_info
= inf
;
775 slurp_rel_relocs (FILE * file
,
776 unsigned long rel_offset
,
777 unsigned long rel_size
,
778 Elf_Internal_Rela
** relsp
,
779 unsigned long * nrelsp
)
781 Elf_Internal_Rela
* rels
;
787 Elf32_External_Rel
* erels
;
789 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
790 rel_size
, _("32-bit relocation data"));
794 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
796 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
801 error (_("out of memory parsing relocs\n"));
805 for (i
= 0; i
< nrels
; i
++)
807 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
808 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
809 rels
[i
].r_addend
= 0;
816 Elf64_External_Rel
* erels
;
818 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
819 rel_size
, _("64-bit relocation data"));
823 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
825 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
830 error (_("out of memory parsing relocs\n"));
834 for (i
= 0; i
< nrels
; i
++)
836 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
837 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
838 rels
[i
].r_addend
= 0;
840 /* The #ifdef BFD64 below is to prevent a compile time
841 warning. We know that if we do not have a 64 bit data
842 type that we will never execute this code anyway. */
844 if (elf_header
.e_machine
== EM_MIPS
845 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
847 /* In little-endian objects, r_info isn't really a
848 64-bit little-endian value: it has a 32-bit
849 little-endian symbol index followed by four
850 individual byte fields. Reorder INFO
852 bfd_vma inf
= rels
[i
].r_info
;
853 inf
= (((inf
& 0xffffffff) << 32)
854 | ((inf
>> 56) & 0xff)
855 | ((inf
>> 40) & 0xff00)
856 | ((inf
>> 24) & 0xff0000)
857 | ((inf
>> 8) & 0xff000000));
858 rels
[i
].r_info
= inf
;
870 /* Returns the reloc type extracted from the reloc info field. */
873 get_reloc_type (bfd_vma reloc_info
)
876 return ELF32_R_TYPE (reloc_info
);
878 switch (elf_header
.e_machine
)
881 /* Note: We assume that reloc_info has already been adjusted for us. */
882 return ELF64_MIPS_R_TYPE (reloc_info
);
885 return ELF64_R_TYPE_ID (reloc_info
);
888 return ELF64_R_TYPE (reloc_info
);
892 /* Return the symbol index extracted from the reloc info field. */
895 get_reloc_symindex (bfd_vma reloc_info
)
897 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
900 /* Display the contents of the relocation data found at the specified
904 dump_relocations (FILE * file
,
905 unsigned long rel_offset
,
906 unsigned long rel_size
,
907 Elf_Internal_Sym
* symtab
,
910 unsigned long strtablen
,
914 Elf_Internal_Rela
* rels
;
916 if (is_rela
== UNKNOWN
)
917 is_rela
= guess_is_rela (elf_header
.e_machine
);
921 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
926 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
935 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
937 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
942 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
944 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
952 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
954 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
959 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
961 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
965 for (i
= 0; i
< rel_size
; i
++)
970 bfd_vma symtab_index
;
973 offset
= rels
[i
].r_offset
;
974 inf
= rels
[i
].r_info
;
976 type
= get_reloc_type (inf
);
977 symtab_index
= get_reloc_symindex (inf
);
981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset
& 0xffffffff,
983 (unsigned long) inf
& 0xffffffff);
987 #if BFD_HOST_64BIT_LONG
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
992 #elif BFD_HOST_64BIT_LONG_LONG
995 ? "%16.16llx %16.16llx "
996 : "%12.12llx %12.12llx ",
1000 ? "%16.16I64x %16.16I64x "
1001 : "%12.12I64x %12.12I64x ",
1006 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1007 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1008 _bfd_int64_high (offset
),
1009 _bfd_int64_low (offset
),
1010 _bfd_int64_high (inf
),
1011 _bfd_int64_low (inf
));
1015 switch (elf_header
.e_machine
)
1022 rtype
= elf_aarch64_reloc_type (type
);
1026 case EM_CYGNUS_M32R
:
1027 rtype
= elf_m32r_reloc_type (type
);
1032 rtype
= elf_i386_reloc_type (type
);
1037 rtype
= elf_m68hc11_reloc_type (type
);
1041 rtype
= elf_m68k_reloc_type (type
);
1045 rtype
= elf_i960_reloc_type (type
);
1050 rtype
= elf_avr_reloc_type (type
);
1053 case EM_OLD_SPARCV9
:
1054 case EM_SPARC32PLUS
:
1057 rtype
= elf_sparc_reloc_type (type
);
1061 rtype
= elf_spu_reloc_type (type
);
1065 rtype
= v800_reloc_type (type
);
1068 case EM_CYGNUS_V850
:
1069 rtype
= v850_reloc_type (type
);
1073 case EM_CYGNUS_D10V
:
1074 rtype
= elf_d10v_reloc_type (type
);
1078 case EM_CYGNUS_D30V
:
1079 rtype
= elf_d30v_reloc_type (type
);
1083 rtype
= elf_dlx_reloc_type (type
);
1087 rtype
= elf_sh_reloc_type (type
);
1091 case EM_CYGNUS_MN10300
:
1092 rtype
= elf_mn10300_reloc_type (type
);
1096 case EM_CYGNUS_MN10200
:
1097 rtype
= elf_mn10200_reloc_type (type
);
1101 case EM_CYGNUS_FR30
:
1102 rtype
= elf_fr30_reloc_type (type
);
1106 rtype
= elf_frv_reloc_type (type
);
1110 rtype
= elf_mcore_reloc_type (type
);
1114 rtype
= elf_mmix_reloc_type (type
);
1118 rtype
= elf_moxie_reloc_type (type
);
1123 rtype
= elf_msp430_reloc_type (type
);
1127 rtype
= elf_ppc_reloc_type (type
);
1131 rtype
= elf_ppc64_reloc_type (type
);
1135 case EM_MIPS_RS3_LE
:
1136 rtype
= elf_mips_reloc_type (type
);
1140 rtype
= elf_alpha_reloc_type (type
);
1144 rtype
= elf_arm_reloc_type (type
);
1148 rtype
= elf_arc_reloc_type (type
);
1152 rtype
= elf_hppa_reloc_type (type
);
1158 rtype
= elf_h8_reloc_type (type
);
1163 rtype
= elf_or32_reloc_type (type
);
1168 rtype
= elf_pj_reloc_type (type
);
1171 rtype
= elf_ia64_reloc_type (type
);
1175 rtype
= elf_cris_reloc_type (type
);
1179 rtype
= elf_i860_reloc_type (type
);
1185 rtype
= elf_x86_64_reloc_type (type
);
1189 rtype
= i370_reloc_type (type
);
1194 rtype
= elf_s390_reloc_type (type
);
1198 rtype
= elf_score_reloc_type (type
);
1202 rtype
= elf_xstormy16_reloc_type (type
);
1206 rtype
= elf_crx_reloc_type (type
);
1210 rtype
= elf_vax_reloc_type (type
);
1213 case EM_ADAPTEVA_EPIPHANY
:
1214 rtype
= elf_epiphany_reloc_type (type
);
1219 rtype
= elf_ip2k_reloc_type (type
);
1223 rtype
= elf_iq2000_reloc_type (type
);
1228 rtype
= elf_xtensa_reloc_type (type
);
1231 case EM_LATTICEMICO32
:
1232 rtype
= elf_lm32_reloc_type (type
);
1237 rtype
= elf_m32c_reloc_type (type
);
1241 rtype
= elf_mt_reloc_type (type
);
1245 rtype
= elf_bfin_reloc_type (type
);
1249 rtype
= elf_mep_reloc_type (type
);
1253 rtype
= elf_cr16_reloc_type (type
);
1257 case EM_MICROBLAZE_OLD
:
1258 rtype
= elf_microblaze_reloc_type (type
);
1262 rtype
= elf_rl78_reloc_type (type
);
1266 rtype
= elf_rx_reloc_type (type
);
1270 rtype
= elf_metag_reloc_type (type
);
1275 rtype
= elf_xc16x_reloc_type (type
);
1279 rtype
= elf_tic6x_reloc_type (type
);
1283 rtype
= elf_tilegx_reloc_type (type
);
1287 rtype
= elf_tilepro_reloc_type (type
);
1291 rtype
= elf_xgate_reloc_type (type
);
1294 case EM_ALTERA_NIOS2
:
1295 rtype
= elf_nios2_reloc_type (type
);
1300 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1302 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1304 if (elf_header
.e_machine
== EM_ALPHA
1306 && streq (rtype
, "R_ALPHA_LITUSE")
1309 switch (rels
[i
].r_addend
)
1311 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1312 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1313 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1314 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1315 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1316 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1317 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1318 default: rtype
= NULL
;
1321 printf (" (%s)", rtype
);
1325 printf (_("<unknown addend: %lx>"),
1326 (unsigned long) rels
[i
].r_addend
);
1329 else if (symtab_index
)
1331 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1332 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1335 Elf_Internal_Sym
* psym
;
1337 psym
= symtab
+ symtab_index
;
1341 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1345 unsigned int width
= is_32bit_elf
? 8 : 14;
1347 /* Relocations against GNU_IFUNC symbols do not use the value
1348 of the symbol as the address to relocate against. Instead
1349 they invoke the function named by the symbol and use its
1350 result as the address for relocation.
1352 To indicate this to the user, do not display the value of
1353 the symbol in the "Symbols's Value" field. Instead show
1354 its name followed by () as a hint that the symbol is
1358 || psym
->st_name
== 0
1359 || psym
->st_name
>= strtablen
)
1362 name
= strtab
+ psym
->st_name
;
1364 len
= print_symbol (width
, name
);
1365 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1369 print_vma (psym
->st_value
, LONG_HEX
);
1371 printf (is_32bit_elf
? " " : " ");
1374 if (psym
->st_name
== 0)
1376 const char * sec_name
= "<null>";
1379 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1381 if (psym
->st_shndx
< elf_header
.e_shnum
)
1383 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1384 else if (psym
->st_shndx
== SHN_ABS
)
1386 else if (psym
->st_shndx
== SHN_COMMON
)
1387 sec_name
= "COMMON";
1388 else if ((elf_header
.e_machine
== EM_MIPS
1389 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1390 || (elf_header
.e_machine
== EM_TI_C6000
1391 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1392 sec_name
= "SCOMMON";
1393 else if (elf_header
.e_machine
== EM_MIPS
1394 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1395 sec_name
= "SUNDEF";
1396 else if ((elf_header
.e_machine
== EM_X86_64
1397 || elf_header
.e_machine
== EM_L1OM
1398 || elf_header
.e_machine
== EM_K1OM
)
1399 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1400 sec_name
= "LARGE_COMMON";
1401 else if (elf_header
.e_machine
== EM_IA_64
1402 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1403 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1404 sec_name
= "ANSI_COM";
1405 else if (is_ia64_vms ()
1406 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1407 sec_name
= "VMS_SYMVEC";
1410 sprintf (name_buf
, "<section 0x%x>",
1411 (unsigned int) psym
->st_shndx
);
1412 sec_name
= name_buf
;
1415 print_symbol (22, sec_name
);
1417 else if (strtab
== NULL
)
1418 printf (_("<string table index: %3ld>"), psym
->st_name
);
1419 else if (psym
->st_name
>= strtablen
)
1420 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1422 print_symbol (22, strtab
+ psym
->st_name
);
1426 bfd_signed_vma off
= rels
[i
].r_addend
;
1429 printf (" - %" BFD_VMA_FMT
"x", - off
);
1431 printf (" + %" BFD_VMA_FMT
"x", off
);
1437 bfd_signed_vma off
= rels
[i
].r_addend
;
1439 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1441 printf ("-%" BFD_VMA_FMT
"x", - off
);
1443 printf ("%" BFD_VMA_FMT
"x", off
);
1446 if (elf_header
.e_machine
== EM_SPARCV9
1448 && streq (rtype
, "R_SPARC_OLO10"))
1449 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1454 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1456 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1457 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1458 const char * rtype2
= elf_mips_reloc_type (type2
);
1459 const char * rtype3
= elf_mips_reloc_type (type3
);
1461 printf (" Type2: ");
1464 printf (_("unrecognized: %-7lx"),
1465 (unsigned long) type2
& 0xffffffff);
1467 printf ("%-17.17s", rtype2
);
1469 printf ("\n Type3: ");
1472 printf (_("unrecognized: %-7lx"),
1473 (unsigned long) type3
& 0xffffffff);
1475 printf ("%-17.17s", rtype3
);
1486 get_mips_dynamic_type (unsigned long type
)
1490 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1491 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1492 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1493 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1494 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1495 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1496 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1497 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1498 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1499 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1500 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1501 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1502 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1503 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1504 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1505 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1506 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1507 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1508 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1509 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1510 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1511 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1512 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1513 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1514 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1515 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1516 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1517 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1518 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1519 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1520 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1521 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1522 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1523 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1524 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1525 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1526 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1527 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1528 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1529 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1530 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1531 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1532 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1533 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1534 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1541 get_sparc64_dynamic_type (unsigned long type
)
1545 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1552 get_ppc_dynamic_type (unsigned long type
)
1556 case DT_PPC_GOT
: return "PPC_GOT";
1557 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1564 get_ppc64_dynamic_type (unsigned long type
)
1568 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1569 case DT_PPC64_OPD
: return "PPC64_OPD";
1570 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1571 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1578 get_parisc_dynamic_type (unsigned long type
)
1582 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1583 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1584 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1585 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1586 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1587 case DT_HP_PREINIT
: return "HP_PREINIT";
1588 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1589 case DT_HP_NEEDED
: return "HP_NEEDED";
1590 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1591 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1592 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1593 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1594 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1595 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1596 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1597 case DT_HP_FILTERED
: return "HP_FILTERED";
1598 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1599 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1600 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1601 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1602 case DT_PLT
: return "PLT";
1603 case DT_PLT_SIZE
: return "PLT_SIZE";
1604 case DT_DLT
: return "DLT";
1605 case DT_DLT_SIZE
: return "DLT_SIZE";
1612 get_ia64_dynamic_type (unsigned long type
)
1616 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1617 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1618 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1619 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1620 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1621 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1622 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1623 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1624 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1625 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1626 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1627 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1628 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1629 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1630 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1631 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1632 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1633 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1634 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1635 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1636 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1637 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1638 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1639 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1640 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1641 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1642 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1643 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1644 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1645 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1646 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1653 get_alpha_dynamic_type (unsigned long type
)
1657 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1664 get_score_dynamic_type (unsigned long type
)
1668 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1669 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1670 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1671 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1672 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1673 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1680 get_tic6x_dynamic_type (unsigned long type
)
1684 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1685 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1686 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1687 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1688 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1689 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1696 get_nios2_dynamic_type (unsigned long type
)
1700 case DT_NIOS2_GP
: return "NIOS2_GP";
1707 get_dynamic_type (unsigned long type
)
1709 static char buff
[64];
1713 case DT_NULL
: return "NULL";
1714 case DT_NEEDED
: return "NEEDED";
1715 case DT_PLTRELSZ
: return "PLTRELSZ";
1716 case DT_PLTGOT
: return "PLTGOT";
1717 case DT_HASH
: return "HASH";
1718 case DT_STRTAB
: return "STRTAB";
1719 case DT_SYMTAB
: return "SYMTAB";
1720 case DT_RELA
: return "RELA";
1721 case DT_RELASZ
: return "RELASZ";
1722 case DT_RELAENT
: return "RELAENT";
1723 case DT_STRSZ
: return "STRSZ";
1724 case DT_SYMENT
: return "SYMENT";
1725 case DT_INIT
: return "INIT";
1726 case DT_FINI
: return "FINI";
1727 case DT_SONAME
: return "SONAME";
1728 case DT_RPATH
: return "RPATH";
1729 case DT_SYMBOLIC
: return "SYMBOLIC";
1730 case DT_REL
: return "REL";
1731 case DT_RELSZ
: return "RELSZ";
1732 case DT_RELENT
: return "RELENT";
1733 case DT_PLTREL
: return "PLTREL";
1734 case DT_DEBUG
: return "DEBUG";
1735 case DT_TEXTREL
: return "TEXTREL";
1736 case DT_JMPREL
: return "JMPREL";
1737 case DT_BIND_NOW
: return "BIND_NOW";
1738 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1739 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1740 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1741 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1742 case DT_RUNPATH
: return "RUNPATH";
1743 case DT_FLAGS
: return "FLAGS";
1745 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1746 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1748 case DT_CHECKSUM
: return "CHECKSUM";
1749 case DT_PLTPADSZ
: return "PLTPADSZ";
1750 case DT_MOVEENT
: return "MOVEENT";
1751 case DT_MOVESZ
: return "MOVESZ";
1752 case DT_FEATURE
: return "FEATURE";
1753 case DT_POSFLAG_1
: return "POSFLAG_1";
1754 case DT_SYMINSZ
: return "SYMINSZ";
1755 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1757 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1758 case DT_CONFIG
: return "CONFIG";
1759 case DT_DEPAUDIT
: return "DEPAUDIT";
1760 case DT_AUDIT
: return "AUDIT";
1761 case DT_PLTPAD
: return "PLTPAD";
1762 case DT_MOVETAB
: return "MOVETAB";
1763 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1765 case DT_VERSYM
: return "VERSYM";
1767 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1768 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1769 case DT_RELACOUNT
: return "RELACOUNT";
1770 case DT_RELCOUNT
: return "RELCOUNT";
1771 case DT_FLAGS_1
: return "FLAGS_1";
1772 case DT_VERDEF
: return "VERDEF";
1773 case DT_VERDEFNUM
: return "VERDEFNUM";
1774 case DT_VERNEED
: return "VERNEED";
1775 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1777 case DT_AUXILIARY
: return "AUXILIARY";
1778 case DT_USED
: return "USED";
1779 case DT_FILTER
: return "FILTER";
1781 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1782 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1783 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1784 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1785 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1786 case DT_GNU_HASH
: return "GNU_HASH";
1789 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1791 const char * result
;
1793 switch (elf_header
.e_machine
)
1796 case EM_MIPS_RS3_LE
:
1797 result
= get_mips_dynamic_type (type
);
1800 result
= get_sparc64_dynamic_type (type
);
1803 result
= get_ppc_dynamic_type (type
);
1806 result
= get_ppc64_dynamic_type (type
);
1809 result
= get_ia64_dynamic_type (type
);
1812 result
= get_alpha_dynamic_type (type
);
1815 result
= get_score_dynamic_type (type
);
1818 result
= get_tic6x_dynamic_type (type
);
1820 case EM_ALTERA_NIOS2
:
1821 result
= get_nios2_dynamic_type (type
);
1831 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1833 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1834 || (elf_header
.e_machine
== EM_PARISC
1835 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1837 const char * result
;
1839 switch (elf_header
.e_machine
)
1842 result
= get_parisc_dynamic_type (type
);
1845 result
= get_ia64_dynamic_type (type
);
1855 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1859 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1866 get_file_type (unsigned e_type
)
1868 static char buff
[32];
1872 case ET_NONE
: return _("NONE (None)");
1873 case ET_REL
: return _("REL (Relocatable file)");
1874 case ET_EXEC
: return _("EXEC (Executable file)");
1875 case ET_DYN
: return _("DYN (Shared object file)");
1876 case ET_CORE
: return _("CORE (Core file)");
1879 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1880 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1881 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1882 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1884 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1890 get_machine_name (unsigned e_machine
)
1892 static char buff
[64]; /* XXX */
1896 case EM_NONE
: return _("None");
1897 case EM_AARCH64
: return "AArch64";
1898 case EM_M32
: return "WE32100";
1899 case EM_SPARC
: return "Sparc";
1900 case EM_SPU
: return "SPU";
1901 case EM_386
: return "Intel 80386";
1902 case EM_68K
: return "MC68000";
1903 case EM_88K
: return "MC88000";
1904 case EM_486
: return "Intel 80486";
1905 case EM_860
: return "Intel 80860";
1906 case EM_MIPS
: return "MIPS R3000";
1907 case EM_S370
: return "IBM System/370";
1908 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1909 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1910 case EM_PARISC
: return "HPPA";
1911 case EM_PPC_OLD
: return "Power PC (old)";
1912 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1913 case EM_960
: return "Intel 90860";
1914 case EM_PPC
: return "PowerPC";
1915 case EM_PPC64
: return "PowerPC64";
1916 case EM_FR20
: return "Fujitsu FR20";
1917 case EM_RH32
: return "TRW RH32";
1918 case EM_MCORE
: return "MCORE";
1919 case EM_ARM
: return "ARM";
1920 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1921 case EM_SH
: return "Renesas / SuperH SH";
1922 case EM_SPARCV9
: return "Sparc v9";
1923 case EM_TRICORE
: return "Siemens Tricore";
1924 case EM_ARC
: return "ARC";
1925 case EM_H8_300
: return "Renesas H8/300";
1926 case EM_H8_300H
: return "Renesas H8/300H";
1927 case EM_H8S
: return "Renesas H8S";
1928 case EM_H8_500
: return "Renesas H8/500";
1929 case EM_IA_64
: return "Intel IA-64";
1930 case EM_MIPS_X
: return "Stanford MIPS-X";
1931 case EM_COLDFIRE
: return "Motorola Coldfire";
1932 case EM_ALPHA
: return "Alpha";
1933 case EM_CYGNUS_D10V
:
1934 case EM_D10V
: return "d10v";
1935 case EM_CYGNUS_D30V
:
1936 case EM_D30V
: return "d30v";
1937 case EM_CYGNUS_M32R
:
1938 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1939 case EM_CYGNUS_V850
:
1940 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1941 case EM_V850
: return "Renesas V850";
1942 case EM_CYGNUS_MN10300
:
1943 case EM_MN10300
: return "mn10300";
1944 case EM_CYGNUS_MN10200
:
1945 case EM_MN10200
: return "mn10200";
1946 case EM_MOXIE
: return "Moxie";
1947 case EM_CYGNUS_FR30
:
1948 case EM_FR30
: return "Fujitsu FR30";
1949 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1951 case EM_PJ
: return "picoJava";
1952 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1953 case EM_PCP
: return "Siemens PCP";
1954 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1955 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1956 case EM_STARCORE
: return "Motorola Star*Core processor";
1957 case EM_ME16
: return "Toyota ME16 processor";
1958 case EM_ST100
: return "STMicroelectronics ST100 processor";
1959 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1960 case EM_PDSP
: return "Sony DSP processor";
1961 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1962 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1963 case EM_FX66
: return "Siemens FX66 microcontroller";
1964 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1965 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1966 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1967 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1968 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1969 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1970 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1971 case EM_SVX
: return "Silicon Graphics SVx";
1972 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1973 case EM_VAX
: return "Digital VAX";
1975 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1976 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1977 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1978 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1979 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1980 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1981 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1982 case EM_PRISM
: return "Vitesse Prism";
1983 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1984 case EM_L1OM
: return "Intel L1OM";
1985 case EM_K1OM
: return "Intel K1OM";
1987 case EM_S390
: return "IBM S/390";
1988 case EM_SCORE
: return "SUNPLUS S+Core";
1989 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1991 case EM_OR32
: return "OpenRISC";
1992 case EM_ARC_A5
: return "ARC International ARCompact processor";
1993 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1994 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
1995 case EM_DLX
: return "OpenDLX";
1997 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1998 case EM_IQ2000
: return "Vitesse IQ2000";
2000 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2001 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2002 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2003 case EM_NS32K
: return "National Semiconductor 32000 series";
2004 case EM_TPC
: return "Tenor Network TPC processor";
2005 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2006 case EM_MAX
: return "MAX Processor";
2007 case EM_CR
: return "National Semiconductor CompactRISC";
2008 case EM_F2MC16
: return "Fujitsu F2MC16";
2009 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2010 case EM_LATTICEMICO32
: return "Lattice Mico32";
2012 case EM_M32C
: return "Renesas M32c";
2013 case EM_MT
: return "Morpho Techologies MT processor";
2014 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2015 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2016 case EM_SEP
: return "Sharp embedded microprocessor";
2017 case EM_ARCA
: return "Arca RISC microprocessor";
2018 case EM_UNICORE
: return "Unicore";
2019 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2020 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2021 case EM_NIOS32
: return "Altera Nios";
2022 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2024 case EM_XC16X
: return "Infineon Technologies xc16x";
2025 case EM_M16C
: return "Renesas M16C series microprocessors";
2026 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2027 case EM_CE
: return "Freescale Communication Engine RISC core";
2028 case EM_TSK3000
: return "Altium TSK3000 core";
2029 case EM_RS08
: return "Freescale RS08 embedded processor";
2030 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2031 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2032 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2033 case EM_SE_C17
: return "Seiko Epson C17 family";
2034 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2035 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2036 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2037 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2038 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2039 case EM_R32C
: return "Renesas R32C series microprocessors";
2040 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2041 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2042 case EM_8051
: return "Intel 8051 and variants";
2043 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2044 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2045 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2046 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2047 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2048 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2049 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2050 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2053 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2054 case EM_RL78
: return "Renesas RL78";
2055 case EM_RX
: return "Renesas RX";
2056 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2057 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2058 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2059 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2060 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2061 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2062 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2063 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2064 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2065 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2066 case EM_CUDA
: return "NVIDIA CUDA architecture";
2067 case EM_XGATE
: return "Motorola XGATE embedded processor";
2069 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2075 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2080 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2081 e_flags
&= ~ EF_ARM_EABIMASK
;
2083 /* Handle "generic" ARM flags. */
2084 if (e_flags
& EF_ARM_RELEXEC
)
2086 strcat (buf
, ", relocatable executable");
2087 e_flags
&= ~ EF_ARM_RELEXEC
;
2090 if (e_flags
& EF_ARM_HASENTRY
)
2092 strcat (buf
, ", has entry point");
2093 e_flags
&= ~ EF_ARM_HASENTRY
;
2096 /* Now handle EABI specific flags. */
2100 strcat (buf
, ", <unrecognized EABI>");
2105 case EF_ARM_EABI_VER1
:
2106 strcat (buf
, ", Version1 EABI");
2111 /* Process flags one bit at a time. */
2112 flag
= e_flags
& - e_flags
;
2117 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2118 strcat (buf
, ", sorted symbol tables");
2128 case EF_ARM_EABI_VER2
:
2129 strcat (buf
, ", Version2 EABI");
2134 /* Process flags one bit at a time. */
2135 flag
= e_flags
& - e_flags
;
2140 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2141 strcat (buf
, ", sorted symbol tables");
2144 case EF_ARM_DYNSYMSUSESEGIDX
:
2145 strcat (buf
, ", dynamic symbols use segment index");
2148 case EF_ARM_MAPSYMSFIRST
:
2149 strcat (buf
, ", mapping symbols precede others");
2159 case EF_ARM_EABI_VER3
:
2160 strcat (buf
, ", Version3 EABI");
2163 case EF_ARM_EABI_VER4
:
2164 strcat (buf
, ", Version4 EABI");
2169 /* Process flags one bit at a time. */
2170 flag
= e_flags
& - e_flags
;
2176 strcat (buf
, ", BE8");
2180 strcat (buf
, ", LE8");
2191 case EF_ARM_EABI_VER5
:
2192 strcat (buf
, ", Version5 EABI");
2197 /* Process flags one bit at a time. */
2198 flag
= e_flags
& - e_flags
;
2204 strcat (buf
, ", BE8");
2208 strcat (buf
, ", LE8");
2211 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2212 strcat (buf
, ", soft-float ABI");
2215 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2216 strcat (buf
, ", hard-float ABI");
2226 case EF_ARM_EABI_UNKNOWN
:
2227 strcat (buf
, ", GNU EABI");
2232 /* Process flags one bit at a time. */
2233 flag
= e_flags
& - e_flags
;
2238 case EF_ARM_INTERWORK
:
2239 strcat (buf
, ", interworking enabled");
2242 case EF_ARM_APCS_26
:
2243 strcat (buf
, ", uses APCS/26");
2246 case EF_ARM_APCS_FLOAT
:
2247 strcat (buf
, ", uses APCS/float");
2251 strcat (buf
, ", position independent");
2255 strcat (buf
, ", 8 bit structure alignment");
2258 case EF_ARM_NEW_ABI
:
2259 strcat (buf
, ", uses new ABI");
2262 case EF_ARM_OLD_ABI
:
2263 strcat (buf
, ", uses old ABI");
2266 case EF_ARM_SOFT_FLOAT
:
2267 strcat (buf
, ", software FP");
2270 case EF_ARM_VFP_FLOAT
:
2271 strcat (buf
, ", VFP");
2274 case EF_ARM_MAVERICK_FLOAT
:
2275 strcat (buf
, ", Maverick FP");
2286 strcat (buf
,_(", <unknown>"));
2290 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2292 static char buf
[1024];
2304 decode_ARM_machine_flags (e_flags
, buf
);
2308 if (e_flags
& EF_BFIN_PIC
)
2309 strcat (buf
, ", PIC");
2311 if (e_flags
& EF_BFIN_FDPIC
)
2312 strcat (buf
, ", FDPIC");
2314 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2315 strcat (buf
, ", code in L1");
2317 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2318 strcat (buf
, ", data in L1");
2323 switch (e_flags
& EF_FRV_CPU_MASK
)
2325 case EF_FRV_CPU_GENERIC
:
2329 strcat (buf
, ", fr???");
2332 case EF_FRV_CPU_FR300
:
2333 strcat (buf
, ", fr300");
2336 case EF_FRV_CPU_FR400
:
2337 strcat (buf
, ", fr400");
2339 case EF_FRV_CPU_FR405
:
2340 strcat (buf
, ", fr405");
2343 case EF_FRV_CPU_FR450
:
2344 strcat (buf
, ", fr450");
2347 case EF_FRV_CPU_FR500
:
2348 strcat (buf
, ", fr500");
2350 case EF_FRV_CPU_FR550
:
2351 strcat (buf
, ", fr550");
2354 case EF_FRV_CPU_SIMPLE
:
2355 strcat (buf
, ", simple");
2357 case EF_FRV_CPU_TOMCAT
:
2358 strcat (buf
, ", tomcat");
2364 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2365 strcat (buf
, ", m68000");
2366 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2367 strcat (buf
, ", cpu32");
2368 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2369 strcat (buf
, ", fido_a");
2372 char const * isa
= _("unknown");
2373 char const * mac
= _("unknown mac");
2374 char const * additional
= NULL
;
2376 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2378 case EF_M68K_CF_ISA_A_NODIV
:
2380 additional
= ", nodiv";
2382 case EF_M68K_CF_ISA_A
:
2385 case EF_M68K_CF_ISA_A_PLUS
:
2388 case EF_M68K_CF_ISA_B_NOUSP
:
2390 additional
= ", nousp";
2392 case EF_M68K_CF_ISA_B
:
2395 case EF_M68K_CF_ISA_C
:
2398 case EF_M68K_CF_ISA_C_NODIV
:
2400 additional
= ", nodiv";
2403 strcat (buf
, ", cf, isa ");
2406 strcat (buf
, additional
);
2407 if (e_flags
& EF_M68K_CF_FLOAT
)
2408 strcat (buf
, ", float");
2409 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2414 case EF_M68K_CF_MAC
:
2417 case EF_M68K_CF_EMAC
:
2420 case EF_M68K_CF_EMAC_B
:
2433 if (e_flags
& EF_PPC_EMB
)
2434 strcat (buf
, ", emb");
2436 if (e_flags
& EF_PPC_RELOCATABLE
)
2437 strcat (buf
, _(", relocatable"));
2439 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2440 strcat (buf
, _(", relocatable-lib"));
2444 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2445 strcat (buf
, ", RH850 ABI");
2447 if (e_flags
& EF_V800_850E3
)
2448 strcat (buf
, ", V3 architecture");
2450 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2451 strcat (buf
, ", FPU not used");
2453 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2454 strcat (buf
, ", regmode: COMMON");
2456 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2457 strcat (buf
, ", r4 not used");
2459 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2460 strcat (buf
, ", r30 not used");
2462 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2463 strcat (buf
, ", r5 not used");
2465 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2466 strcat (buf
, ", r2 not used");
2468 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2470 switch (e_flags
& - e_flags
)
2472 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2473 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2474 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2475 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2476 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2477 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2478 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2479 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2480 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2481 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2482 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2483 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2484 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2485 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2486 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2487 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2494 case EM_CYGNUS_V850
:
2495 switch (e_flags
& EF_V850_ARCH
)
2497 case E_V850E3V5_ARCH
:
2498 strcat (buf
, ", v850e3v5");
2500 case E_V850E2V3_ARCH
:
2501 strcat (buf
, ", v850e2v3");
2504 strcat (buf
, ", v850e2");
2507 strcat (buf
, ", v850e1");
2510 strcat (buf
, ", v850e");
2513 strcat (buf
, ", v850");
2516 strcat (buf
, _(", unknown v850 architecture variant"));
2522 case EM_CYGNUS_M32R
:
2523 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2524 strcat (buf
, ", m32r");
2528 case EM_MIPS_RS3_LE
:
2529 if (e_flags
& EF_MIPS_NOREORDER
)
2530 strcat (buf
, ", noreorder");
2532 if (e_flags
& EF_MIPS_PIC
)
2533 strcat (buf
, ", pic");
2535 if (e_flags
& EF_MIPS_CPIC
)
2536 strcat (buf
, ", cpic");
2538 if (e_flags
& EF_MIPS_UCODE
)
2539 strcat (buf
, ", ugen_reserved");
2541 if (e_flags
& EF_MIPS_ABI2
)
2542 strcat (buf
, ", abi2");
2544 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2545 strcat (buf
, ", odk first");
2547 if (e_flags
& EF_MIPS_32BITMODE
)
2548 strcat (buf
, ", 32bitmode");
2550 switch ((e_flags
& EF_MIPS_MACH
))
2552 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2553 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2554 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2555 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2556 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2557 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2558 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2559 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2560 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2561 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2562 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2563 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2564 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2565 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2566 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2567 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2569 /* We simply ignore the field in this case to avoid confusion:
2570 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2573 default: strcat (buf
, _(", unknown CPU")); break;
2576 switch ((e_flags
& EF_MIPS_ABI
))
2578 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2579 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2580 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2581 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2583 /* We simply ignore the field in this case to avoid confusion:
2584 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2585 This means it is likely to be an o32 file, but not for
2588 default: strcat (buf
, _(", unknown ABI")); break;
2591 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2592 strcat (buf
, ", mdmx");
2594 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2595 strcat (buf
, ", mips16");
2597 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2598 strcat (buf
, ", micromips");
2600 switch ((e_flags
& EF_MIPS_ARCH
))
2602 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2603 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2604 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2605 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2606 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2607 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2608 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2609 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2610 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2611 default: strcat (buf
, _(", unknown ISA")); break;
2616 switch ((e_flags
& EF_SH_MACH_MASK
))
2618 case EF_SH1
: strcat (buf
, ", sh1"); break;
2619 case EF_SH2
: strcat (buf
, ", sh2"); break;
2620 case EF_SH3
: strcat (buf
, ", sh3"); break;
2621 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2622 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2623 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2624 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2625 case EF_SH4
: strcat (buf
, ", sh4"); break;
2626 case EF_SH5
: strcat (buf
, ", sh5"); break;
2627 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2628 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2629 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2630 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2631 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2632 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2633 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2634 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2635 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2636 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2637 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2638 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2639 default: strcat (buf
, _(", unknown ISA")); break;
2642 if (e_flags
& EF_SH_PIC
)
2643 strcat (buf
, ", pic");
2645 if (e_flags
& EF_SH_FDPIC
)
2646 strcat (buf
, ", fdpic");
2650 if (e_flags
& EF_SPARC_32PLUS
)
2651 strcat (buf
, ", v8+");
2653 if (e_flags
& EF_SPARC_SUN_US1
)
2654 strcat (buf
, ", ultrasparcI");
2656 if (e_flags
& EF_SPARC_SUN_US3
)
2657 strcat (buf
, ", ultrasparcIII");
2659 if (e_flags
& EF_SPARC_HAL_R1
)
2660 strcat (buf
, ", halr1");
2662 if (e_flags
& EF_SPARC_LEDATA
)
2663 strcat (buf
, ", ledata");
2665 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2666 strcat (buf
, ", tso");
2668 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2669 strcat (buf
, ", pso");
2671 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2672 strcat (buf
, ", rmo");
2676 switch (e_flags
& EF_PARISC_ARCH
)
2678 case EFA_PARISC_1_0
:
2679 strcpy (buf
, ", PA-RISC 1.0");
2681 case EFA_PARISC_1_1
:
2682 strcpy (buf
, ", PA-RISC 1.1");
2684 case EFA_PARISC_2_0
:
2685 strcpy (buf
, ", PA-RISC 2.0");
2690 if (e_flags
& EF_PARISC_TRAPNIL
)
2691 strcat (buf
, ", trapnil");
2692 if (e_flags
& EF_PARISC_EXT
)
2693 strcat (buf
, ", ext");
2694 if (e_flags
& EF_PARISC_LSB
)
2695 strcat (buf
, ", lsb");
2696 if (e_flags
& EF_PARISC_WIDE
)
2697 strcat (buf
, ", wide");
2698 if (e_flags
& EF_PARISC_NO_KABP
)
2699 strcat (buf
, ", no kabp");
2700 if (e_flags
& EF_PARISC_LAZYSWAP
)
2701 strcat (buf
, ", lazyswap");
2706 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2707 strcat (buf
, ", new calling convention");
2709 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2710 strcat (buf
, ", gnu calling convention");
2714 if ((e_flags
& EF_IA_64_ABI64
))
2715 strcat (buf
, ", 64-bit");
2717 strcat (buf
, ", 32-bit");
2718 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2719 strcat (buf
, ", reduced fp model");
2720 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2721 strcat (buf
, ", no function descriptors, constant gp");
2722 else if ((e_flags
& EF_IA_64_CONS_GP
))
2723 strcat (buf
, ", constant gp");
2724 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2725 strcat (buf
, ", absolute");
2726 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2728 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2729 strcat (buf
, ", vms_linkages");
2730 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2732 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2734 case EF_IA_64_VMS_COMCOD_WARNING
:
2735 strcat (buf
, ", warning");
2737 case EF_IA_64_VMS_COMCOD_ERROR
:
2738 strcat (buf
, ", error");
2740 case EF_IA_64_VMS_COMCOD_ABORT
:
2741 strcat (buf
, ", abort");
2750 if ((e_flags
& EF_VAX_NONPIC
))
2751 strcat (buf
, ", non-PIC");
2752 if ((e_flags
& EF_VAX_DFLOAT
))
2753 strcat (buf
, ", D-Float");
2754 if ((e_flags
& EF_VAX_GFLOAT
))
2755 strcat (buf
, ", G-Float");
2759 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2760 strcat (buf
, ", 64-bit doubles");
2761 if (e_flags
& E_FLAG_RX_DSP
)
2762 strcat (buf
, ", dsp");
2763 if (e_flags
& E_FLAG_RX_PID
)
2764 strcat (buf
, ", pid");
2765 if (e_flags
& E_FLAG_RX_ABI
)
2766 strcat (buf
, ", RX ABI");
2770 if (e_flags
& EF_S390_HIGH_GPRS
)
2771 strcat (buf
, ", highgprs");
2775 if ((e_flags
& EF_C6000_REL
))
2776 strcat (buf
, ", relocatable module");
2785 get_osabi_name (unsigned int osabi
)
2787 static char buff
[32];
2791 case ELFOSABI_NONE
: return "UNIX - System V";
2792 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2793 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2794 case ELFOSABI_GNU
: return "UNIX - GNU";
2795 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2796 case ELFOSABI_AIX
: return "UNIX - AIX";
2797 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2798 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2799 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2800 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2801 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2802 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2803 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2804 case ELFOSABI_AROS
: return "AROS";
2805 case ELFOSABI_FENIXOS
: return "FenixOS";
2808 switch (elf_header
.e_machine
)
2813 case ELFOSABI_ARM
: return "ARM";
2823 case ELFOSABI_STANDALONE
: return _("Standalone App");
2832 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2833 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2842 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2848 get_aarch64_segment_type (unsigned long type
)
2852 case PT_AARCH64_ARCHEXT
:
2853 return "AARCH64_ARCHEXT";
2862 get_arm_segment_type (unsigned long type
)
2876 get_mips_segment_type (unsigned long type
)
2880 case PT_MIPS_REGINFO
:
2882 case PT_MIPS_RTPROC
:
2884 case PT_MIPS_OPTIONS
:
2894 get_parisc_segment_type (unsigned long type
)
2898 case PT_HP_TLS
: return "HP_TLS";
2899 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2900 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2901 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2902 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2903 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2904 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2905 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2906 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2907 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2908 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2909 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2910 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2911 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2912 case PT_HP_STACK
: return "HP_STACK";
2913 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2914 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2915 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2916 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2925 get_ia64_segment_type (unsigned long type
)
2929 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2930 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2931 case PT_HP_TLS
: return "HP_TLS";
2932 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2933 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2934 case PT_IA_64_HP_STACK
: return "HP_STACK";
2943 get_tic6x_segment_type (unsigned long type
)
2947 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2956 get_segment_type (unsigned long p_type
)
2958 static char buff
[32];
2962 case PT_NULL
: return "NULL";
2963 case PT_LOAD
: return "LOAD";
2964 case PT_DYNAMIC
: return "DYNAMIC";
2965 case PT_INTERP
: return "INTERP";
2966 case PT_NOTE
: return "NOTE";
2967 case PT_SHLIB
: return "SHLIB";
2968 case PT_PHDR
: return "PHDR";
2969 case PT_TLS
: return "TLS";
2971 case PT_GNU_EH_FRAME
:
2972 return "GNU_EH_FRAME";
2973 case PT_GNU_STACK
: return "GNU_STACK";
2974 case PT_GNU_RELRO
: return "GNU_RELRO";
2977 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2979 const char * result
;
2981 switch (elf_header
.e_machine
)
2984 result
= get_aarch64_segment_type (p_type
);
2987 result
= get_arm_segment_type (p_type
);
2990 case EM_MIPS_RS3_LE
:
2991 result
= get_mips_segment_type (p_type
);
2994 result
= get_parisc_segment_type (p_type
);
2997 result
= get_ia64_segment_type (p_type
);
3000 result
= get_tic6x_segment_type (p_type
);
3010 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3012 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3014 const char * result
;
3016 switch (elf_header
.e_machine
)
3019 result
= get_parisc_segment_type (p_type
);
3022 result
= get_ia64_segment_type (p_type
);
3032 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3035 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3042 get_mips_section_type_name (unsigned int sh_type
)
3046 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3047 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3048 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3049 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3050 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3051 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3052 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3053 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3054 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3055 case SHT_MIPS_RELD
: return "MIPS_RELD";
3056 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3057 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3058 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3059 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3060 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3061 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3062 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3063 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3064 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3065 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3066 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3067 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3068 case SHT_MIPS_LINE
: return "MIPS_LINE";
3069 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3070 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3071 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3072 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3073 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3074 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3075 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3076 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3077 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3078 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3079 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3080 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3081 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3082 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3083 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3084 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3092 get_parisc_section_type_name (unsigned int sh_type
)
3096 case SHT_PARISC_EXT
: return "PARISC_EXT";
3097 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3098 case SHT_PARISC_DOC
: return "PARISC_DOC";
3099 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3100 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3101 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3102 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3110 get_ia64_section_type_name (unsigned int sh_type
)
3112 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3113 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3114 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3118 case SHT_IA_64_EXT
: return "IA_64_EXT";
3119 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3120 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3121 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3122 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3123 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3124 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3125 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3126 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3127 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3135 get_x86_64_section_type_name (unsigned int sh_type
)
3139 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3147 get_aarch64_section_type_name (unsigned int sh_type
)
3151 case SHT_AARCH64_ATTRIBUTES
:
3152 return "AARCH64_ATTRIBUTES";
3160 get_arm_section_type_name (unsigned int sh_type
)
3164 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3165 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3166 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3167 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3168 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3176 get_tic6x_section_type_name (unsigned int sh_type
)
3180 case SHT_C6000_UNWIND
:
3181 return "C6000_UNWIND";
3182 case SHT_C6000_PREEMPTMAP
:
3183 return "C6000_PREEMPTMAP";
3184 case SHT_C6000_ATTRIBUTES
:
3185 return "C6000_ATTRIBUTES";
3190 case SHT_TI_HANDLER
:
3191 return "TI_HANDLER";
3192 case SHT_TI_INITINFO
:
3193 return "TI_INITINFO";
3194 case SHT_TI_PHATTRS
:
3195 return "TI_PHATTRS";
3203 get_section_type_name (unsigned int sh_type
)
3205 static char buff
[32];
3209 case SHT_NULL
: return "NULL";
3210 case SHT_PROGBITS
: return "PROGBITS";
3211 case SHT_SYMTAB
: return "SYMTAB";
3212 case SHT_STRTAB
: return "STRTAB";
3213 case SHT_RELA
: return "RELA";
3214 case SHT_HASH
: return "HASH";
3215 case SHT_DYNAMIC
: return "DYNAMIC";
3216 case SHT_NOTE
: return "NOTE";
3217 case SHT_NOBITS
: return "NOBITS";
3218 case SHT_REL
: return "REL";
3219 case SHT_SHLIB
: return "SHLIB";
3220 case SHT_DYNSYM
: return "DYNSYM";
3221 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3222 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3223 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3224 case SHT_GNU_HASH
: return "GNU_HASH";
3225 case SHT_GROUP
: return "GROUP";
3226 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3227 case SHT_GNU_verdef
: return "VERDEF";
3228 case SHT_GNU_verneed
: return "VERNEED";
3229 case SHT_GNU_versym
: return "VERSYM";
3230 case 0x6ffffff0: return "VERSYM";
3231 case 0x6ffffffc: return "VERDEF";
3232 case 0x7ffffffd: return "AUXILIARY";
3233 case 0x7fffffff: return "FILTER";
3234 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3237 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3239 const char * result
;
3241 switch (elf_header
.e_machine
)
3244 case EM_MIPS_RS3_LE
:
3245 result
= get_mips_section_type_name (sh_type
);
3248 result
= get_parisc_section_type_name (sh_type
);
3251 result
= get_ia64_section_type_name (sh_type
);
3256 result
= get_x86_64_section_type_name (sh_type
);
3259 result
= get_aarch64_section_type_name (sh_type
);
3262 result
= get_arm_section_type_name (sh_type
);
3265 result
= get_tic6x_section_type_name (sh_type
);
3275 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3277 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3279 const char * result
;
3281 switch (elf_header
.e_machine
)
3284 result
= get_ia64_section_type_name (sh_type
);
3294 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3296 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3297 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3299 /* This message is probably going to be displayed in a 15
3300 character wide field, so put the hex value first. */
3301 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3307 #define OPTION_DEBUG_DUMP 512
3308 #define OPTION_DYN_SYMS 513
3309 #define OPTION_DWARF_DEPTH 514
3310 #define OPTION_DWARF_START 515
3311 #define OPTION_DWARF_CHECK 516
3313 static struct option options
[] =
3315 {"all", no_argument
, 0, 'a'},
3316 {"file-header", no_argument
, 0, 'h'},
3317 {"program-headers", no_argument
, 0, 'l'},
3318 {"headers", no_argument
, 0, 'e'},
3319 {"histogram", no_argument
, 0, 'I'},
3320 {"segments", no_argument
, 0, 'l'},
3321 {"sections", no_argument
, 0, 'S'},
3322 {"section-headers", no_argument
, 0, 'S'},
3323 {"section-groups", no_argument
, 0, 'g'},
3324 {"section-details", no_argument
, 0, 't'},
3325 {"full-section-name",no_argument
, 0, 'N'},
3326 {"symbols", no_argument
, 0, 's'},
3327 {"syms", no_argument
, 0, 's'},
3328 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3329 {"relocs", no_argument
, 0, 'r'},
3330 {"notes", no_argument
, 0, 'n'},
3331 {"dynamic", no_argument
, 0, 'd'},
3332 {"arch-specific", no_argument
, 0, 'A'},
3333 {"version-info", no_argument
, 0, 'V'},
3334 {"use-dynamic", no_argument
, 0, 'D'},
3335 {"unwind", no_argument
, 0, 'u'},
3336 {"archive-index", no_argument
, 0, 'c'},
3337 {"hex-dump", required_argument
, 0, 'x'},
3338 {"relocated-dump", required_argument
, 0, 'R'},
3339 {"string-dump", required_argument
, 0, 'p'},
3340 #ifdef SUPPORT_DISASSEMBLY
3341 {"instruction-dump", required_argument
, 0, 'i'},
3343 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3345 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3346 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3347 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3349 {"version", no_argument
, 0, 'v'},
3350 {"wide", no_argument
, 0, 'W'},
3351 {"help", no_argument
, 0, 'H'},
3352 {0, no_argument
, 0, 0}
3356 usage (FILE * stream
)
3358 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3359 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3360 fprintf (stream
, _(" Options are:\n\
3361 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3362 -h --file-header Display the ELF file header\n\
3363 -l --program-headers Display the program headers\n\
3364 --segments An alias for --program-headers\n\
3365 -S --section-headers Display the sections' header\n\
3366 --sections An alias for --section-headers\n\
3367 -g --section-groups Display the section groups\n\
3368 -t --section-details Display the section details\n\
3369 -e --headers Equivalent to: -h -l -S\n\
3370 -s --syms Display the symbol table\n\
3371 --symbols An alias for --syms\n\
3372 --dyn-syms Display the dynamic symbol table\n\
3373 -n --notes Display the core notes (if present)\n\
3374 -r --relocs Display the relocations (if present)\n\
3375 -u --unwind Display the unwind info (if present)\n\
3376 -d --dynamic Display the dynamic section (if present)\n\
3377 -V --version-info Display the version sections (if present)\n\
3378 -A --arch-specific Display architecture specific information (if any)\n\
3379 -c --archive-index Display the symbol/file index in an archive\n\
3380 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3381 -x --hex-dump=<number|name>\n\
3382 Dump the contents of section <number|name> as bytes\n\
3383 -p --string-dump=<number|name>\n\
3384 Dump the contents of section <number|name> as strings\n\
3385 -R --relocated-dump=<number|name>\n\
3386 Dump the contents of section <number|name> as relocated bytes\n\
3387 -w[lLiaprmfFsoRt] or\n\
3388 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3389 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3390 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3392 Display the contents of DWARF2 debug sections\n"));
3393 fprintf (stream
, _("\
3394 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3395 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3397 #ifdef SUPPORT_DISASSEMBLY
3398 fprintf (stream
, _("\
3399 -i --instruction-dump=<number|name>\n\
3400 Disassemble the contents of section <number|name>\n"));
3402 fprintf (stream
, _("\
3403 -I --histogram Display histogram of bucket list lengths\n\
3404 -W --wide Allow output width to exceed 80 characters\n\
3405 @<file> Read options from <file>\n\
3406 -H --help Display this information\n\
3407 -v --version Display the version number of readelf\n"));
3409 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3410 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3412 exit (stream
== stdout
? 0 : 1);
3415 /* Record the fact that the user wants the contents of section number
3416 SECTION to be displayed using the method(s) encoded as flags bits
3417 in TYPE. Note, TYPE can be zero if we are creating the array for
3421 request_dump_bynumber (unsigned int section
, dump_type type
)
3423 if (section
>= num_dump_sects
)
3425 dump_type
* new_dump_sects
;
3427 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3428 sizeof (* dump_sects
));
3430 if (new_dump_sects
== NULL
)
3431 error (_("Out of memory allocating dump request table.\n"));
3434 /* Copy current flag settings. */
3435 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3439 dump_sects
= new_dump_sects
;
3440 num_dump_sects
= section
+ 1;
3445 dump_sects
[section
] |= type
;
3450 /* Request a dump by section name. */
3453 request_dump_byname (const char * section
, dump_type type
)
3455 struct dump_list_entry
* new_request
;
3457 new_request
= (struct dump_list_entry
*)
3458 malloc (sizeof (struct dump_list_entry
));
3460 error (_("Out of memory allocating dump request table.\n"));
3462 new_request
->name
= strdup (section
);
3463 if (!new_request
->name
)
3464 error (_("Out of memory allocating dump request table.\n"));
3466 new_request
->type
= type
;
3468 new_request
->next
= dump_sects_byname
;
3469 dump_sects_byname
= new_request
;
3473 request_dump (dump_type type
)
3479 section
= strtoul (optarg
, & cp
, 0);
3481 if (! *cp
&& section
>= 0)
3482 request_dump_bynumber (section
, type
);
3484 request_dump_byname (optarg
, type
);
3489 parse_args (int argc
, char ** argv
)
3496 while ((c
= getopt_long
3497 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3515 do_section_groups
++;
3523 do_section_groups
++;
3528 do_section_details
++;
3572 request_dump (HEX_DUMP
);
3575 request_dump (STRING_DUMP
);
3578 request_dump (RELOC_DUMP
);
3585 dwarf_select_sections_all ();
3590 dwarf_select_sections_by_letters (optarg
);
3593 case OPTION_DEBUG_DUMP
:
3600 dwarf_select_sections_by_names (optarg
);
3603 case OPTION_DWARF_DEPTH
:
3607 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3610 case OPTION_DWARF_START
:
3614 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3617 case OPTION_DWARF_CHECK
:
3620 case OPTION_DYN_SYMS
:
3623 #ifdef SUPPORT_DISASSEMBLY
3625 request_dump (DISASS_DUMP
);
3629 print_version (program_name
);
3638 /* xgettext:c-format */
3639 error (_("Invalid option '-%c'\n"), c
);
3646 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3647 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3648 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3649 && !do_section_groups
&& !do_archive_index
3654 warn (_("Nothing to do.\n"));
3660 get_elf_class (unsigned int elf_class
)
3662 static char buff
[32];
3666 case ELFCLASSNONE
: return _("none");
3667 case ELFCLASS32
: return "ELF32";
3668 case ELFCLASS64
: return "ELF64";
3670 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3676 get_data_encoding (unsigned int encoding
)
3678 static char buff
[32];
3682 case ELFDATANONE
: return _("none");
3683 case ELFDATA2LSB
: return _("2's complement, little endian");
3684 case ELFDATA2MSB
: return _("2's complement, big endian");
3686 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3691 /* Decode the data held in 'elf_header'. */
3694 process_file_header (void)
3696 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3697 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3698 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3699 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3702 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3706 init_dwarf_regnames (elf_header
.e_machine
);
3712 printf (_("ELF Header:\n"));
3713 printf (_(" Magic: "));
3714 for (i
= 0; i
< EI_NIDENT
; i
++)
3715 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3717 printf (_(" Class: %s\n"),
3718 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3719 printf (_(" Data: %s\n"),
3720 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3721 printf (_(" Version: %d %s\n"),
3722 elf_header
.e_ident
[EI_VERSION
],
3723 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3725 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3726 ? _("<unknown: %lx>")
3728 printf (_(" OS/ABI: %s\n"),
3729 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3730 printf (_(" ABI Version: %d\n"),
3731 elf_header
.e_ident
[EI_ABIVERSION
]);
3732 printf (_(" Type: %s\n"),
3733 get_file_type (elf_header
.e_type
));
3734 printf (_(" Machine: %s\n"),
3735 get_machine_name (elf_header
.e_machine
));
3736 printf (_(" Version: 0x%lx\n"),
3737 (unsigned long) elf_header
.e_version
);
3739 printf (_(" Entry point address: "));
3740 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3741 printf (_("\n Start of program headers: "));
3742 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3743 printf (_(" (bytes into file)\n Start of section headers: "));
3744 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3745 printf (_(" (bytes into file)\n"));
3747 printf (_(" Flags: 0x%lx%s\n"),
3748 (unsigned long) elf_header
.e_flags
,
3749 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3750 printf (_(" Size of this header: %ld (bytes)\n"),
3751 (long) elf_header
.e_ehsize
);
3752 printf (_(" Size of program headers: %ld (bytes)\n"),
3753 (long) elf_header
.e_phentsize
);
3754 printf (_(" Number of program headers: %ld"),
3755 (long) elf_header
.e_phnum
);
3756 if (section_headers
!= NULL
3757 && elf_header
.e_phnum
== PN_XNUM
3758 && section_headers
[0].sh_info
!= 0)
3759 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3760 putc ('\n', stdout
);
3761 printf (_(" Size of section headers: %ld (bytes)\n"),
3762 (long) elf_header
.e_shentsize
);
3763 printf (_(" Number of section headers: %ld"),
3764 (long) elf_header
.e_shnum
);
3765 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3766 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3767 putc ('\n', stdout
);
3768 printf (_(" Section header string table index: %ld"),
3769 (long) elf_header
.e_shstrndx
);
3770 if (section_headers
!= NULL
3771 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3772 printf (" (%u)", section_headers
[0].sh_link
);
3773 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3774 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3775 printf (_(" <corrupt: out of range>"));
3776 putc ('\n', stdout
);
3779 if (section_headers
!= NULL
)
3781 if (elf_header
.e_phnum
== PN_XNUM
3782 && section_headers
[0].sh_info
!= 0)
3783 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3784 if (elf_header
.e_shnum
== SHN_UNDEF
)
3785 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3786 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3787 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3788 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3789 elf_header
.e_shstrndx
= SHN_UNDEF
;
3790 free (section_headers
);
3791 section_headers
= NULL
;
3799 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3801 Elf32_External_Phdr
* phdrs
;
3802 Elf32_External_Phdr
* external
;
3803 Elf_Internal_Phdr
* internal
;
3806 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3807 elf_header
.e_phentsize
,
3809 _("program headers"));
3813 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3814 i
< elf_header
.e_phnum
;
3815 i
++, internal
++, external
++)
3817 internal
->p_type
= BYTE_GET (external
->p_type
);
3818 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3819 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3820 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3821 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3822 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3823 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3824 internal
->p_align
= BYTE_GET (external
->p_align
);
3833 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3835 Elf64_External_Phdr
* phdrs
;
3836 Elf64_External_Phdr
* external
;
3837 Elf_Internal_Phdr
* internal
;
3840 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3841 elf_header
.e_phentsize
,
3843 _("program headers"));
3847 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3848 i
< elf_header
.e_phnum
;
3849 i
++, internal
++, external
++)
3851 internal
->p_type
= BYTE_GET (external
->p_type
);
3852 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3853 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3854 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3855 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3856 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3857 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3858 internal
->p_align
= BYTE_GET (external
->p_align
);
3866 /* Returns 1 if the program headers were read into `program_headers'. */
3869 get_program_headers (FILE * file
)
3871 Elf_Internal_Phdr
* phdrs
;
3873 /* Check cache of prior read. */
3874 if (program_headers
!= NULL
)
3877 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3878 sizeof (Elf_Internal_Phdr
));
3882 error (_("Out of memory\n"));
3887 ? get_32bit_program_headers (file
, phdrs
)
3888 : get_64bit_program_headers (file
, phdrs
))
3890 program_headers
= phdrs
;
3898 /* Returns 1 if the program headers were loaded. */
3901 process_program_headers (FILE * file
)
3903 Elf_Internal_Phdr
* segment
;
3906 if (elf_header
.e_phnum
== 0)
3908 /* PR binutils/12467. */
3909 if (elf_header
.e_phoff
!= 0)
3910 warn (_("possibly corrupt ELF header - it has a non-zero program"
3911 " header offset, but no program headers"));
3912 else if (do_segments
)
3913 printf (_("\nThere are no program headers in this file.\n"));
3917 if (do_segments
&& !do_header
)
3919 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3920 printf (_("Entry point "));
3921 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3922 printf (_("\nThere are %d program headers, starting at offset "),
3923 elf_header
.e_phnum
);
3924 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3928 if (! get_program_headers (file
))
3933 if (elf_header
.e_phnum
> 1)
3934 printf (_("\nProgram Headers:\n"));
3936 printf (_("\nProgram Headers:\n"));
3940 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3943 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3947 (_(" Type Offset VirtAddr PhysAddr\n"));
3949 (_(" FileSiz MemSiz Flags Align\n"));
3956 for (i
= 0, segment
= program_headers
;
3957 i
< elf_header
.e_phnum
;
3962 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3966 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3967 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3968 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3969 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3970 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3972 (segment
->p_flags
& PF_R
? 'R' : ' '),
3973 (segment
->p_flags
& PF_W
? 'W' : ' '),
3974 (segment
->p_flags
& PF_X
? 'E' : ' '));
3975 printf ("%#lx", (unsigned long) segment
->p_align
);
3979 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3980 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3983 print_vma (segment
->p_offset
, FULL_HEX
);
3987 print_vma (segment
->p_vaddr
, FULL_HEX
);
3989 print_vma (segment
->p_paddr
, FULL_HEX
);
3992 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3993 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3996 print_vma (segment
->p_filesz
, FULL_HEX
);
4000 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4001 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4004 print_vma (segment
->p_memsz
, FULL_HEX
);
4008 (segment
->p_flags
& PF_R
? 'R' : ' '),
4009 (segment
->p_flags
& PF_W
? 'W' : ' '),
4010 (segment
->p_flags
& PF_X
? 'E' : ' '));
4012 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4013 printf ("%#lx", (unsigned long) segment
->p_align
);
4016 print_vma (segment
->p_align
, PREFIX_HEX
);
4021 print_vma (segment
->p_offset
, FULL_HEX
);
4023 print_vma (segment
->p_vaddr
, FULL_HEX
);
4025 print_vma (segment
->p_paddr
, FULL_HEX
);
4027 print_vma (segment
->p_filesz
, FULL_HEX
);
4029 print_vma (segment
->p_memsz
, FULL_HEX
);
4031 (segment
->p_flags
& PF_R
? 'R' : ' '),
4032 (segment
->p_flags
& PF_W
? 'W' : ' '),
4033 (segment
->p_flags
& PF_X
? 'E' : ' '));
4034 print_vma (segment
->p_align
, HEX
);
4038 switch (segment
->p_type
)
4042 error (_("more than one dynamic segment\n"));
4044 /* By default, assume that the .dynamic section is the first
4045 section in the DYNAMIC segment. */
4046 dynamic_addr
= segment
->p_offset
;
4047 dynamic_size
= segment
->p_filesz
;
4049 /* Try to locate the .dynamic section. If there is
4050 a section header table, we can easily locate it. */
4051 if (section_headers
!= NULL
)
4053 Elf_Internal_Shdr
* sec
;
4055 sec
= find_section (".dynamic");
4056 if (sec
== NULL
|| sec
->sh_size
== 0)
4058 /* A corresponding .dynamic section is expected, but on
4059 IA-64/OpenVMS it is OK for it to be missing. */
4060 if (!is_ia64_vms ())
4061 error (_("no .dynamic section in the dynamic segment\n"));
4065 if (sec
->sh_type
== SHT_NOBITS
)
4071 dynamic_addr
= sec
->sh_offset
;
4072 dynamic_size
= sec
->sh_size
;
4074 if (dynamic_addr
< segment
->p_offset
4075 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4076 warn (_("the .dynamic section is not contained"
4077 " within the dynamic segment\n"));
4078 else if (dynamic_addr
> segment
->p_offset
)
4079 warn (_("the .dynamic section is not the first section"
4080 " in the dynamic segment.\n"));
4085 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4087 error (_("Unable to find program interpreter name\n"));
4091 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4093 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4094 error (_("Internal error: failed to create format string to display program interpreter\n"));
4096 program_interpreter
[0] = 0;
4097 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4098 error (_("Unable to read program interpreter name\n"));
4101 printf (_("\n [Requesting program interpreter: %s]"),
4102 program_interpreter
);
4108 putc ('\n', stdout
);
4111 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4113 printf (_("\n Section to Segment mapping:\n"));
4114 printf (_(" Segment Sections...\n"));
4116 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4119 Elf_Internal_Shdr
* section
;
4121 segment
= program_headers
+ i
;
4122 section
= section_headers
+ 1;
4124 printf (" %2.2d ", i
);
4126 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4128 if (!ELF_TBSS_SPECIAL (section
, segment
)
4129 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4130 printf ("%s ", SECTION_NAME (section
));
4141 /* Find the file offset corresponding to VMA by using the program headers. */
4144 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4146 Elf_Internal_Phdr
* seg
;
4148 if (! get_program_headers (file
))
4150 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4154 for (seg
= program_headers
;
4155 seg
< program_headers
+ elf_header
.e_phnum
;
4158 if (seg
->p_type
!= PT_LOAD
)
4161 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4162 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4163 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4166 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4167 (unsigned long) vma
);
4173 get_32bit_section_headers (FILE * file
, unsigned int num
)
4175 Elf32_External_Shdr
* shdrs
;
4176 Elf_Internal_Shdr
* internal
;
4179 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4180 elf_header
.e_shentsize
, num
,
4181 _("section headers"));
4185 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4186 sizeof (Elf_Internal_Shdr
));
4188 if (section_headers
== NULL
)
4190 error (_("Out of memory\n"));
4194 for (i
= 0, internal
= section_headers
;
4198 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4199 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4200 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4201 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4202 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4203 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4204 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4205 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4206 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4207 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4216 get_64bit_section_headers (FILE * file
, unsigned int num
)
4218 Elf64_External_Shdr
* shdrs
;
4219 Elf_Internal_Shdr
* internal
;
4222 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4223 elf_header
.e_shentsize
, num
,
4224 _("section headers"));
4228 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4229 sizeof (Elf_Internal_Shdr
));
4231 if (section_headers
== NULL
)
4233 error (_("Out of memory\n"));
4237 for (i
= 0, internal
= section_headers
;
4241 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4242 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4243 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4244 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4245 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4246 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4247 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4248 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4249 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4250 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4258 static Elf_Internal_Sym
*
4259 get_32bit_elf_symbols (FILE * file
,
4260 Elf_Internal_Shdr
* section
,
4261 unsigned long * num_syms_return
)
4263 unsigned long number
= 0;
4264 Elf32_External_Sym
* esyms
= NULL
;
4265 Elf_External_Sym_Shndx
* shndx
= NULL
;
4266 Elf_Internal_Sym
* isyms
= NULL
;
4267 Elf_Internal_Sym
* psym
;
4270 /* Run some sanity checks first. */
4271 if (section
->sh_entsize
== 0)
4273 error (_("sh_entsize is zero\n"));
4277 number
= section
->sh_size
/ section
->sh_entsize
;
4279 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4281 error (_("Invalid sh_entsize\n"));
4285 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4286 section
->sh_size
, _("symbols"));
4291 if (symtab_shndx_hdr
!= NULL
4292 && (symtab_shndx_hdr
->sh_link
4293 == (unsigned long) (section
- section_headers
)))
4295 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4296 symtab_shndx_hdr
->sh_offset
,
4297 1, symtab_shndx_hdr
->sh_size
,
4298 _("symbol table section indicies"));
4303 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4307 error (_("Out of memory\n"));
4311 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4313 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4314 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4315 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4316 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4317 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4319 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4320 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4321 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4322 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4323 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4332 if (num_syms_return
!= NULL
)
4333 * num_syms_return
= isyms
== NULL
? 0 : number
;
4338 static Elf_Internal_Sym
*
4339 get_64bit_elf_symbols (FILE * file
,
4340 Elf_Internal_Shdr
* section
,
4341 unsigned long * num_syms_return
)
4343 unsigned long number
= 0;
4344 Elf64_External_Sym
* esyms
= NULL
;
4345 Elf_External_Sym_Shndx
* shndx
= NULL
;
4346 Elf_Internal_Sym
* isyms
= NULL
;
4347 Elf_Internal_Sym
* psym
;
4350 /* Run some sanity checks first. */
4351 if (section
->sh_entsize
== 0)
4353 error (_("sh_entsize is zero\n"));
4357 number
= section
->sh_size
/ section
->sh_entsize
;
4359 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4361 error (_("Invalid sh_entsize\n"));
4365 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4366 section
->sh_size
, _("symbols"));
4370 if (symtab_shndx_hdr
!= NULL
4371 && (symtab_shndx_hdr
->sh_link
4372 == (unsigned long) (section
- section_headers
)))
4374 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4375 symtab_shndx_hdr
->sh_offset
,
4376 1, symtab_shndx_hdr
->sh_size
,
4377 _("symbol table section indicies"));
4382 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4386 error (_("Out of memory\n"));
4390 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4392 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4393 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4394 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4395 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4397 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4399 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4400 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4401 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4403 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4404 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4413 if (num_syms_return
!= NULL
)
4414 * num_syms_return
= isyms
== NULL
? 0 : number
;
4420 get_elf_section_flags (bfd_vma sh_flags
)
4422 static char buff
[1024];
4424 int field_size
= is_32bit_elf
? 8 : 16;
4426 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4427 bfd_vma os_flags
= 0;
4428 bfd_vma proc_flags
= 0;
4429 bfd_vma unknown_flags
= 0;
4437 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4438 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4439 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4440 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4441 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4442 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4443 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4444 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4445 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4446 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4447 /* IA-64 specific. */
4448 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4449 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4450 /* IA-64 OpenVMS specific. */
4451 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4452 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4453 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4454 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4455 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4456 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4458 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4459 /* SPARC specific. */
4460 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4463 if (do_section_details
)
4465 sprintf (buff
, "[%*.*lx]: ",
4466 field_size
, field_size
, (unsigned long) sh_flags
);
4467 p
+= field_size
+ 4;
4474 flag
= sh_flags
& - sh_flags
;
4477 if (do_section_details
)
4481 case SHF_WRITE
: sindex
= 0; break;
4482 case SHF_ALLOC
: sindex
= 1; break;
4483 case SHF_EXECINSTR
: sindex
= 2; break;
4484 case SHF_MERGE
: sindex
= 3; break;
4485 case SHF_STRINGS
: sindex
= 4; break;
4486 case SHF_INFO_LINK
: sindex
= 5; break;
4487 case SHF_LINK_ORDER
: sindex
= 6; break;
4488 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4489 case SHF_GROUP
: sindex
= 8; break;
4490 case SHF_TLS
: sindex
= 9; break;
4491 case SHF_EXCLUDE
: sindex
= 18; break;
4495 switch (elf_header
.e_machine
)
4498 if (flag
== SHF_IA_64_SHORT
)
4500 else if (flag
== SHF_IA_64_NORECOV
)
4503 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4506 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4507 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4508 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4509 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4510 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4511 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4522 case EM_OLD_SPARCV9
:
4523 case EM_SPARC32PLUS
:
4526 if (flag
== SHF_ORDERED
)
4536 if (p
!= buff
+ field_size
+ 4)
4538 if (size
< (10 + 2))
4545 size
-= flags
[sindex
].len
;
4546 p
= stpcpy (p
, flags
[sindex
].str
);
4548 else if (flag
& SHF_MASKOS
)
4550 else if (flag
& SHF_MASKPROC
)
4553 unknown_flags
|= flag
;
4559 case SHF_WRITE
: *p
= 'W'; break;
4560 case SHF_ALLOC
: *p
= 'A'; break;
4561 case SHF_EXECINSTR
: *p
= 'X'; break;
4562 case SHF_MERGE
: *p
= 'M'; break;
4563 case SHF_STRINGS
: *p
= 'S'; break;
4564 case SHF_INFO_LINK
: *p
= 'I'; break;
4565 case SHF_LINK_ORDER
: *p
= 'L'; break;
4566 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4567 case SHF_GROUP
: *p
= 'G'; break;
4568 case SHF_TLS
: *p
= 'T'; break;
4569 case SHF_EXCLUDE
: *p
= 'E'; break;
4572 if ((elf_header
.e_machine
== EM_X86_64
4573 || elf_header
.e_machine
== EM_L1OM
4574 || elf_header
.e_machine
== EM_K1OM
)
4575 && flag
== SHF_X86_64_LARGE
)
4577 else if (flag
& SHF_MASKOS
)
4580 sh_flags
&= ~ SHF_MASKOS
;
4582 else if (flag
& SHF_MASKPROC
)
4585 sh_flags
&= ~ SHF_MASKPROC
;
4595 if (do_section_details
)
4599 size
-= 5 + field_size
;
4600 if (p
!= buff
+ field_size
+ 4)
4608 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4609 (unsigned long) os_flags
);
4610 p
+= 5 + field_size
;
4614 size
-= 7 + field_size
;
4615 if (p
!= buff
+ field_size
+ 4)
4623 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4624 (unsigned long) proc_flags
);
4625 p
+= 7 + field_size
;
4629 size
-= 10 + field_size
;
4630 if (p
!= buff
+ field_size
+ 4)
4638 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4639 (unsigned long) unknown_flags
);
4640 p
+= 10 + field_size
;
4649 process_section_headers (FILE * file
)
4651 Elf_Internal_Shdr
* section
;
4654 section_headers
= NULL
;
4656 if (elf_header
.e_shnum
== 0)
4658 /* PR binutils/12467. */
4659 if (elf_header
.e_shoff
!= 0)
4660 warn (_("possibly corrupt ELF file header - it has a non-zero"
4661 " section header offset, but no section headers\n"));
4662 else if (do_sections
)
4663 printf (_("\nThere are no sections in this file.\n"));
4668 if (do_sections
&& !do_header
)
4669 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4670 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4674 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4677 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4680 /* Read in the string table, so that we have names to display. */
4681 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4682 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4684 section
= section_headers
+ elf_header
.e_shstrndx
;
4686 if (section
->sh_size
!= 0)
4688 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4689 1, section
->sh_size
,
4692 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4696 /* Scan the sections for the dynamic symbol table
4697 and dynamic string table and debug sections. */
4698 dynamic_symbols
= NULL
;
4699 dynamic_strings
= NULL
;
4700 dynamic_syminfo
= NULL
;
4701 symtab_shndx_hdr
= NULL
;
4703 eh_addr_size
= is_32bit_elf
? 4 : 8;
4704 switch (elf_header
.e_machine
)
4707 case EM_MIPS_RS3_LE
:
4708 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4709 FDE addresses. However, the ABI also has a semi-official ILP32
4710 variant for which the normal FDE address size rules apply.
4712 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4713 section, where XX is the size of longs in bits. Unfortunately,
4714 earlier compilers provided no way of distinguishing ILP32 objects
4715 from LP64 objects, so if there's any doubt, we should assume that
4716 the official LP64 form is being used. */
4717 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4718 && find_section (".gcc_compiled_long32") == NULL
)
4724 switch (elf_header
.e_flags
& EF_H8_MACH
)
4726 case E_H8_MACH_H8300
:
4727 case E_H8_MACH_H8300HN
:
4728 case E_H8_MACH_H8300SN
:
4729 case E_H8_MACH_H8300SXN
:
4732 case E_H8_MACH_H8300H
:
4733 case E_H8_MACH_H8300S
:
4734 case E_H8_MACH_H8300SX
:
4742 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4744 case EF_M32C_CPU_M16C
:
4751 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4754 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
4755 if (section->sh_entsize != expected_entsize) \
4757 error (_("Section %d has invalid an sh_entsize of %" BFD_VMA_FMT "x\n"), \
4758 i, section->sh_entsize); \
4759 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4760 (int) expected_entsize); \
4761 section->sh_entsize = expected_entsize; \
4766 #define CHECK_ENTSIZE(section, i, type) \
4767 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4768 sizeof (Elf64_External_##type))
4770 for (i
= 0, section
= section_headers
;
4771 i
< elf_header
.e_shnum
;
4774 char * name
= SECTION_NAME (section
);
4776 if (section
->sh_type
== SHT_DYNSYM
)
4778 if (dynamic_symbols
!= NULL
)
4780 error (_("File contains multiple dynamic symbol tables\n"));
4784 CHECK_ENTSIZE (section
, i
, Sym
);
4785 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4787 else if (section
->sh_type
== SHT_STRTAB
4788 && streq (name
, ".dynstr"))
4790 if (dynamic_strings
!= NULL
)
4792 error (_("File contains multiple dynamic string tables\n"));
4796 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4797 1, section
->sh_size
,
4798 _("dynamic strings"));
4799 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4801 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4803 if (symtab_shndx_hdr
!= NULL
)
4805 error (_("File contains multiple symtab shndx tables\n"));
4808 symtab_shndx_hdr
= section
;
4810 else if (section
->sh_type
== SHT_SYMTAB
)
4811 CHECK_ENTSIZE (section
, i
, Sym
);
4812 else if (section
->sh_type
== SHT_GROUP
)
4813 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4814 else if (section
->sh_type
== SHT_REL
)
4815 CHECK_ENTSIZE (section
, i
, Rel
);
4816 else if (section
->sh_type
== SHT_RELA
)
4817 CHECK_ENTSIZE (section
, i
, Rela
);
4818 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4819 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4820 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4821 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4822 || do_debug_addr
|| do_debug_cu_index
)
4823 && (const_strneq (name
, ".debug_")
4824 || const_strneq (name
, ".zdebug_")))
4827 name
+= sizeof (".zdebug_") - 1;
4829 name
+= sizeof (".debug_") - 1;
4832 || (do_debug_info
&& const_strneq (name
, "info"))
4833 || (do_debug_info
&& const_strneq (name
, "types"))
4834 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4835 || (do_debug_lines
&& const_strneq (name
, "line"))
4836 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4837 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4838 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4839 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4840 || (do_debug_frames
&& const_strneq (name
, "frame"))
4841 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4842 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4843 || (do_debug_str
&& const_strneq (name
, "str"))
4844 || (do_debug_loc
&& const_strneq (name
, "loc"))
4845 || (do_debug_addr
&& const_strneq (name
, "addr"))
4846 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4847 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4849 request_dump_bynumber (i
, DEBUG_DUMP
);
4851 /* Linkonce section to be combined with .debug_info at link time. */
4852 else if ((do_debugging
|| do_debug_info
)
4853 && const_strneq (name
, ".gnu.linkonce.wi."))
4854 request_dump_bynumber (i
, DEBUG_DUMP
);
4855 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4856 request_dump_bynumber (i
, DEBUG_DUMP
);
4857 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4858 request_dump_bynumber (i
, DEBUG_DUMP
);
4859 /* Trace sections for Itanium VMS. */
4860 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4861 || do_trace_aranges
)
4862 && const_strneq (name
, ".trace_"))
4864 name
+= sizeof (".trace_") - 1;
4867 || (do_trace_info
&& streq (name
, "info"))
4868 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4869 || (do_trace_aranges
&& streq (name
, "aranges"))
4871 request_dump_bynumber (i
, DEBUG_DUMP
);
4879 if (elf_header
.e_shnum
> 1)
4880 printf (_("\nSection Headers:\n"));
4882 printf (_("\nSection Header:\n"));
4886 if (do_section_details
)
4888 printf (_(" [Nr] Name\n"));
4889 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4893 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4897 if (do_section_details
)
4899 printf (_(" [Nr] Name\n"));
4900 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4904 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4908 if (do_section_details
)
4910 printf (_(" [Nr] Name\n"));
4911 printf (_(" Type Address Offset Link\n"));
4912 printf (_(" Size EntSize Info Align\n"));
4916 printf (_(" [Nr] Name Type Address Offset\n"));
4917 printf (_(" Size EntSize Flags Link Info Align\n"));
4921 if (do_section_details
)
4922 printf (_(" Flags\n"));
4924 for (i
= 0, section
= section_headers
;
4925 i
< elf_header
.e_shnum
;
4928 printf (" [%2u] ", i
);
4929 if (do_section_details
)
4931 print_symbol (INT_MAX
, SECTION_NAME (section
));
4936 print_symbol (-17, SECTION_NAME (section
));
4939 printf (do_wide
? " %-15s " : " %-15.15s ",
4940 get_section_type_name (section
->sh_type
));
4944 const char * link_too_big
= NULL
;
4946 print_vma (section
->sh_addr
, LONG_HEX
);
4948 printf ( " %6.6lx %6.6lx %2.2lx",
4949 (unsigned long) section
->sh_offset
,
4950 (unsigned long) section
->sh_size
,
4951 (unsigned long) section
->sh_entsize
);
4953 if (do_section_details
)
4954 fputs (" ", stdout
);
4956 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4958 if (section
->sh_link
>= elf_header
.e_shnum
)
4961 /* The sh_link value is out of range. Normally this indicates
4962 an error but it can have special values in Solaris binaries. */
4963 switch (elf_header
.e_machine
)
4970 case EM_OLD_SPARCV9
:
4971 case EM_SPARC32PLUS
:
4974 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4975 link_too_big
= "BEFORE";
4976 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4977 link_too_big
= "AFTER";
4984 if (do_section_details
)
4986 if (link_too_big
!= NULL
&& * link_too_big
)
4987 printf ("<%s> ", link_too_big
);
4989 printf ("%2u ", section
->sh_link
);
4990 printf ("%3u %2lu\n", section
->sh_info
,
4991 (unsigned long) section
->sh_addralign
);
4994 printf ("%2u %3u %2lu\n",
4997 (unsigned long) section
->sh_addralign
);
4999 if (link_too_big
&& ! * link_too_big
)
5000 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5001 i
, section
->sh_link
);
5005 print_vma (section
->sh_addr
, LONG_HEX
);
5007 if ((long) section
->sh_offset
== section
->sh_offset
)
5008 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5012 print_vma (section
->sh_offset
, LONG_HEX
);
5015 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5016 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5020 print_vma (section
->sh_size
, LONG_HEX
);
5023 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5024 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5028 print_vma (section
->sh_entsize
, LONG_HEX
);
5031 if (do_section_details
)
5032 fputs (" ", stdout
);
5034 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5036 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5038 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5039 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5042 print_vma (section
->sh_addralign
, DEC
);
5046 else if (do_section_details
)
5048 printf (" %-15.15s ",
5049 get_section_type_name (section
->sh_type
));
5050 print_vma (section
->sh_addr
, LONG_HEX
);
5051 if ((long) section
->sh_offset
== section
->sh_offset
)
5052 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5056 print_vma (section
->sh_offset
, LONG_HEX
);
5058 printf (" %u\n ", section
->sh_link
);
5059 print_vma (section
->sh_size
, LONG_HEX
);
5061 print_vma (section
->sh_entsize
, LONG_HEX
);
5063 printf (" %-16u %lu\n",
5065 (unsigned long) section
->sh_addralign
);
5070 print_vma (section
->sh_addr
, LONG_HEX
);
5071 if ((long) section
->sh_offset
== section
->sh_offset
)
5072 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5076 print_vma (section
->sh_offset
, LONG_HEX
);
5079 print_vma (section
->sh_size
, LONG_HEX
);
5081 print_vma (section
->sh_entsize
, LONG_HEX
);
5083 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5085 printf (" %2u %3u %lu\n",
5088 (unsigned long) section
->sh_addralign
);
5091 if (do_section_details
)
5092 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5095 if (!do_section_details
)
5097 if (elf_header
.e_machine
== EM_X86_64
5098 || elf_header
.e_machine
== EM_L1OM
5099 || elf_header
.e_machine
== EM_K1OM
)
5100 printf (_("Key to Flags:\n\
5101 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5102 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5103 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5105 printf (_("Key to Flags:\n\
5106 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5107 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5108 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5115 get_group_flags (unsigned int flags
)
5117 static char buff
[32];
5127 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5134 process_section_groups (FILE * file
)
5136 Elf_Internal_Shdr
* section
;
5138 struct group
* group
;
5139 Elf_Internal_Shdr
* symtab_sec
;
5140 Elf_Internal_Shdr
* strtab_sec
;
5141 Elf_Internal_Sym
* symtab
;
5142 unsigned long num_syms
;
5146 /* Don't process section groups unless needed. */
5147 if (!do_unwind
&& !do_section_groups
)
5150 if (elf_header
.e_shnum
== 0)
5152 if (do_section_groups
)
5153 printf (_("\nThere are no sections to group in this file.\n"));
5158 if (section_headers
== NULL
)
5160 error (_("Section headers are not available!\n"));
5161 /* PR 13622: This can happen with a corrupt ELF header. */
5165 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5166 sizeof (struct group
*));
5168 if (section_headers_groups
== NULL
)
5170 error (_("Out of memory\n"));
5174 /* Scan the sections for the group section. */
5176 for (i
= 0, section
= section_headers
;
5177 i
< elf_header
.e_shnum
;
5179 if (section
->sh_type
== SHT_GROUP
)
5182 if (group_count
== 0)
5184 if (do_section_groups
)
5185 printf (_("\nThere are no section groups in this file.\n"));
5190 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5192 if (section_groups
== NULL
)
5194 error (_("Out of memory\n"));
5204 for (i
= 0, section
= section_headers
, group
= section_groups
;
5205 i
< elf_header
.e_shnum
;
5208 if (section
->sh_type
== SHT_GROUP
)
5210 char * name
= SECTION_NAME (section
);
5212 unsigned char * start
;
5213 unsigned char * indices
;
5214 unsigned int entry
, j
, size
;
5215 Elf_Internal_Shdr
* sec
;
5216 Elf_Internal_Sym
* sym
;
5218 /* Get the symbol table. */
5219 if (section
->sh_link
>= elf_header
.e_shnum
5220 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5223 error (_("Bad sh_link in group section `%s'\n"), name
);
5227 if (symtab_sec
!= sec
)
5232 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5237 error (_("Corrupt header in group section `%s'\n"), name
);
5241 if (section
->sh_info
>= num_syms
)
5243 error (_("Bad sh_info in group section `%s'\n"), name
);
5247 sym
= symtab
+ section
->sh_info
;
5249 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5251 if (sym
->st_shndx
== 0
5252 || sym
->st_shndx
>= elf_header
.e_shnum
)
5254 error (_("Bad sh_info in group section `%s'\n"), name
);
5258 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5267 /* Get the string table. */
5268 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5277 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5282 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5283 1, strtab_sec
->sh_size
,
5285 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5287 group_name
= sym
->st_name
< strtab_size
5288 ? strtab
+ sym
->st_name
: _("<corrupt>");
5291 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5292 1, section
->sh_size
,
5298 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5299 entry
= byte_get (indices
, 4);
5302 if (do_section_groups
)
5304 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5305 get_group_flags (entry
), i
, name
, group_name
, size
);
5307 printf (_(" [Index] Name\n"));
5310 group
->group_index
= i
;
5312 for (j
= 0; j
< size
; j
++)
5314 struct group_list
* g
;
5316 entry
= byte_get (indices
, 4);
5319 if (entry
>= elf_header
.e_shnum
)
5321 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5322 entry
, i
, elf_header
.e_shnum
- 1);
5326 if (section_headers_groups
[entry
] != NULL
)
5330 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5332 section_headers_groups
[entry
]->group_index
);
5337 /* Intel C/C++ compiler may put section 0 in a
5338 section group. We just warn it the first time
5339 and ignore it afterwards. */
5340 static int warned
= 0;
5343 error (_("section 0 in group section [%5u]\n"),
5344 section_headers_groups
[entry
]->group_index
);
5350 section_headers_groups
[entry
] = group
;
5352 if (do_section_groups
)
5354 sec
= section_headers
+ entry
;
5355 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5358 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5359 g
->section_index
= entry
;
5360 g
->next
= group
->root
;
5378 /* Data used to display dynamic fixups. */
5380 struct ia64_vms_dynfixup
5382 bfd_vma needed_ident
; /* Library ident number. */
5383 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5384 bfd_vma fixup_needed
; /* Index of the library. */
5385 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5386 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5389 /* Data used to display dynamic relocations. */
5391 struct ia64_vms_dynimgrela
5393 bfd_vma img_rela_cnt
; /* Number of relocations. */
5394 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5397 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5401 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5402 const char *strtab
, unsigned int strtab_sz
)
5404 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5406 const char *lib_name
;
5408 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5409 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5410 _("dynamic section image fixups"));
5414 if (fixup
->needed
< strtab_sz
)
5415 lib_name
= strtab
+ fixup
->needed
;
5418 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5419 (unsigned long) fixup
->needed
);
5422 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5423 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5425 (_("Seg Offset Type SymVec DataType\n"));
5427 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5432 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5433 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5434 type
= BYTE_GET (imfs
[i
].type
);
5435 rtype
= elf_ia64_reloc_type (type
);
5437 printf (" 0x%08x ", type
);
5439 printf (" %-32s ", rtype
);
5440 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5441 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5447 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5450 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5452 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5455 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5456 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5457 _("dynamic section image relocations"));
5461 printf (_("\nImage relocs\n"));
5463 (_("Seg Offset Type Addend Seg Sym Off\n"));
5465 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5470 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5471 printf ("%08" BFD_VMA_FMT
"x ",
5472 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5473 type
= BYTE_GET (imrs
[i
].type
);
5474 rtype
= elf_ia64_reloc_type (type
);
5476 printf ("0x%08x ", type
);
5478 printf ("%-31s ", rtype
);
5479 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5480 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5481 printf ("%08" BFD_VMA_FMT
"x\n",
5482 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5488 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5491 process_ia64_vms_dynamic_relocs (FILE *file
)
5493 struct ia64_vms_dynfixup fixup
;
5494 struct ia64_vms_dynimgrela imgrela
;
5495 Elf_Internal_Dyn
*entry
;
5497 bfd_vma strtab_off
= 0;
5498 bfd_vma strtab_sz
= 0;
5499 char *strtab
= NULL
;
5501 memset (&fixup
, 0, sizeof (fixup
));
5502 memset (&imgrela
, 0, sizeof (imgrela
));
5504 /* Note: the order of the entries is specified by the OpenVMS specs. */
5505 for (entry
= dynamic_section
;
5506 entry
< dynamic_section
+ dynamic_nent
;
5509 switch (entry
->d_tag
)
5511 case DT_IA_64_VMS_STRTAB_OFFSET
:
5512 strtab_off
= entry
->d_un
.d_val
;
5515 strtab_sz
= entry
->d_un
.d_val
;
5517 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5518 1, strtab_sz
, _("dynamic string section"));
5521 case DT_IA_64_VMS_NEEDED_IDENT
:
5522 fixup
.needed_ident
= entry
->d_un
.d_val
;
5525 fixup
.needed
= entry
->d_un
.d_val
;
5527 case DT_IA_64_VMS_FIXUP_NEEDED
:
5528 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5530 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5531 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5533 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5534 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5536 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5539 case DT_IA_64_VMS_IMG_RELA_CNT
:
5540 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5542 case DT_IA_64_VMS_IMG_RELA_OFF
:
5543 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5545 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5565 } dynamic_relocations
[] =
5567 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5568 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5569 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5572 /* Process the reloc section. */
5575 process_relocs (FILE * file
)
5577 unsigned long rel_size
;
5578 unsigned long rel_offset
;
5584 if (do_using_dynamic
)
5588 int has_dynamic_reloc
;
5591 has_dynamic_reloc
= 0;
5593 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5595 is_rela
= dynamic_relocations
[i
].rela
;
5596 name
= dynamic_relocations
[i
].name
;
5597 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5598 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5600 has_dynamic_reloc
|= rel_size
;
5602 if (is_rela
== UNKNOWN
)
5604 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5605 switch (dynamic_info
[DT_PLTREL
])
5619 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5620 name
, rel_offset
, rel_size
);
5622 dump_relocations (file
,
5623 offset_from_vma (file
, rel_offset
, rel_size
),
5625 dynamic_symbols
, num_dynamic_syms
,
5626 dynamic_strings
, dynamic_strings_length
, is_rela
);
5631 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5633 if (! has_dynamic_reloc
)
5634 printf (_("\nThere are no dynamic relocations in this file.\n"));
5638 Elf_Internal_Shdr
* section
;
5642 for (i
= 0, section
= section_headers
;
5643 i
< elf_header
.e_shnum
;
5646 if ( section
->sh_type
!= SHT_RELA
5647 && section
->sh_type
!= SHT_REL
)
5650 rel_offset
= section
->sh_offset
;
5651 rel_size
= section
->sh_size
;
5655 Elf_Internal_Shdr
* strsec
;
5658 printf (_("\nRelocation section "));
5660 if (string_table
== NULL
)
5661 printf ("%d", section
->sh_name
);
5663 printf ("'%s'", SECTION_NAME (section
));
5665 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5666 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5668 is_rela
= section
->sh_type
== SHT_RELA
;
5670 if (section
->sh_link
!= 0
5671 && section
->sh_link
< elf_header
.e_shnum
)
5673 Elf_Internal_Shdr
* symsec
;
5674 Elf_Internal_Sym
* symtab
;
5675 unsigned long nsyms
;
5676 unsigned long strtablen
= 0;
5677 char * strtab
= NULL
;
5679 symsec
= section_headers
+ section
->sh_link
;
5680 if (symsec
->sh_type
!= SHT_SYMTAB
5681 && symsec
->sh_type
!= SHT_DYNSYM
)
5684 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5689 if (symsec
->sh_link
!= 0
5690 && symsec
->sh_link
< elf_header
.e_shnum
)
5692 strsec
= section_headers
+ symsec
->sh_link
;
5694 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5697 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5700 dump_relocations (file
, rel_offset
, rel_size
,
5701 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5707 dump_relocations (file
, rel_offset
, rel_size
,
5708 NULL
, 0, NULL
, 0, is_rela
);
5715 printf (_("\nThere are no relocations in this file.\n"));
5721 /* Process the unwind section. */
5723 #include "unwind-ia64.h"
5725 /* An absolute address consists of a section and an offset. If the
5726 section is NULL, the offset itself is the address, otherwise, the
5727 address equals to LOAD_ADDRESS(section) + offset. */
5731 unsigned short section
;
5735 #define ABSADDR(a) \
5737 ? section_headers [(a).section].sh_addr + (a).offset \
5740 struct ia64_unw_table_entry
5742 struct absaddr start
;
5744 struct absaddr info
;
5747 struct ia64_unw_aux_info
5750 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5751 unsigned long table_len
; /* Length of unwind table. */
5752 unsigned char * info
; /* Unwind info. */
5753 unsigned long info_size
; /* Size of unwind info. */
5754 bfd_vma info_addr
; /* starting address of unwind info. */
5755 bfd_vma seg_base
; /* Starting address of segment. */
5756 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5757 unsigned long nsyms
; /* Number of symbols. */
5758 char * strtab
; /* The string table. */
5759 unsigned long strtab_size
; /* Size of string table. */
5763 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5764 unsigned long nsyms
,
5765 const char * strtab
,
5766 unsigned long strtab_size
,
5767 struct absaddr addr
,
5768 const char ** symname
,
5771 bfd_vma dist
= 0x100000;
5772 Elf_Internal_Sym
* sym
;
5773 Elf_Internal_Sym
* best
= NULL
;
5776 REMOVE_ARCH_BITS (addr
.offset
);
5778 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5780 bfd_vma value
= sym
->st_value
;
5782 REMOVE_ARCH_BITS (value
);
5784 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5785 && sym
->st_name
!= 0
5786 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5787 && addr
.offset
>= value
5788 && addr
.offset
- value
< dist
)
5791 dist
= addr
.offset
- value
;
5799 *symname
= (best
->st_name
>= strtab_size
5800 ? _("<corrupt>") : strtab
+ best
->st_name
);
5806 *offset
= addr
.offset
;
5810 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5812 struct ia64_unw_table_entry
* tp
;
5815 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5819 const unsigned char * dp
;
5820 const unsigned char * head
;
5821 const char * procname
;
5823 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5824 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5826 fputs ("\n<", stdout
);
5830 fputs (procname
, stdout
);
5833 printf ("+%lx", (unsigned long) offset
);
5836 fputs (">: [", stdout
);
5837 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5838 fputc ('-', stdout
);
5839 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5840 printf ("], info at +0x%lx\n",
5841 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5843 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5844 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5846 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5847 (unsigned) UNW_VER (stamp
),
5848 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5849 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5850 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5851 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5853 if (UNW_VER (stamp
) != 1)
5855 printf (_("\tUnknown version.\n"));
5860 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5861 dp
= unw_decode (dp
, in_body
, & in_body
);
5866 slurp_ia64_unwind_table (FILE * file
,
5867 struct ia64_unw_aux_info
* aux
,
5868 Elf_Internal_Shdr
* sec
)
5870 unsigned long size
, nrelas
, i
;
5871 Elf_Internal_Phdr
* seg
;
5872 struct ia64_unw_table_entry
* tep
;
5873 Elf_Internal_Shdr
* relsec
;
5874 Elf_Internal_Rela
* rela
;
5875 Elf_Internal_Rela
* rp
;
5876 unsigned char * table
;
5878 Elf_Internal_Sym
* sym
;
5879 const char * relname
;
5881 /* First, find the starting address of the segment that includes
5884 if (elf_header
.e_phnum
)
5886 if (! get_program_headers (file
))
5889 for (seg
= program_headers
;
5890 seg
< program_headers
+ elf_header
.e_phnum
;
5893 if (seg
->p_type
!= PT_LOAD
)
5896 if (sec
->sh_addr
>= seg
->p_vaddr
5897 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5899 aux
->seg_base
= seg
->p_vaddr
;
5905 /* Second, build the unwind table from the contents of the unwind section: */
5906 size
= sec
->sh_size
;
5907 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5912 aux
->table
= (struct ia64_unw_table_entry
*)
5913 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5915 for (tp
= table
; tp
< table
+ size
; ++tep
)
5917 tep
->start
.section
= SHN_UNDEF
;
5918 tep
->end
.section
= SHN_UNDEF
;
5919 tep
->info
.section
= SHN_UNDEF
;
5920 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5921 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5922 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5923 tep
->start
.offset
+= aux
->seg_base
;
5924 tep
->end
.offset
+= aux
->seg_base
;
5925 tep
->info
.offset
+= aux
->seg_base
;
5929 /* Third, apply any relocations to the unwind table: */
5930 for (relsec
= section_headers
;
5931 relsec
< section_headers
+ elf_header
.e_shnum
;
5934 if (relsec
->sh_type
!= SHT_RELA
5935 || relsec
->sh_info
>= elf_header
.e_shnum
5936 || section_headers
+ relsec
->sh_info
!= sec
)
5939 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5943 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5945 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5946 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5948 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5950 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5954 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5956 switch (rp
->r_offset
/eh_addr_size
% 3)
5959 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5960 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5963 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5964 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5967 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5968 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5978 aux
->table_len
= size
/ (3 * eh_addr_size
);
5983 ia64_process_unwind (FILE * file
)
5985 Elf_Internal_Shdr
* sec
;
5986 Elf_Internal_Shdr
* unwsec
= NULL
;
5987 Elf_Internal_Shdr
* strsec
;
5988 unsigned long i
, unwcount
= 0, unwstart
= 0;
5989 struct ia64_unw_aux_info aux
;
5991 memset (& aux
, 0, sizeof (aux
));
5993 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5995 if (sec
->sh_type
== SHT_SYMTAB
5996 && sec
->sh_link
< elf_header
.e_shnum
)
5998 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6000 strsec
= section_headers
+ sec
->sh_link
;
6001 assert (aux
.strtab
== NULL
);
6002 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6005 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6007 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6012 printf (_("\nThere are no unwind sections in this file.\n"));
6014 while (unwcount
-- > 0)
6019 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6020 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6021 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6028 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6030 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6032 /* We need to find which section group it is in. */
6033 struct group_list
* g
= section_headers_groups
[i
]->root
;
6035 for (; g
!= NULL
; g
= g
->next
)
6037 sec
= section_headers
+ g
->section_index
;
6039 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6044 i
= elf_header
.e_shnum
;
6046 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6048 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6049 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6050 suffix
= SECTION_NAME (unwsec
) + len
;
6051 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6053 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6054 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6059 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6060 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6061 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6062 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6064 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6065 suffix
= SECTION_NAME (unwsec
) + len
;
6066 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6068 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6069 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6073 if (i
== elf_header
.e_shnum
)
6075 printf (_("\nCould not find unwind info section for "));
6077 if (string_table
== NULL
)
6078 printf ("%d", unwsec
->sh_name
);
6080 printf (_("'%s'"), SECTION_NAME (unwsec
));
6084 aux
.info_addr
= sec
->sh_addr
;
6085 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6088 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6090 printf (_("\nUnwind section "));
6092 if (string_table
== NULL
)
6093 printf ("%d", unwsec
->sh_name
);
6095 printf (_("'%s'"), SECTION_NAME (unwsec
));
6097 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6098 (unsigned long) unwsec
->sh_offset
,
6099 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6101 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6103 if (aux
.table_len
> 0)
6104 dump_ia64_unwind (& aux
);
6107 free ((char *) aux
.table
);
6109 free ((char *) aux
.info
);
6118 free ((char *) aux
.strtab
);
6121 struct hppa_unw_table_entry
6123 struct absaddr start
;
6125 unsigned int Cannot_unwind
:1; /* 0 */
6126 unsigned int Millicode
:1; /* 1 */
6127 unsigned int Millicode_save_sr0
:1; /* 2 */
6128 unsigned int Region_description
:2; /* 3..4 */
6129 unsigned int reserved1
:1; /* 5 */
6130 unsigned int Entry_SR
:1; /* 6 */
6131 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6132 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6133 unsigned int Args_stored
:1; /* 16 */
6134 unsigned int Variable_Frame
:1; /* 17 */
6135 unsigned int Separate_Package_Body
:1; /* 18 */
6136 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6137 unsigned int Stack_Overflow_Check
:1; /* 20 */
6138 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6139 unsigned int Ada_Region
:1; /* 22 */
6140 unsigned int cxx_info
:1; /* 23 */
6141 unsigned int cxx_try_catch
:1; /* 24 */
6142 unsigned int sched_entry_seq
:1; /* 25 */
6143 unsigned int reserved2
:1; /* 26 */
6144 unsigned int Save_SP
:1; /* 27 */
6145 unsigned int Save_RP
:1; /* 28 */
6146 unsigned int Save_MRP_in_frame
:1; /* 29 */
6147 unsigned int extn_ptr_defined
:1; /* 30 */
6148 unsigned int Cleanup_defined
:1; /* 31 */
6150 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6151 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6152 unsigned int Large_frame
:1; /* 2 */
6153 unsigned int Pseudo_SP_Set
:1; /* 3 */
6154 unsigned int reserved4
:1; /* 4 */
6155 unsigned int Total_frame_size
:27; /* 5..31 */
6158 struct hppa_unw_aux_info
6160 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6161 unsigned long table_len
; /* Length of unwind table. */
6162 bfd_vma seg_base
; /* Starting address of segment. */
6163 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6164 unsigned long nsyms
; /* Number of symbols. */
6165 char * strtab
; /* The string table. */
6166 unsigned long strtab_size
; /* Size of string table. */
6170 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6172 struct hppa_unw_table_entry
* tp
;
6174 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6177 const char * procname
;
6179 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6180 aux
->strtab_size
, tp
->start
, &procname
,
6183 fputs ("\n<", stdout
);
6187 fputs (procname
, stdout
);
6190 printf ("+%lx", (unsigned long) offset
);
6193 fputs (">: [", stdout
);
6194 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6195 fputc ('-', stdout
);
6196 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6199 #define PF(_m) if (tp->_m) printf (#_m " ");
6200 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6203 PF(Millicode_save_sr0
);
6204 /* PV(Region_description); */
6210 PF(Separate_Package_Body
);
6211 PF(Frame_Extension_Millicode
);
6212 PF(Stack_Overflow_Check
);
6213 PF(Two_Instruction_SP_Increment
);
6217 PF(sched_entry_seq
);
6220 PF(Save_MRP_in_frame
);
6221 PF(extn_ptr_defined
);
6222 PF(Cleanup_defined
);
6223 PF(MPE_XL_interrupt_marker
);
6224 PF(HP_UX_interrupt_marker
);
6227 PV(Total_frame_size
);
6236 slurp_hppa_unwind_table (FILE * file
,
6237 struct hppa_unw_aux_info
* aux
,
6238 Elf_Internal_Shdr
* sec
)
6240 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6241 Elf_Internal_Phdr
* seg
;
6242 struct hppa_unw_table_entry
* tep
;
6243 Elf_Internal_Shdr
* relsec
;
6244 Elf_Internal_Rela
* rela
;
6245 Elf_Internal_Rela
* rp
;
6246 unsigned char * table
;
6248 Elf_Internal_Sym
* sym
;
6249 const char * relname
;
6251 /* First, find the starting address of the segment that includes
6254 if (elf_header
.e_phnum
)
6256 if (! get_program_headers (file
))
6259 for (seg
= program_headers
;
6260 seg
< program_headers
+ elf_header
.e_phnum
;
6263 if (seg
->p_type
!= PT_LOAD
)
6266 if (sec
->sh_addr
>= seg
->p_vaddr
6267 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6269 aux
->seg_base
= seg
->p_vaddr
;
6275 /* Second, build the unwind table from the contents of the unwind
6277 size
= sec
->sh_size
;
6278 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6284 nentries
= size
/ unw_ent_size
;
6285 size
= unw_ent_size
* nentries
;
6287 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6288 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6290 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6292 unsigned int tmp1
, tmp2
;
6294 tep
->start
.section
= SHN_UNDEF
;
6295 tep
->end
.section
= SHN_UNDEF
;
6297 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6298 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6299 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6300 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6302 tep
->start
.offset
+= aux
->seg_base
;
6303 tep
->end
.offset
+= aux
->seg_base
;
6305 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6306 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6307 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6308 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6309 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6310 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6311 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6312 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6313 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6314 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6315 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6316 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6317 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6318 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6319 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6320 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6321 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6322 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6323 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6324 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6325 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6326 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6327 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6328 tep
->Cleanup_defined
= tmp1
& 0x1;
6330 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6331 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6332 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6333 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6334 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6335 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6339 /* Third, apply any relocations to the unwind table. */
6340 for (relsec
= section_headers
;
6341 relsec
< section_headers
+ elf_header
.e_shnum
;
6344 if (relsec
->sh_type
!= SHT_RELA
6345 || relsec
->sh_info
>= elf_header
.e_shnum
6346 || section_headers
+ relsec
->sh_info
!= sec
)
6349 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6353 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6355 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6356 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6358 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6359 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6361 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6365 i
= rp
->r_offset
/ unw_ent_size
;
6367 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6370 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6371 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6374 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6375 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6385 aux
->table_len
= nentries
;
6391 hppa_process_unwind (FILE * file
)
6393 struct hppa_unw_aux_info aux
;
6394 Elf_Internal_Shdr
* unwsec
= NULL
;
6395 Elf_Internal_Shdr
* strsec
;
6396 Elf_Internal_Shdr
* sec
;
6399 if (string_table
== NULL
)
6402 memset (& aux
, 0, sizeof (aux
));
6404 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6406 if (sec
->sh_type
== SHT_SYMTAB
6407 && sec
->sh_link
< elf_header
.e_shnum
)
6409 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6411 strsec
= section_headers
+ sec
->sh_link
;
6412 assert (aux
.strtab
== NULL
);
6413 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6416 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6418 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6423 printf (_("\nThere are no unwind sections in this file.\n"));
6425 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6427 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6429 printf (_("\nUnwind section "));
6430 printf (_("'%s'"), SECTION_NAME (sec
));
6432 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6433 (unsigned long) sec
->sh_offset
,
6434 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6436 slurp_hppa_unwind_table (file
, &aux
, sec
);
6437 if (aux
.table_len
> 0)
6438 dump_hppa_unwind (&aux
);
6441 free ((char *) aux
.table
);
6449 free ((char *) aux
.strtab
);
6454 unsigned char * data
; /* The unwind data. */
6455 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6456 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6457 unsigned long nrelas
; /* The number of relocations. */
6458 unsigned int rel_type
; /* REL or RELA ? */
6459 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6462 struct arm_unw_aux_info
6464 FILE * file
; /* The file containing the unwind sections. */
6465 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6466 unsigned long nsyms
; /* Number of symbols. */
6467 char * strtab
; /* The file's string table. */
6468 unsigned long strtab_size
; /* Size of string table. */
6472 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6473 bfd_vma fn
, struct absaddr addr
)
6475 const char *procname
;
6478 if (addr
.section
== SHN_UNDEF
)
6481 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6482 aux
->strtab_size
, addr
, &procname
,
6485 print_vma (fn
, PREFIX_HEX
);
6489 fputs (" <", stdout
);
6490 fputs (procname
, stdout
);
6493 printf ("+0x%lx", (unsigned long) sym_offset
);
6494 fputc ('>', stdout
);
6501 arm_free_section (struct arm_section
*arm_sec
)
6503 if (arm_sec
->data
!= NULL
)
6504 free (arm_sec
->data
);
6506 if (arm_sec
->rela
!= NULL
)
6507 free (arm_sec
->rela
);
6510 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6511 cached section and install SEC instead.
6512 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6513 and return its valued in * WORDP, relocating if necessary.
6514 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6515 relocation's offset in ADDR.
6516 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6517 into the string table of the symbol associated with the reloc. If no
6518 reloc was applied store -1 there.
6519 5) Return TRUE upon success, FALSE otherwise. */
6522 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6523 struct arm_section
* arm_sec
,
6524 Elf_Internal_Shdr
* sec
,
6525 bfd_vma word_offset
,
6526 unsigned int * wordp
,
6527 struct absaddr
* addr
,
6530 Elf_Internal_Rela
*rp
;
6531 Elf_Internal_Sym
*sym
;
6532 const char * relname
;
6534 bfd_boolean wrapped
;
6536 addr
->section
= SHN_UNDEF
;
6539 if (sym_name
!= NULL
)
6540 *sym_name
= (bfd_vma
) -1;
6542 /* If necessary, update the section cache. */
6543 if (sec
!= arm_sec
->sec
)
6545 Elf_Internal_Shdr
*relsec
;
6547 arm_free_section (arm_sec
);
6550 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6551 sec
->sh_size
, _("unwind data"));
6552 arm_sec
->rela
= NULL
;
6553 arm_sec
->nrelas
= 0;
6555 for (relsec
= section_headers
;
6556 relsec
< section_headers
+ elf_header
.e_shnum
;
6559 if (relsec
->sh_info
>= elf_header
.e_shnum
6560 || section_headers
+ relsec
->sh_info
!= sec
)
6563 arm_sec
->rel_type
= relsec
->sh_type
;
6564 if (relsec
->sh_type
== SHT_REL
)
6566 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6568 & arm_sec
->rela
, & arm_sec
->nrelas
))
6572 else if (relsec
->sh_type
== SHT_RELA
)
6574 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6576 & arm_sec
->rela
, & arm_sec
->nrelas
))
6581 warn (_("unexpected relocation type (%d) for section %d"),
6582 relsec
->sh_type
, relsec
->sh_info
);
6585 arm_sec
->next_rela
= arm_sec
->rela
;
6588 /* If there is no unwind data we can do nothing. */
6589 if (arm_sec
->data
== NULL
)
6592 /* Get the word at the required offset. */
6593 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6595 /* Look through the relocs to find the one that applies to the provided offset. */
6597 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6599 bfd_vma prelval
, offset
;
6601 if (rp
->r_offset
> word_offset
&& !wrapped
)
6606 if (rp
->r_offset
> word_offset
)
6609 if (rp
->r_offset
& 3)
6611 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6612 (unsigned long) rp
->r_offset
);
6616 if (rp
->r_offset
< word_offset
)
6619 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6621 if (arm_sec
->rel_type
== SHT_REL
)
6623 offset
= word
& 0x7fffffff;
6624 if (offset
& 0x40000000)
6625 offset
|= ~ (bfd_vma
) 0x7fffffff;
6627 else if (arm_sec
->rel_type
== SHT_RELA
)
6628 offset
= rp
->r_addend
;
6632 offset
+= sym
->st_value
;
6633 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6635 /* Check that we are processing the expected reloc type. */
6636 if (elf_header
.e_machine
== EM_ARM
)
6638 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6640 if (streq (relname
, "R_ARM_NONE"))
6643 if (! streq (relname
, "R_ARM_PREL31"))
6645 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6649 else if (elf_header
.e_machine
== EM_TI_C6000
)
6651 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6653 if (streq (relname
, "R_C6000_NONE"))
6656 if (! streq (relname
, "R_C6000_PREL31"))
6658 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6665 /* This function currently only supports ARM and TI unwinders. */
6668 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6669 addr
->section
= sym
->st_shndx
;
6670 addr
->offset
= offset
;
6672 * sym_name
= sym
->st_name
;
6677 arm_sec
->next_rela
= rp
;
6682 static const char *tic6x_unwind_regnames
[16] =
6684 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6685 "A14", "A13", "A12", "A11", "A10",
6686 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6690 decode_tic6x_unwind_regmask (unsigned int mask
)
6694 for (i
= 12; mask
; mask
>>= 1, i
--)
6698 fputs (tic6x_unwind_regnames
[i
], stdout
);
6700 fputs (", ", stdout
);
6706 if (remaining == 0 && more_words) \
6709 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6710 data_offset, & word, & addr, NULL)) \
6716 #define GET_OP(OP) \
6721 (OP) = word >> 24; \
6726 printf (_("[Truncated opcode]\n")); \
6729 printf ("0x%02x ", OP)
6732 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6733 unsigned int word
, unsigned int remaining
,
6734 unsigned int more_words
,
6735 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6736 struct arm_section
*data_arm_sec
)
6738 struct absaddr addr
;
6740 /* Decode the unwinding instructions. */
6743 unsigned int op
, op2
;
6752 printf (" 0x%02x ", op
);
6754 if ((op
& 0xc0) == 0x00)
6756 int offset
= ((op
& 0x3f) << 2) + 4;
6758 printf (" vsp = vsp + %d", offset
);
6760 else if ((op
& 0xc0) == 0x40)
6762 int offset
= ((op
& 0x3f) << 2) + 4;
6764 printf (" vsp = vsp - %d", offset
);
6766 else if ((op
& 0xf0) == 0x80)
6769 if (op
== 0x80 && op2
== 0)
6770 printf (_("Refuse to unwind"));
6773 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6778 for (i
= 0; i
< 12; i
++)
6779 if (mask
& (1 << i
))
6785 printf ("r%d", 4 + i
);
6790 else if ((op
& 0xf0) == 0x90)
6792 if (op
== 0x9d || op
== 0x9f)
6793 printf (_(" [Reserved]"));
6795 printf (" vsp = r%d", op
& 0x0f);
6797 else if ((op
& 0xf0) == 0xa0)
6799 int end
= 4 + (op
& 0x07);
6804 for (i
= 4; i
<= end
; i
++)
6820 else if (op
== 0xb0)
6821 printf (_(" finish"));
6822 else if (op
== 0xb1)
6825 if (op2
== 0 || (op2
& 0xf0) != 0)
6826 printf (_("[Spare]"));
6829 unsigned int mask
= op2
& 0x0f;
6834 for (i
= 0; i
< 12; i
++)
6835 if (mask
& (1 << i
))
6846 else if (op
== 0xb2)
6848 unsigned char buf
[9];
6849 unsigned int i
, len
;
6850 unsigned long offset
;
6852 for (i
= 0; i
< sizeof (buf
); i
++)
6855 if ((buf
[i
] & 0x80) == 0)
6858 assert (i
< sizeof (buf
));
6859 offset
= read_uleb128 (buf
, &len
);
6860 assert (len
== i
+ 1);
6861 offset
= offset
* 4 + 0x204;
6862 printf ("vsp = vsp + %ld", offset
);
6864 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6866 unsigned int first
, last
;
6873 printf ("pop {D%d", first
);
6875 printf ("-D%d", first
+ last
);
6878 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6880 unsigned int count
= op
& 0x07;
6884 printf ("-D%d", 8 + count
);
6887 else if (op
>= 0xc0 && op
<= 0xc5)
6889 unsigned int count
= op
& 0x07;
6891 printf (" pop {wR10");
6893 printf ("-wR%d", 10 + count
);
6896 else if (op
== 0xc6)
6898 unsigned int first
, last
;
6903 printf ("pop {wR%d", first
);
6905 printf ("-wR%d", first
+ last
);
6908 else if (op
== 0xc7)
6911 if (op2
== 0 || (op2
& 0xf0) != 0)
6912 printf (_("[Spare]"));
6915 unsigned int mask
= op2
& 0x0f;
6920 for (i
= 0; i
< 4; i
++)
6921 if (mask
& (1 << i
))
6927 printf ("wCGR%d", i
);
6933 printf (_(" [unsupported opcode]"));
6939 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6940 unsigned int word
, unsigned int remaining
,
6941 unsigned int more_words
,
6942 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6943 struct arm_section
*data_arm_sec
)
6945 struct absaddr addr
;
6947 /* Decode the unwinding instructions. */
6950 unsigned int op
, op2
;
6959 printf (" 0x%02x ", op
);
6961 if ((op
& 0xc0) == 0x00)
6963 int offset
= ((op
& 0x3f) << 3) + 8;
6964 printf (" sp = sp + %d", offset
);
6966 else if ((op
& 0xc0) == 0x80)
6969 if (op
== 0x80 && op2
== 0)
6970 printf (_("Refuse to unwind"));
6973 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6975 printf ("pop compact {");
6979 decode_tic6x_unwind_regmask (mask
);
6983 else if ((op
& 0xf0) == 0xc0)
6991 unsigned int offset
;
6995 /* Scan entire instruction first so that GET_OP output is not
6996 interleaved with disassembly. */
6998 for (i
= 0; nregs
< (op
& 0xf); i
++)
7004 regpos
[nregs
].offset
= i
* 2;
7005 regpos
[nregs
].reg
= reg
;
7012 regpos
[nregs
].offset
= i
* 2 + 1;
7013 regpos
[nregs
].reg
= reg
;
7018 printf (_("pop frame {"));
7020 for (i
= i
* 2; i
> 0; i
--)
7022 if (regpos
[reg
].offset
== i
- 1)
7024 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7031 fputs (name
, stdout
);
7038 else if (op
== 0xd0)
7039 printf (" MOV FP, SP");
7040 else if (op
== 0xd1)
7041 printf (" __c6xabi_pop_rts");
7042 else if (op
== 0xd2)
7044 unsigned char buf
[9];
7045 unsigned int i
, len
;
7046 unsigned long offset
;
7048 for (i
= 0; i
< sizeof (buf
); i
++)
7051 if ((buf
[i
] & 0x80) == 0)
7054 assert (i
< sizeof (buf
));
7055 offset
= read_uleb128 (buf
, &len
);
7056 assert (len
== i
+ 1);
7057 offset
= offset
* 8 + 0x408;
7058 printf (_("sp = sp + %ld"), offset
);
7060 else if ((op
& 0xf0) == 0xe0)
7062 if ((op
& 0x0f) == 7)
7065 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7069 printf (_(" [unsupported opcode]"));
7076 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7080 offset
= word
& 0x7fffffff;
7081 if (offset
& 0x40000000)
7082 offset
|= ~ (bfd_vma
) 0x7fffffff;
7084 if (elf_header
.e_machine
== EM_TI_C6000
)
7087 return offset
+ where
;
7091 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7093 unsigned int remaining
,
7094 bfd_vma data_offset
,
7095 Elf_Internal_Shdr
* data_sec
,
7096 struct arm_section
* data_arm_sec
)
7099 unsigned int more_words
= 0;
7100 struct absaddr addr
;
7101 bfd_vma sym_name
= (bfd_vma
) -1;
7105 /* Fetch the first word.
7106 Note - when decoding an object file the address extracted
7107 here will always be 0. So we also pass in the sym_name
7108 parameter so that we can find the symbol associated with
7109 the personality routine. */
7110 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7111 & word
, & addr
, & sym_name
))
7117 if ((word
& 0x80000000) == 0)
7119 /* Expand prel31 for personality routine. */
7121 const char *procname
;
7123 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7124 printf (_(" Personality routine: "));
7126 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7127 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7129 procname
= aux
->strtab
+ sym_name
;
7130 print_vma (fn
, PREFIX_HEX
);
7133 fputs (" <", stdout
);
7134 fputs (procname
, stdout
);
7135 fputc ('>', stdout
);
7139 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7140 fputc ('\n', stdout
);
7142 /* The GCC personality routines use the standard compact
7143 encoding, starting with one byte giving the number of
7145 if (procname
!= NULL
7146 && (const_strneq (procname
, "__gcc_personality_v0")
7147 || const_strneq (procname
, "__gxx_personality_v0")
7148 || const_strneq (procname
, "__gcj_personality_v0")
7149 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7156 printf (_(" [Truncated data]\n"));
7159 more_words
= word
>> 24;
7169 /* ARM EHABI Section 6.3:
7171 An exception-handling table entry for the compact model looks like:
7175 1 0 index Data for personalityRoutine[index] */
7177 if (elf_header
.e_machine
== EM_ARM
7178 && (word
& 0x70000000))
7179 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7181 per_index
= (word
>> 24) & 0x7f;
7182 printf (_(" Compact model index: %d\n"), per_index
);
7189 else if (per_index
< 3)
7191 more_words
= (word
>> 16) & 0xff;
7197 switch (elf_header
.e_machine
)
7202 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7203 data_offset
, data_sec
, data_arm_sec
);
7207 warn (_("Unknown ARM compact model index encountered\n"));
7208 printf (_(" [reserved]\n"));
7215 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7216 data_offset
, data_sec
, data_arm_sec
);
7218 else if (per_index
< 5)
7220 if (((word
>> 17) & 0x7f) == 0x7f)
7221 printf (_(" Restore stack from frame pointer\n"));
7223 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7224 printf (_(" Registers restored: "));
7226 printf (" (compact) ");
7227 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7229 printf (_(" Return register: %s\n"),
7230 tic6x_unwind_regnames
[word
& 0xf]);
7233 printf (_(" [reserved (%d)]\n"), per_index
);
7237 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7238 elf_header
.e_machine
);
7241 /* Decode the descriptors. Not implemented. */
7245 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7247 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7248 unsigned int i
, exidx_len
;
7250 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7251 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7252 exidx_len
= exidx_sec
->sh_size
/ 8;
7254 for (i
= 0; i
< exidx_len
; i
++)
7256 unsigned int exidx_fn
, exidx_entry
;
7257 struct absaddr fn_addr
, entry_addr
;
7260 fputc ('\n', stdout
);
7262 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7263 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7264 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7265 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7267 arm_free_section (& exidx_arm_sec
);
7268 arm_free_section (& extab_arm_sec
);
7272 /* ARM EHABI, Section 5:
7273 An index table entry consists of 2 words.
7274 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7275 if (exidx_fn
& 0x80000000)
7276 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7278 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7280 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7281 fputs (": ", stdout
);
7283 if (exidx_entry
== 1)
7285 print_vma (exidx_entry
, PREFIX_HEX
);
7286 fputs (" [cantunwind]\n", stdout
);
7288 else if (exidx_entry
& 0x80000000)
7290 print_vma (exidx_entry
, PREFIX_HEX
);
7291 fputc ('\n', stdout
);
7292 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7296 bfd_vma table
, table_offset
= 0;
7297 Elf_Internal_Shdr
*table_sec
;
7299 fputs ("@", stdout
);
7300 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7301 print_vma (table
, PREFIX_HEX
);
7304 /* Locate the matching .ARM.extab. */
7305 if (entry_addr
.section
!= SHN_UNDEF
7306 && entry_addr
.section
< elf_header
.e_shnum
)
7308 table_sec
= section_headers
+ entry_addr
.section
;
7309 table_offset
= entry_addr
.offset
;
7313 table_sec
= find_section_by_address (table
);
7314 if (table_sec
!= NULL
)
7315 table_offset
= table
- table_sec
->sh_addr
;
7317 if (table_sec
== NULL
)
7319 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7320 (unsigned long) table
);
7323 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7330 arm_free_section (&exidx_arm_sec
);
7331 arm_free_section (&extab_arm_sec
);
7334 /* Used for both ARM and C6X unwinding tables. */
7337 arm_process_unwind (FILE *file
)
7339 struct arm_unw_aux_info aux
;
7340 Elf_Internal_Shdr
*unwsec
= NULL
;
7341 Elf_Internal_Shdr
*strsec
;
7342 Elf_Internal_Shdr
*sec
;
7344 unsigned int sec_type
;
7346 switch (elf_header
.e_machine
)
7349 sec_type
= SHT_ARM_EXIDX
;
7353 sec_type
= SHT_C6000_UNWIND
;
7357 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7358 elf_header
.e_machine
);
7362 if (string_table
== NULL
)
7365 memset (& aux
, 0, sizeof (aux
));
7368 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7370 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7372 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7374 strsec
= section_headers
+ sec
->sh_link
;
7375 assert (aux
.strtab
== NULL
);
7376 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7377 1, strsec
->sh_size
, _("string table"));
7378 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7380 else if (sec
->sh_type
== sec_type
)
7385 printf (_("\nThere are no unwind sections in this file.\n"));
7387 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7389 if (sec
->sh_type
== sec_type
)
7391 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7393 (unsigned long) sec
->sh_offset
,
7394 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7396 dump_arm_unwind (&aux
, sec
);
7403 free ((char *) aux
.strtab
);
7407 process_unwind (FILE * file
)
7409 struct unwind_handler
7412 void (* handler
)(FILE *);
7415 { EM_ARM
, arm_process_unwind
},
7416 { EM_IA_64
, ia64_process_unwind
},
7417 { EM_PARISC
, hppa_process_unwind
},
7418 { EM_TI_C6000
, arm_process_unwind
},
7426 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7427 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7428 return handlers
[i
].handler (file
);
7430 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7431 get_machine_name (elf_header
.e_machine
));
7435 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7437 switch (entry
->d_tag
)
7440 if (entry
->d_un
.d_val
== 0)
7444 static const char * opts
[] =
7446 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7447 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7448 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7449 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7455 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7456 if (entry
->d_un
.d_val
& (1 << cnt
))
7458 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7464 case DT_MIPS_IVERSION
:
7465 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7466 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7468 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7471 case DT_MIPS_TIME_STAMP
:
7476 time_t atime
= entry
->d_un
.d_val
;
7477 tmp
= gmtime (&atime
);
7478 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7479 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7480 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7481 printf (_("Time Stamp: %s"), timebuf
);
7485 case DT_MIPS_RLD_VERSION
:
7486 case DT_MIPS_LOCAL_GOTNO
:
7487 case DT_MIPS_CONFLICTNO
:
7488 case DT_MIPS_LIBLISTNO
:
7489 case DT_MIPS_SYMTABNO
:
7490 case DT_MIPS_UNREFEXTNO
:
7491 case DT_MIPS_HIPAGENO
:
7492 case DT_MIPS_DELTA_CLASS_NO
:
7493 case DT_MIPS_DELTA_INSTANCE_NO
:
7494 case DT_MIPS_DELTA_RELOC_NO
:
7495 case DT_MIPS_DELTA_SYM_NO
:
7496 case DT_MIPS_DELTA_CLASSSYM_NO
:
7497 case DT_MIPS_COMPACT_SIZE
:
7498 print_vma (entry
->d_un
.d_ptr
, DEC
);
7502 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7508 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7510 switch (entry
->d_tag
)
7512 case DT_HP_DLD_FLAGS
:
7521 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7522 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7523 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7524 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7525 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7526 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7527 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7528 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7529 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7530 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7531 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7532 { DT_HP_GST
, "HP_GST" },
7533 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7534 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7535 { DT_HP_NODELETE
, "HP_NODELETE" },
7536 { DT_HP_GROUP
, "HP_GROUP" },
7537 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7541 bfd_vma val
= entry
->d_un
.d_val
;
7543 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7544 if (val
& flags
[cnt
].bit
)
7548 fputs (flags
[cnt
].str
, stdout
);
7550 val
^= flags
[cnt
].bit
;
7553 if (val
!= 0 || first
)
7557 print_vma (val
, HEX
);
7563 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7571 /* VMS vs Unix time offset and factor. */
7573 #define VMS_EPOCH_OFFSET 35067168000000000LL
7574 #define VMS_GRANULARITY_FACTOR 10000000
7576 /* Display a VMS time in a human readable format. */
7579 print_vms_time (bfd_int64_t vmstime
)
7584 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7585 tm
= gmtime (&unxtime
);
7586 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7587 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7588 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7593 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7595 switch (entry
->d_tag
)
7597 case DT_IA_64_PLT_RESERVE
:
7598 /* First 3 slots reserved. */
7599 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7601 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7604 case DT_IA_64_VMS_LINKTIME
:
7606 print_vms_time (entry
->d_un
.d_val
);
7610 case DT_IA_64_VMS_LNKFLAGS
:
7611 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7612 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7613 printf (" CALL_DEBUG");
7614 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7615 printf (" NOP0BUFS");
7616 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7617 printf (" P0IMAGE");
7618 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7619 printf (" MKTHREADS");
7620 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7621 printf (" UPCALLS");
7622 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7624 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7625 printf (" INITIALIZE");
7626 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7628 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7629 printf (" EXE_INIT");
7630 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7631 printf (" TBK_IN_IMG");
7632 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7633 printf (" DBG_IN_IMG");
7634 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7635 printf (" TBK_IN_DSF");
7636 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7637 printf (" DBG_IN_DSF");
7638 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7639 printf (" SIGNATURES");
7640 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7641 printf (" REL_SEG_OFF");
7645 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7652 get_32bit_dynamic_section (FILE * file
)
7654 Elf32_External_Dyn
* edyn
;
7655 Elf32_External_Dyn
* ext
;
7656 Elf_Internal_Dyn
* entry
;
7658 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7659 dynamic_size
, _("dynamic section"));
7663 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7664 might not have the luxury of section headers. Look for the DT_NULL
7665 terminator to determine the number of entries. */
7666 for (ext
= edyn
, dynamic_nent
= 0;
7667 (char *) ext
< (char *) edyn
+ dynamic_size
;
7671 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7675 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7677 if (dynamic_section
== NULL
)
7679 error (_("Out of memory\n"));
7684 for (ext
= edyn
, entry
= dynamic_section
;
7685 entry
< dynamic_section
+ dynamic_nent
;
7688 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7689 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7698 get_64bit_dynamic_section (FILE * file
)
7700 Elf64_External_Dyn
* edyn
;
7701 Elf64_External_Dyn
* ext
;
7702 Elf_Internal_Dyn
* entry
;
7704 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7705 dynamic_size
, _("dynamic section"));
7709 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7710 might not have the luxury of section headers. Look for the DT_NULL
7711 terminator to determine the number of entries. */
7712 for (ext
= edyn
, dynamic_nent
= 0;
7713 (char *) ext
< (char *) edyn
+ dynamic_size
;
7717 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7721 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7723 if (dynamic_section
== NULL
)
7725 error (_("Out of memory\n"));
7730 for (ext
= edyn
, entry
= dynamic_section
;
7731 entry
< dynamic_section
+ dynamic_nent
;
7734 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7735 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7744 print_dynamic_flags (bfd_vma flags
)
7752 flag
= flags
& - flags
;
7762 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7763 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7764 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7765 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7766 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7767 default: fputs (_("unknown"), stdout
); break;
7773 /* Parse and display the contents of the dynamic section. */
7776 process_dynamic_section (FILE * file
)
7778 Elf_Internal_Dyn
* entry
;
7780 if (dynamic_size
== 0)
7783 printf (_("\nThere is no dynamic section in this file.\n"));
7790 if (! get_32bit_dynamic_section (file
))
7793 else if (! get_64bit_dynamic_section (file
))
7796 /* Find the appropriate symbol table. */
7797 if (dynamic_symbols
== NULL
)
7799 for (entry
= dynamic_section
;
7800 entry
< dynamic_section
+ dynamic_nent
;
7803 Elf_Internal_Shdr section
;
7805 if (entry
->d_tag
!= DT_SYMTAB
)
7808 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7810 /* Since we do not know how big the symbol table is,
7811 we default to reading in the entire file (!) and
7812 processing that. This is overkill, I know, but it
7814 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7816 if (archive_file_offset
!= 0)
7817 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7820 if (fseek (file
, 0, SEEK_END
))
7821 error (_("Unable to seek to end of file!\n"));
7823 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7827 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7829 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7831 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7832 if (num_dynamic_syms
< 1)
7834 error (_("Unable to determine the number of symbols to load\n"));
7840 /* Similarly find a string table. */
7841 if (dynamic_strings
== NULL
)
7843 for (entry
= dynamic_section
;
7844 entry
< dynamic_section
+ dynamic_nent
;
7847 unsigned long offset
;
7850 if (entry
->d_tag
!= DT_STRTAB
)
7853 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7855 /* Since we do not know how big the string table is,
7856 we default to reading in the entire file (!) and
7857 processing that. This is overkill, I know, but it
7860 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7862 if (archive_file_offset
!= 0)
7863 str_tab_len
= archive_file_size
- offset
;
7866 if (fseek (file
, 0, SEEK_END
))
7867 error (_("Unable to seek to end of file\n"));
7868 str_tab_len
= ftell (file
) - offset
;
7871 if (str_tab_len
< 1)
7874 (_("Unable to determine the length of the dynamic string table\n"));
7878 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7880 _("dynamic string table"));
7881 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7886 /* And find the syminfo section if available. */
7887 if (dynamic_syminfo
== NULL
)
7889 unsigned long syminsz
= 0;
7891 for (entry
= dynamic_section
;
7892 entry
< dynamic_section
+ dynamic_nent
;
7895 if (entry
->d_tag
== DT_SYMINENT
)
7897 /* Note: these braces are necessary to avoid a syntax
7898 error from the SunOS4 C compiler. */
7899 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7901 else if (entry
->d_tag
== DT_SYMINSZ
)
7902 syminsz
= entry
->d_un
.d_val
;
7903 else if (entry
->d_tag
== DT_SYMINFO
)
7904 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7908 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7910 Elf_External_Syminfo
* extsyminfo
;
7911 Elf_External_Syminfo
* extsym
;
7912 Elf_Internal_Syminfo
* syminfo
;
7914 /* There is a syminfo section. Read the data. */
7915 extsyminfo
= (Elf_External_Syminfo
*)
7916 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7917 _("symbol information"));
7921 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7922 if (dynamic_syminfo
== NULL
)
7924 error (_("Out of memory\n"));
7928 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7929 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7930 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7931 ++syminfo
, ++extsym
)
7933 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7934 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7941 if (do_dynamic
&& dynamic_addr
)
7942 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7943 dynamic_addr
, dynamic_nent
);
7945 printf (_(" Tag Type Name/Value\n"));
7947 for (entry
= dynamic_section
;
7948 entry
< dynamic_section
+ dynamic_nent
;
7956 print_vma (entry
->d_tag
, FULL_HEX
);
7957 dtype
= get_dynamic_type (entry
->d_tag
);
7958 printf (" (%s)%*s", dtype
,
7959 ((is_32bit_elf
? 27 : 19)
7960 - (int) strlen (dtype
)),
7964 switch (entry
->d_tag
)
7968 print_dynamic_flags (entry
->d_un
.d_val
);
7978 switch (entry
->d_tag
)
7981 printf (_("Auxiliary library"));
7985 printf (_("Filter library"));
7989 printf (_("Configuration file"));
7993 printf (_("Dependency audit library"));
7997 printf (_("Audit library"));
8001 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8002 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8006 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8015 printf (_("Flags:"));
8017 if (entry
->d_un
.d_val
== 0)
8018 printf (_(" None\n"));
8021 unsigned long int val
= entry
->d_un
.d_val
;
8023 if (val
& DTF_1_PARINIT
)
8025 printf (" PARINIT");
8026 val
^= DTF_1_PARINIT
;
8028 if (val
& DTF_1_CONFEXP
)
8030 printf (" CONFEXP");
8031 val
^= DTF_1_CONFEXP
;
8034 printf (" %lx", val
);
8043 printf (_("Flags:"));
8045 if (entry
->d_un
.d_val
== 0)
8046 printf (_(" None\n"));
8049 unsigned long int val
= entry
->d_un
.d_val
;
8051 if (val
& DF_P1_LAZYLOAD
)
8053 printf (" LAZYLOAD");
8054 val
^= DF_P1_LAZYLOAD
;
8056 if (val
& DF_P1_GROUPPERM
)
8058 printf (" GROUPPERM");
8059 val
^= DF_P1_GROUPPERM
;
8062 printf (" %lx", val
);
8071 printf (_("Flags:"));
8072 if (entry
->d_un
.d_val
== 0)
8073 printf (_(" None\n"));
8076 unsigned long int val
= entry
->d_un
.d_val
;
8083 if (val
& DF_1_GLOBAL
)
8088 if (val
& DF_1_GROUP
)
8093 if (val
& DF_1_NODELETE
)
8095 printf (" NODELETE");
8096 val
^= DF_1_NODELETE
;
8098 if (val
& DF_1_LOADFLTR
)
8100 printf (" LOADFLTR");
8101 val
^= DF_1_LOADFLTR
;
8103 if (val
& DF_1_INITFIRST
)
8105 printf (" INITFIRST");
8106 val
^= DF_1_INITFIRST
;
8108 if (val
& DF_1_NOOPEN
)
8113 if (val
& DF_1_ORIGIN
)
8118 if (val
& DF_1_DIRECT
)
8123 if (val
& DF_1_TRANS
)
8128 if (val
& DF_1_INTERPOSE
)
8130 printf (" INTERPOSE");
8131 val
^= DF_1_INTERPOSE
;
8133 if (val
& DF_1_NODEFLIB
)
8135 printf (" NODEFLIB");
8136 val
^= DF_1_NODEFLIB
;
8138 if (val
& DF_1_NODUMP
)
8143 if (val
& DF_1_CONFALT
)
8145 printf (" CONFALT");
8146 val
^= DF_1_CONFALT
;
8148 if (val
& DF_1_ENDFILTEE
)
8150 printf (" ENDFILTEE");
8151 val
^= DF_1_ENDFILTEE
;
8153 if (val
& DF_1_DISPRELDNE
)
8155 printf (" DISPRELDNE");
8156 val
^= DF_1_DISPRELDNE
;
8158 if (val
& DF_1_DISPRELPND
)
8160 printf (" DISPRELPND");
8161 val
^= DF_1_DISPRELPND
;
8163 if (val
& DF_1_NODIRECT
)
8165 printf (" NODIRECT");
8166 val
^= DF_1_NODIRECT
;
8168 if (val
& DF_1_IGNMULDEF
)
8170 printf (" IGNMULDEF");
8171 val
^= DF_1_IGNMULDEF
;
8173 if (val
& DF_1_NOKSYMS
)
8175 printf (" NOKSYMS");
8176 val
^= DF_1_NOKSYMS
;
8178 if (val
& DF_1_NOHDR
)
8183 if (val
& DF_1_EDITED
)
8188 if (val
& DF_1_NORELOC
)
8190 printf (" NORELOC");
8191 val
^= DF_1_NORELOC
;
8193 if (val
& DF_1_SYMINTPOSE
)
8195 printf (" SYMINTPOSE");
8196 val
^= DF_1_SYMINTPOSE
;
8198 if (val
& DF_1_GLOBAUDIT
)
8200 printf (" GLOBAUDIT");
8201 val
^= DF_1_GLOBAUDIT
;
8203 if (val
& DF_1_SINGLETON
)
8205 printf (" SINGLETON");
8206 val
^= DF_1_SINGLETON
;
8209 printf (" %lx", val
);
8216 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8218 puts (get_dynamic_type (entry
->d_un
.d_val
));
8238 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8244 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8245 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8251 switch (entry
->d_tag
)
8254 printf (_("Shared library: [%s]"), name
);
8256 if (streq (name
, program_interpreter
))
8257 printf (_(" program interpreter"));
8261 printf (_("Library soname: [%s]"), name
);
8265 printf (_("Library rpath: [%s]"), name
);
8269 printf (_("Library runpath: [%s]"), name
);
8273 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8278 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8291 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8295 case DT_INIT_ARRAYSZ
:
8296 case DT_FINI_ARRAYSZ
:
8297 case DT_GNU_CONFLICTSZ
:
8298 case DT_GNU_LIBLISTSZ
:
8301 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8302 printf (_(" (bytes)\n"));
8312 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8325 if (entry
->d_tag
== DT_USED
8326 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8328 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8332 printf (_("Not needed object: [%s]\n"), name
);
8337 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8343 /* The value of this entry is ignored. */
8348 case DT_GNU_PRELINKED
:
8352 time_t atime
= entry
->d_un
.d_val
;
8354 tmp
= gmtime (&atime
);
8355 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8356 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8357 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8363 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8366 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8372 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8373 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8378 switch (elf_header
.e_machine
)
8381 case EM_MIPS_RS3_LE
:
8382 dynamic_section_mips_val (entry
);
8385 dynamic_section_parisc_val (entry
);
8388 dynamic_section_ia64_val (entry
);
8391 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8403 get_ver_flags (unsigned int flags
)
8405 static char buff
[32];
8412 if (flags
& VER_FLG_BASE
)
8413 strcat (buff
, "BASE ");
8415 if (flags
& VER_FLG_WEAK
)
8417 if (flags
& VER_FLG_BASE
)
8418 strcat (buff
, "| ");
8420 strcat (buff
, "WEAK ");
8423 if (flags
& VER_FLG_INFO
)
8425 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8426 strcat (buff
, "| ");
8428 strcat (buff
, "INFO ");
8431 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8432 strcat (buff
, _("| <unknown>"));
8437 /* Display the contents of the version sections. */
8440 process_version_sections (FILE * file
)
8442 Elf_Internal_Shdr
* section
;
8449 for (i
= 0, section
= section_headers
;
8450 i
< elf_header
.e_shnum
;
8453 switch (section
->sh_type
)
8455 case SHT_GNU_verdef
:
8457 Elf_External_Verdef
* edefs
;
8465 (_("\nVersion definition section '%s' contains %u entries:\n"),
8466 SECTION_NAME (section
), section
->sh_info
);
8468 printf (_(" Addr: 0x"));
8469 printf_vma (section
->sh_addr
);
8470 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8471 (unsigned long) section
->sh_offset
, section
->sh_link
,
8472 section
->sh_link
< elf_header
.e_shnum
8473 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8476 edefs
= (Elf_External_Verdef
*)
8477 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8478 _("version definition section"));
8481 endbuf
= (char *) edefs
+ section
->sh_size
;
8483 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8486 Elf_External_Verdef
* edef
;
8487 Elf_Internal_Verdef ent
;
8488 Elf_External_Verdaux
* eaux
;
8489 Elf_Internal_Verdaux aux
;
8493 /* Check for very large indicies. */
8494 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8497 vstart
= ((char *) edefs
) + idx
;
8498 if (vstart
+ sizeof (*edef
) > endbuf
)
8501 edef
= (Elf_External_Verdef
*) vstart
;
8503 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8504 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8505 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8506 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8507 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8508 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8509 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8511 printf (_(" %#06x: Rev: %d Flags: %s"),
8512 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8514 printf (_(" Index: %d Cnt: %d "),
8515 ent
.vd_ndx
, ent
.vd_cnt
);
8517 /* Check for overflow. */
8518 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8521 vstart
+= ent
.vd_aux
;
8523 eaux
= (Elf_External_Verdaux
*) vstart
;
8525 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8526 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8528 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8529 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8531 printf (_("Name index: %ld\n"), aux
.vda_name
);
8533 isum
= idx
+ ent
.vd_aux
;
8535 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8537 /* Check for overflow. */
8538 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8541 isum
+= aux
.vda_next
;
8542 vstart
+= aux
.vda_next
;
8544 eaux
= (Elf_External_Verdaux
*) vstart
;
8545 if (vstart
+ sizeof (*eaux
) > endbuf
)
8548 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8549 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8551 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8552 printf (_(" %#06x: Parent %d: %s\n"),
8553 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8555 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8556 isum
, j
, aux
.vda_name
);
8560 printf (_(" Version def aux past end of section\n"));
8565 if (cnt
< section
->sh_info
)
8566 printf (_(" Version definition past end of section\n"));
8572 case SHT_GNU_verneed
:
8574 Elf_External_Verneed
* eneed
;
8581 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8582 SECTION_NAME (section
), section
->sh_info
);
8584 printf (_(" Addr: 0x"));
8585 printf_vma (section
->sh_addr
);
8586 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8587 (unsigned long) section
->sh_offset
, section
->sh_link
,
8588 section
->sh_link
< elf_header
.e_shnum
8589 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8592 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8593 section
->sh_offset
, 1,
8595 _("Version Needs section"));
8598 endbuf
= (char *) eneed
+ section
->sh_size
;
8600 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8602 Elf_External_Verneed
* entry
;
8603 Elf_Internal_Verneed ent
;
8608 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8611 vstart
= ((char *) eneed
) + idx
;
8612 if (vstart
+ sizeof (*entry
) > endbuf
)
8615 entry
= (Elf_External_Verneed
*) vstart
;
8617 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8618 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8619 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8620 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8621 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8623 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8625 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8626 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8628 printf (_(" File: %lx"), ent
.vn_file
);
8630 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8632 /* Check for overflow. */
8633 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8636 vstart
+= ent
.vn_aux
;
8638 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8640 Elf_External_Vernaux
* eaux
;
8641 Elf_Internal_Vernaux aux
;
8643 if (vstart
+ sizeof (*eaux
) > endbuf
)
8645 eaux
= (Elf_External_Vernaux
*) vstart
;
8647 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8648 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8649 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8650 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8651 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8653 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8654 printf (_(" %#06x: Name: %s"),
8655 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8657 printf (_(" %#06x: Name index: %lx"),
8658 isum
, aux
.vna_name
);
8660 printf (_(" Flags: %s Version: %d\n"),
8661 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8663 /* Check for overflow. */
8664 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8667 isum
+= aux
.vna_next
;
8668 vstart
+= aux
.vna_next
;
8672 warn (_("Missing Version Needs auxillary information\n"));
8677 if (cnt
< section
->sh_info
)
8678 warn (_("Missing Version Needs information\n"));
8684 case SHT_GNU_versym
:
8686 Elf_Internal_Shdr
* link_section
;
8689 unsigned char * edata
;
8690 unsigned short * data
;
8692 Elf_Internal_Sym
* symbols
;
8693 Elf_Internal_Shdr
* string_sec
;
8694 unsigned long num_syms
;
8697 if (section
->sh_link
>= elf_header
.e_shnum
)
8700 link_section
= section_headers
+ section
->sh_link
;
8701 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8703 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8708 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8709 if (symbols
== NULL
)
8712 string_sec
= section_headers
+ link_section
->sh_link
;
8714 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8715 string_sec
->sh_size
,
8716 _("version string table"));
8723 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8724 SECTION_NAME (section
), total
);
8726 printf (_(" Addr: "));
8727 printf_vma (section
->sh_addr
);
8728 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8729 (unsigned long) section
->sh_offset
, section
->sh_link
,
8730 SECTION_NAME (link_section
));
8732 off
= offset_from_vma (file
,
8733 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8734 total
* sizeof (short));
8735 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8737 _("version symbol data"));
8745 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8747 for (cnt
= total
; cnt
--;)
8748 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8753 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8756 int check_def
, check_need
;
8759 printf (" %03x:", cnt
);
8761 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8762 switch (data
[cnt
+ j
])
8765 fputs (_(" 0 (*local*) "), stdout
);
8769 fputs (_(" 1 (*global*) "), stdout
);
8773 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8774 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8776 /* If this index value is greater than the size of the symbols
8777 array, break to avoid an out-of-bounds read. */
8778 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8780 warn (_("invalid index into symbol array\n"));
8786 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8787 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8790 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8797 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8799 Elf_Internal_Verneed ivn
;
8800 unsigned long offset
;
8802 offset
= offset_from_vma
8803 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8804 sizeof (Elf_External_Verneed
));
8808 Elf_Internal_Vernaux ivna
;
8809 Elf_External_Verneed evn
;
8810 Elf_External_Vernaux evna
;
8811 unsigned long a_off
;
8813 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8814 _("version need")) == NULL
)
8817 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8818 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8820 a_off
= offset
+ ivn
.vn_aux
;
8824 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8825 1, _("version need aux (2)")) == NULL
)
8832 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8833 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8836 a_off
+= ivna
.vna_next
;
8838 while (ivna
.vna_other
!= data
[cnt
+ j
]
8839 && ivna
.vna_next
!= 0);
8841 if (ivna
.vna_other
== data
[cnt
+ j
])
8843 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8845 if (ivna
.vna_name
>= string_sec
->sh_size
)
8846 name
= _("*invalid*");
8848 name
= strtab
+ ivna
.vna_name
;
8849 nn
+= printf ("(%s%-*s",
8851 12 - (int) strlen (name
),
8857 offset
+= ivn
.vn_next
;
8859 while (ivn
.vn_next
);
8862 if (check_def
&& data
[cnt
+ j
] != 0x8001
8863 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8865 Elf_Internal_Verdef ivd
;
8866 Elf_External_Verdef evd
;
8867 unsigned long offset
;
8869 offset
= offset_from_vma
8870 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8875 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8876 _("version def")) == NULL
)
8883 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8884 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8887 offset
+= ivd
.vd_next
;
8889 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8890 && ivd
.vd_next
!= 0);
8892 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8894 Elf_External_Verdaux evda
;
8895 Elf_Internal_Verdaux ivda
;
8897 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8899 if (get_data (&evda
, file
,
8900 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8902 _("version def aux")) == NULL
)
8905 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8907 if (ivda
.vda_name
>= string_sec
->sh_size
)
8908 name
= _("*invalid*");
8910 name
= strtab
+ ivda
.vda_name
;
8911 nn
+= printf ("(%s%-*s",
8913 12 - (int) strlen (name
),
8919 printf ("%*c", 18 - nn
, ' ');
8937 printf (_("\nNo version information found in this file.\n"));
8943 get_symbol_binding (unsigned int binding
)
8945 static char buff
[32];
8949 case STB_LOCAL
: return "LOCAL";
8950 case STB_GLOBAL
: return "GLOBAL";
8951 case STB_WEAK
: return "WEAK";
8953 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8954 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8956 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8958 if (binding
== STB_GNU_UNIQUE
8959 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8960 /* GNU is still using the default value 0. */
8961 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8963 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8966 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8972 get_symbol_type (unsigned int type
)
8974 static char buff
[32];
8978 case STT_NOTYPE
: return "NOTYPE";
8979 case STT_OBJECT
: return "OBJECT";
8980 case STT_FUNC
: return "FUNC";
8981 case STT_SECTION
: return "SECTION";
8982 case STT_FILE
: return "FILE";
8983 case STT_COMMON
: return "COMMON";
8984 case STT_TLS
: return "TLS";
8985 case STT_RELC
: return "RELC";
8986 case STT_SRELC
: return "SRELC";
8988 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8990 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8991 return "THUMB_FUNC";
8993 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8996 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8997 return "PARISC_MILLI";
8999 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9001 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9003 if (elf_header
.e_machine
== EM_PARISC
)
9005 if (type
== STT_HP_OPAQUE
)
9007 if (type
== STT_HP_STUB
)
9011 if (type
== STT_GNU_IFUNC
9012 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9013 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9014 /* GNU is still using the default value 0. */
9015 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9018 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9021 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9027 get_symbol_visibility (unsigned int visibility
)
9031 case STV_DEFAULT
: return "DEFAULT";
9032 case STV_INTERNAL
: return "INTERNAL";
9033 case STV_HIDDEN
: return "HIDDEN";
9034 case STV_PROTECTED
: return "PROTECTED";
9040 get_mips_symbol_other (unsigned int other
)
9052 case STO_MICROMIPS
| STO_MIPS_PIC
:
9053 return "MICROMIPS, MIPS PIC";
9062 get_ia64_symbol_other (unsigned int other
)
9066 static char res
[32];
9070 /* Function types is for images and .STB files only. */
9071 switch (elf_header
.e_type
)
9075 switch (VMS_ST_FUNC_TYPE (other
))
9077 case VMS_SFT_CODE_ADDR
:
9078 strcat (res
, " CA");
9080 case VMS_SFT_SYMV_IDX
:
9081 strcat (res
, " VEC");
9084 strcat (res
, " FD");
9086 case VMS_SFT_RESERVE
:
9087 strcat (res
, " RSV");
9096 switch (VMS_ST_LINKAGE (other
))
9098 case VMS_STL_IGNORE
:
9099 strcat (res
, " IGN");
9101 case VMS_STL_RESERVE
:
9102 strcat (res
, " RSV");
9105 strcat (res
, " STD");
9108 strcat (res
, " LNK");
9123 get_symbol_other (unsigned int other
)
9125 const char * result
= NULL
;
9126 static char buff
[32];
9131 switch (elf_header
.e_machine
)
9134 result
= get_mips_symbol_other (other
);
9137 result
= get_ia64_symbol_other (other
);
9146 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9151 get_symbol_index_type (unsigned int type
)
9153 static char buff
[32];
9157 case SHN_UNDEF
: return "UND";
9158 case SHN_ABS
: return "ABS";
9159 case SHN_COMMON
: return "COM";
9161 if (type
== SHN_IA_64_ANSI_COMMON
9162 && elf_header
.e_machine
== EM_IA_64
9163 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9165 else if ((elf_header
.e_machine
== EM_X86_64
9166 || elf_header
.e_machine
== EM_L1OM
9167 || elf_header
.e_machine
== EM_K1OM
)
9168 && type
== SHN_X86_64_LCOMMON
)
9170 else if ((type
== SHN_MIPS_SCOMMON
9171 && elf_header
.e_machine
== EM_MIPS
)
9172 || (type
== SHN_TIC6X_SCOMMON
9173 && elf_header
.e_machine
== EM_TI_C6000
))
9175 else if (type
== SHN_MIPS_SUNDEFINED
9176 && elf_header
.e_machine
== EM_MIPS
)
9178 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9179 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9180 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9181 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9182 else if (type
>= SHN_LORESERVE
)
9183 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9184 else if (type
>= elf_header
.e_shnum
)
9185 sprintf (buff
, "bad section index[%3d]", type
);
9187 sprintf (buff
, "%3d", type
);
9195 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9197 unsigned char * e_data
;
9200 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9204 error (_("Out of memory\n"));
9208 if (fread (e_data
, ent_size
, number
, file
) != number
)
9210 error (_("Unable to read in dynamic data\n"));
9214 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9218 error (_("Out of memory\n"));
9224 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9232 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9234 Elf_Internal_Sym
* psym
;
9237 psym
= dynamic_symbols
+ si
;
9239 n
= print_vma (si
, DEC_5
);
9241 fputs (" " + n
, stdout
);
9242 printf (" %3lu: ", hn
);
9243 print_vma (psym
->st_value
, LONG_HEX
);
9245 print_vma (psym
->st_size
, DEC_5
);
9247 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9248 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9249 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9250 /* Check to see if any other bits in the st_other field are set.
9251 Note - displaying this information disrupts the layout of the
9252 table being generated, but for the moment this case is very
9254 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9255 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9256 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9257 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9258 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9260 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9264 /* Dump the symbol table. */
9266 process_symbol_table (FILE * file
)
9268 Elf_Internal_Shdr
* section
;
9269 bfd_vma nbuckets
= 0;
9270 bfd_vma nchains
= 0;
9271 bfd_vma
* buckets
= NULL
;
9272 bfd_vma
* chains
= NULL
;
9273 bfd_vma ngnubuckets
= 0;
9274 bfd_vma
* gnubuckets
= NULL
;
9275 bfd_vma
* gnuchains
= NULL
;
9276 bfd_vma gnusymidx
= 0;
9278 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9281 if (dynamic_info
[DT_HASH
]
9283 || (do_using_dynamic
9285 && dynamic_strings
!= NULL
)))
9287 unsigned char nb
[8];
9288 unsigned char nc
[8];
9289 int hash_ent_size
= 4;
9291 if ((elf_header
.e_machine
== EM_ALPHA
9292 || elf_header
.e_machine
== EM_S390
9293 || elf_header
.e_machine
== EM_S390_OLD
)
9294 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9298 (archive_file_offset
9299 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9300 sizeof nb
+ sizeof nc
)),
9303 error (_("Unable to seek to start of dynamic information\n"));
9307 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9309 error (_("Failed to read in number of buckets\n"));
9313 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9315 error (_("Failed to read in number of chains\n"));
9319 nbuckets
= byte_get (nb
, hash_ent_size
);
9320 nchains
= byte_get (nc
, hash_ent_size
);
9322 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9323 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9326 if (buckets
== NULL
|| chains
== NULL
)
9328 if (do_using_dynamic
)
9339 if (dynamic_info_DT_GNU_HASH
9341 || (do_using_dynamic
9343 && dynamic_strings
!= NULL
)))
9345 unsigned char nb
[16];
9346 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9347 bfd_vma buckets_vma
;
9350 (archive_file_offset
9351 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9355 error (_("Unable to seek to start of dynamic information\n"));
9359 if (fread (nb
, 16, 1, file
) != 1)
9361 error (_("Failed to read in number of buckets\n"));
9365 ngnubuckets
= byte_get (nb
, 4);
9366 gnusymidx
= byte_get (nb
+ 4, 4);
9367 bitmaskwords
= byte_get (nb
+ 8, 4);
9368 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9370 buckets_vma
+= bitmaskwords
* 4;
9372 buckets_vma
+= bitmaskwords
* 8;
9375 (archive_file_offset
9376 + offset_from_vma (file
, buckets_vma
, 4)),
9379 error (_("Unable to seek to start of dynamic information\n"));
9383 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9385 if (gnubuckets
== NULL
)
9388 for (i
= 0; i
< ngnubuckets
; i
++)
9389 if (gnubuckets
[i
] != 0)
9391 if (gnubuckets
[i
] < gnusymidx
)
9394 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9395 maxchain
= gnubuckets
[i
];
9398 if (maxchain
== 0xffffffff)
9401 maxchain
-= gnusymidx
;
9404 (archive_file_offset
9405 + offset_from_vma (file
, buckets_vma
9406 + 4 * (ngnubuckets
+ maxchain
), 4)),
9409 error (_("Unable to seek to start of dynamic information\n"));
9415 if (fread (nb
, 4, 1, file
) != 1)
9417 error (_("Failed to determine last chain length\n"));
9421 if (maxchain
+ 1 == 0)
9426 while ((byte_get (nb
, 4) & 1) == 0);
9429 (archive_file_offset
9430 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9433 error (_("Unable to seek to start of dynamic information\n"));
9437 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9440 if (gnuchains
== NULL
)
9445 if (do_using_dynamic
)
9450 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9453 && dynamic_strings
!= NULL
)
9457 if (dynamic_info
[DT_HASH
])
9461 printf (_("\nSymbol table for image:\n"));
9463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9465 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9467 for (hn
= 0; hn
< nbuckets
; hn
++)
9472 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9473 print_dynamic_symbol (si
, hn
);
9477 if (dynamic_info_DT_GNU_HASH
)
9479 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9481 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9483 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9485 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9486 if (gnubuckets
[hn
] != 0)
9488 bfd_vma si
= gnubuckets
[hn
];
9489 bfd_vma off
= si
- gnusymidx
;
9493 print_dynamic_symbol (si
, hn
);
9496 while ((gnuchains
[off
++] & 1) == 0);
9500 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9504 for (i
= 0, section
= section_headers
;
9505 i
< elf_header
.e_shnum
;
9509 char * strtab
= NULL
;
9510 unsigned long int strtab_size
= 0;
9511 Elf_Internal_Sym
* symtab
;
9512 Elf_Internal_Sym
* psym
;
9513 unsigned long num_syms
;
9515 if ((section
->sh_type
!= SHT_SYMTAB
9516 && section
->sh_type
!= SHT_DYNSYM
)
9518 && section
->sh_type
== SHT_SYMTAB
))
9521 if (section
->sh_entsize
== 0)
9523 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9524 SECTION_NAME (section
));
9528 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9529 SECTION_NAME (section
),
9530 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9533 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9535 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9537 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9541 if (section
->sh_link
== elf_header
.e_shstrndx
)
9543 strtab
= string_table
;
9544 strtab_size
= string_table_length
;
9546 else if (section
->sh_link
< elf_header
.e_shnum
)
9548 Elf_Internal_Shdr
* string_sec
;
9550 string_sec
= section_headers
+ section
->sh_link
;
9552 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9553 1, string_sec
->sh_size
,
9555 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9558 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9560 printf ("%6d: ", si
);
9561 print_vma (psym
->st_value
, LONG_HEX
);
9563 print_vma (psym
->st_size
, DEC_5
);
9564 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9565 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9566 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9567 /* Check to see if any other bits in the st_other field are set.
9568 Note - displaying this information disrupts the layout of the
9569 table being generated, but for the moment this case is very rare. */
9570 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9571 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9572 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9573 print_symbol (25, psym
->st_name
< strtab_size
9574 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9576 if (section
->sh_type
== SHT_DYNSYM
9577 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9579 unsigned char data
[2];
9580 unsigned short vers_data
;
9581 unsigned long offset
;
9585 offset
= offset_from_vma
9586 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9587 sizeof data
+ si
* sizeof (vers_data
));
9589 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9590 sizeof (data
), 1, _("version data")) == NULL
)
9593 vers_data
= byte_get (data
, 2);
9595 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9596 && section_headers
[psym
->st_shndx
].sh_type
9599 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9601 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9603 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9604 && (is_nobits
|| ! check_def
))
9606 Elf_External_Verneed evn
;
9607 Elf_Internal_Verneed ivn
;
9608 Elf_Internal_Vernaux ivna
;
9610 /* We must test both. */
9611 offset
= offset_from_vma
9612 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9617 unsigned long vna_off
;
9619 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9620 _("version need")) == NULL
)
9628 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9629 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9631 vna_off
= offset
+ ivn
.vn_aux
;
9635 Elf_External_Vernaux evna
;
9637 if (get_data (&evna
, file
, vna_off
,
9639 _("version need aux (3)")) == NULL
)
9647 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9648 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9649 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9652 vna_off
+= ivna
.vna_next
;
9654 while (ivna
.vna_other
!= vers_data
9655 && ivna
.vna_next
!= 0);
9657 if (ivna
.vna_other
== vers_data
)
9660 offset
+= ivn
.vn_next
;
9662 while (ivn
.vn_next
!= 0);
9664 if (ivna
.vna_other
== vers_data
)
9667 ivna
.vna_name
< strtab_size
9668 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9672 else if (! is_nobits
)
9673 error (_("bad dynamic symbol\n"));
9680 if (vers_data
!= 0x8001
9681 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9683 Elf_Internal_Verdef ivd
;
9684 Elf_Internal_Verdaux ivda
;
9685 Elf_External_Verdaux evda
;
9688 off
= offset_from_vma
9690 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9691 sizeof (Elf_External_Verdef
));
9695 Elf_External_Verdef evd
;
9697 if (get_data (&evd
, file
, off
, sizeof (evd
),
9698 1, _("version def")) == NULL
)
9706 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9707 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9708 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9713 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9714 && ivd
.vd_next
!= 0);
9719 if (get_data (&evda
, file
, off
, sizeof (evda
),
9720 1, _("version def aux")) == NULL
)
9723 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9725 if (psym
->st_name
!= ivda
.vda_name
)
9726 printf ((vers_data
& VERSYM_HIDDEN
)
9728 ivda
.vda_name
< strtab_size
9729 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9739 if (strtab
!= string_table
)
9745 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9747 if (do_histogram
&& buckets
!= NULL
)
9749 unsigned long * lengths
;
9750 unsigned long * counts
;
9753 unsigned long maxlength
= 0;
9754 unsigned long nzero_counts
= 0;
9755 unsigned long nsyms
= 0;
9757 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9758 (unsigned long) nbuckets
);
9759 printf (_(" Length Number %% of total Coverage\n"));
9761 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9762 if (lengths
== NULL
)
9764 error (_("Out of memory\n"));
9767 for (hn
= 0; hn
< nbuckets
; ++hn
)
9769 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9772 if (maxlength
< ++lengths
[hn
])
9777 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9780 error (_("Out of memory\n"));
9784 for (hn
= 0; hn
< nbuckets
; ++hn
)
9785 ++counts
[lengths
[hn
]];
9790 printf (" 0 %-10lu (%5.1f%%)\n",
9791 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9792 for (i
= 1; i
<= maxlength
; ++i
)
9794 nzero_counts
+= counts
[i
] * i
;
9795 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9796 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9797 (nzero_counts
* 100.0) / nsyms
);
9805 if (buckets
!= NULL
)
9811 if (do_histogram
&& gnubuckets
!= NULL
)
9813 unsigned long * lengths
;
9814 unsigned long * counts
;
9816 unsigned long maxlength
= 0;
9817 unsigned long nzero_counts
= 0;
9818 unsigned long nsyms
= 0;
9820 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9821 if (lengths
== NULL
)
9823 error (_("Out of memory\n"));
9827 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9828 (unsigned long) ngnubuckets
);
9829 printf (_(" Length Number %% of total Coverage\n"));
9831 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9832 if (gnubuckets
[hn
] != 0)
9834 bfd_vma off
, length
= 1;
9836 for (off
= gnubuckets
[hn
] - gnusymidx
;
9837 (gnuchains
[off
] & 1) == 0; ++off
)
9839 lengths
[hn
] = length
;
9840 if (length
> maxlength
)
9845 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9848 error (_("Out of memory\n"));
9852 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9853 ++counts
[lengths
[hn
]];
9855 if (ngnubuckets
> 0)
9858 printf (" 0 %-10lu (%5.1f%%)\n",
9859 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9860 for (j
= 1; j
<= maxlength
; ++j
)
9862 nzero_counts
+= counts
[j
] * j
;
9863 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9864 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9865 (nzero_counts
* 100.0) / nsyms
);
9879 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9883 if (dynamic_syminfo
== NULL
9885 /* No syminfo, this is ok. */
9888 /* There better should be a dynamic symbol section. */
9889 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9893 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9894 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9896 printf (_(" Num: Name BoundTo Flags\n"));
9897 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9899 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9901 printf ("%4d: ", i
);
9902 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9903 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9905 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9908 switch (dynamic_syminfo
[i
].si_boundto
)
9910 case SYMINFO_BT_SELF
:
9911 fputs ("SELF ", stdout
);
9913 case SYMINFO_BT_PARENT
:
9914 fputs ("PARENT ", stdout
);
9917 if (dynamic_syminfo
[i
].si_boundto
> 0
9918 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9919 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9921 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9925 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9929 if (flags
& SYMINFO_FLG_DIRECT
)
9931 if (flags
& SYMINFO_FLG_PASSTHRU
)
9932 printf (" PASSTHRU");
9933 if (flags
& SYMINFO_FLG_COPY
)
9935 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9936 printf (" LAZYLOAD");
9944 /* Check to see if the given reloc needs to be handled in a target specific
9945 manner. If so then process the reloc and return TRUE otherwise return
9949 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9950 unsigned char * start
,
9951 Elf_Internal_Sym
* symtab
)
9953 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9955 switch (elf_header
.e_machine
)
9958 case EM_CYGNUS_MN10300
:
9960 static Elf_Internal_Sym
* saved_sym
= NULL
;
9964 case 34: /* R_MN10300_ALIGN */
9966 case 33: /* R_MN10300_SYM_DIFF */
9967 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9969 case 1: /* R_MN10300_32 */
9970 case 2: /* R_MN10300_16 */
9971 if (saved_sym
!= NULL
)
9975 value
= reloc
->r_addend
9976 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9977 - saved_sym
->st_value
);
9979 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9986 if (saved_sym
!= NULL
)
9987 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9997 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9998 DWARF debug sections. This is a target specific test. Note - we do not
9999 go through the whole including-target-headers-multiple-times route, (as
10000 we have already done with <elf/h8.h>) because this would become very
10001 messy and even then this function would have to contain target specific
10002 information (the names of the relocs instead of their numeric values).
10003 FIXME: This is not the correct way to solve this problem. The proper way
10004 is to have target specific reloc sizing and typing functions created by
10005 the reloc-macros.h header, in the same way that it already creates the
10006 reloc naming functions. */
10009 is_32bit_abs_reloc (unsigned int reloc_type
)
10011 switch (elf_header
.e_machine
)
10015 return reloc_type
== 1; /* R_386_32. */
10017 return reloc_type
== 1; /* R_68K_32. */
10019 return reloc_type
== 1; /* R_860_32. */
10021 return reloc_type
== 2; /* R_960_32. */
10023 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10025 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10027 return reloc_type
== 1; /* R_ARC_32. */
10029 return reloc_type
== 2; /* R_ARM_ABS32 */
10032 return reloc_type
== 1;
10033 case EM_ADAPTEVA_EPIPHANY
:
10034 return reloc_type
== 3;
10036 return reloc_type
== 0x12; /* R_byte4_data. */
10038 return reloc_type
== 3; /* R_CRIS_32. */
10040 return reloc_type
== 3; /* R_CR16_NUM32. */
10042 return reloc_type
== 15; /* R_CRX_NUM32. */
10043 case EM_CYGNUS_FRV
:
10044 return reloc_type
== 1;
10045 case EM_CYGNUS_D10V
:
10047 return reloc_type
== 6; /* R_D10V_32. */
10048 case EM_CYGNUS_D30V
:
10050 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10052 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10053 case EM_CYGNUS_FR30
:
10055 return reloc_type
== 3; /* R_FR30_32. */
10059 return reloc_type
== 1; /* R_H8_DIR32. */
10061 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10064 return reloc_type
== 2; /* R_IP2K_32. */
10066 return reloc_type
== 2; /* R_IQ2000_32. */
10067 case EM_LATTICEMICO32
:
10068 return reloc_type
== 3; /* R_LM32_32. */
10071 return reloc_type
== 3; /* R_M32C_32. */
10073 return reloc_type
== 34; /* R_M32R_32_RELA. */
10075 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10076 case EM_CYGNUS_MEP
:
10077 return reloc_type
== 4; /* R_MEP_32. */
10079 return reloc_type
== 2; /* R_METAG_ADDR32. */
10080 case EM_MICROBLAZE
:
10081 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10083 return reloc_type
== 2; /* R_MIPS_32. */
10085 return reloc_type
== 4; /* R_MMIX_32. */
10086 case EM_CYGNUS_MN10200
:
10088 return reloc_type
== 1; /* R_MN10200_32. */
10089 case EM_CYGNUS_MN10300
:
10091 return reloc_type
== 1; /* R_MN10300_32. */
10093 return reloc_type
== 1; /* R_MOXIE_32. */
10094 case EM_MSP430_OLD
:
10096 return reloc_type
== 1; /* R_MSP43_32. */
10098 return reloc_type
== 2; /* R_MT_32. */
10099 case EM_ALTERA_NIOS2
:
10100 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10102 return reloc_type
== 1; /* R_NIOS_32. */
10105 return reloc_type
== 1; /* R_OR32_32. */
10107 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10108 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10111 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10113 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10115 return reloc_type
== 1; /* R_PPC_ADDR32. */
10117 return reloc_type
== 1; /* R_RL78_DIR32. */
10119 return reloc_type
== 1; /* R_RX_DIR32. */
10121 return reloc_type
== 1; /* R_I370_ADDR31. */
10124 return reloc_type
== 4; /* R_S390_32. */
10126 return reloc_type
== 8; /* R_SCORE_ABS32. */
10128 return reloc_type
== 1; /* R_SH_DIR32. */
10129 case EM_SPARC32PLUS
:
10132 return reloc_type
== 3 /* R_SPARC_32. */
10133 || reloc_type
== 23; /* R_SPARC_UA32. */
10135 return reloc_type
== 6; /* R_SPU_ADDR32 */
10137 return reloc_type
== 1; /* R_C6000_ABS32. */
10139 return reloc_type
== 2; /* R_TILEGX_32. */
10141 return reloc_type
== 1; /* R_TILEPRO_32. */
10142 case EM_CYGNUS_V850
:
10144 return reloc_type
== 6; /* R_V850_ABS32. */
10146 return reloc_type
== 0x33; /* R_V810_WORD. */
10148 return reloc_type
== 1; /* R_VAX_32. */
10152 return reloc_type
== 10; /* R_X86_64_32. */
10155 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10157 return reloc_type
== 4; /* R_XGATE_32. */
10159 return reloc_type
== 1; /* R_XSTROMY16_32. */
10160 case EM_XTENSA_OLD
:
10162 return reloc_type
== 1; /* R_XTENSA_32. */
10164 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10165 elf_header
.e_machine
);
10170 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10171 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10174 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10176 switch (elf_header
.e_machine
)
10180 return reloc_type
== 2; /* R_386_PC32. */
10182 return reloc_type
== 4; /* R_68K_PC32. */
10184 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10185 case EM_ADAPTEVA_EPIPHANY
:
10186 return reloc_type
== 6;
10188 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10190 return reloc_type
== 3; /* R_ARM_REL32 */
10191 case EM_MICROBLAZE
:
10192 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10194 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10196 return reloc_type
== 26; /* R_PPC_REL32. */
10198 return reloc_type
== 26; /* R_PPC64_REL32. */
10201 return reloc_type
== 5; /* R_390_PC32. */
10203 return reloc_type
== 2; /* R_SH_REL32. */
10204 case EM_SPARC32PLUS
:
10207 return reloc_type
== 6; /* R_SPARC_DISP32. */
10209 return reloc_type
== 13; /* R_SPU_REL32. */
10211 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10213 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10217 return reloc_type
== 2; /* R_X86_64_PC32. */
10218 case EM_XTENSA_OLD
:
10220 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10222 /* Do not abort or issue an error message here. Not all targets use
10223 pc-relative 32-bit relocs in their DWARF debug information and we
10224 have already tested for target coverage in is_32bit_abs_reloc. A
10225 more helpful warning message will be generated by apply_relocations
10226 anyway, so just return. */
10231 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10232 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10235 is_64bit_abs_reloc (unsigned int reloc_type
)
10237 switch (elf_header
.e_machine
)
10240 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10242 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10244 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10246 return reloc_type
== 80; /* R_PARISC_DIR64. */
10248 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10249 case EM_SPARC32PLUS
:
10252 return reloc_type
== 54; /* R_SPARC_UA64. */
10256 return reloc_type
== 1; /* R_X86_64_64. */
10259 return reloc_type
== 22; /* R_S390_64. */
10261 return reloc_type
== 1; /* R_TILEGX_64. */
10263 return reloc_type
== 18; /* R_MIPS_64. */
10269 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10270 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10273 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10275 switch (elf_header
.e_machine
)
10278 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10280 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10282 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10284 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10286 return reloc_type
== 44; /* R_PPC64_REL64. */
10287 case EM_SPARC32PLUS
:
10290 return reloc_type
== 46; /* R_SPARC_DISP64. */
10294 return reloc_type
== 24; /* R_X86_64_PC64. */
10297 return reloc_type
== 23; /* R_S390_PC64. */
10299 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10305 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10306 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10309 is_24bit_abs_reloc (unsigned int reloc_type
)
10311 switch (elf_header
.e_machine
)
10313 case EM_CYGNUS_MN10200
:
10315 return reloc_type
== 4; /* R_MN10200_24. */
10321 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10322 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10325 is_16bit_abs_reloc (unsigned int reloc_type
)
10327 switch (elf_header
.e_machine
)
10331 return reloc_type
== 4; /* R_AVR_16. */
10332 case EM_ADAPTEVA_EPIPHANY
:
10333 return reloc_type
== 5;
10334 case EM_CYGNUS_D10V
:
10336 return reloc_type
== 3; /* R_D10V_16. */
10340 return reloc_type
== R_H8_DIR16
;
10343 return reloc_type
== 1; /* R_IP2K_16. */
10346 return reloc_type
== 1; /* R_M32C_16 */
10348 case EM_MSP430_OLD
:
10349 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10350 case EM_ALTERA_NIOS2
:
10351 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10353 return reloc_type
== 9; /* R_NIOS_16. */
10355 return reloc_type
== 2; /* R_C6000_ABS16. */
10358 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10359 case EM_CYGNUS_MN10200
:
10361 return reloc_type
== 2; /* R_MN10200_16. */
10362 case EM_CYGNUS_MN10300
:
10364 return reloc_type
== 2; /* R_MN10300_16. */
10366 return reloc_type
== 3; /* R_XGATE_16. */
10372 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10373 relocation entries (possibly formerly used for SHT_GROUP sections). */
10376 is_none_reloc (unsigned int reloc_type
)
10378 switch (elf_header
.e_machine
)
10380 case EM_68K
: /* R_68K_NONE. */
10381 case EM_386
: /* R_386_NONE. */
10382 case EM_SPARC32PLUS
:
10384 case EM_SPARC
: /* R_SPARC_NONE. */
10385 case EM_MIPS
: /* R_MIPS_NONE. */
10386 case EM_PARISC
: /* R_PARISC_NONE. */
10387 case EM_ALPHA
: /* R_ALPHA_NONE. */
10388 case EM_ADAPTEVA_EPIPHANY
:
10389 case EM_PPC
: /* R_PPC_NONE. */
10390 case EM_PPC64
: /* R_PPC64_NONE. */
10391 case EM_ARM
: /* R_ARM_NONE. */
10392 case EM_IA_64
: /* R_IA64_NONE. */
10393 case EM_SH
: /* R_SH_NONE. */
10395 case EM_S390
: /* R_390_NONE. */
10396 case EM_CRIS
: /* R_CRIS_NONE. */
10397 case EM_X86_64
: /* R_X86_64_NONE. */
10398 case EM_L1OM
: /* R_X86_64_NONE. */
10399 case EM_K1OM
: /* R_X86_64_NONE. */
10400 case EM_MN10300
: /* R_MN10300_NONE. */
10401 case EM_MOXIE
: /* R_MOXIE_NONE. */
10402 case EM_M32R
: /* R_M32R_NONE. */
10403 case EM_TI_C6000
:/* R_C6000_NONE. */
10404 case EM_TILEGX
: /* R_TILEGX_NONE. */
10405 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10407 case EM_C166
: /* R_XC16X_NONE. */
10408 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10409 case EM_NIOS32
: /* R_NIOS_NONE. */
10410 return reloc_type
== 0;
10412 return reloc_type
== 0 || reloc_type
== 256;
10413 case EM_XTENSA_OLD
:
10415 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10416 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10417 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10418 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10420 return reloc_type
== 3; /* R_METAG_NONE. */
10425 /* Apply relocations to a section.
10426 Note: So far support has been added only for those relocations
10427 which can be found in debug sections.
10428 FIXME: Add support for more relocations ? */
10431 apply_relocations (void * file
,
10432 Elf_Internal_Shdr
* section
,
10433 unsigned char * start
)
10435 Elf_Internal_Shdr
* relsec
;
10436 unsigned char * end
= start
+ section
->sh_size
;
10438 if (elf_header
.e_type
!= ET_REL
)
10441 /* Find the reloc section associated with the section. */
10442 for (relsec
= section_headers
;
10443 relsec
< section_headers
+ elf_header
.e_shnum
;
10446 bfd_boolean is_rela
;
10447 unsigned long num_relocs
;
10448 Elf_Internal_Rela
* relocs
;
10449 Elf_Internal_Rela
* rp
;
10450 Elf_Internal_Shdr
* symsec
;
10451 Elf_Internal_Sym
* symtab
;
10452 unsigned long num_syms
;
10453 Elf_Internal_Sym
* sym
;
10455 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10456 || relsec
->sh_info
>= elf_header
.e_shnum
10457 || section_headers
+ relsec
->sh_info
!= section
10458 || relsec
->sh_size
== 0
10459 || relsec
->sh_link
>= elf_header
.e_shnum
)
10462 is_rela
= relsec
->sh_type
== SHT_RELA
;
10466 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10467 relsec
->sh_size
, & relocs
, & num_relocs
))
10472 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10473 relsec
->sh_size
, & relocs
, & num_relocs
))
10477 /* SH uses RELA but uses in place value instead of the addend field. */
10478 if (elf_header
.e_machine
== EM_SH
)
10481 symsec
= section_headers
+ relsec
->sh_link
;
10482 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10484 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10487 unsigned int reloc_type
;
10488 unsigned int reloc_size
;
10489 unsigned char * rloc
;
10490 unsigned long sym_index
;
10492 reloc_type
= get_reloc_type (rp
->r_info
);
10494 if (target_specific_reloc_handling (rp
, start
, symtab
))
10496 else if (is_none_reloc (reloc_type
))
10498 else if (is_32bit_abs_reloc (reloc_type
)
10499 || is_32bit_pcrel_reloc (reloc_type
))
10501 else if (is_64bit_abs_reloc (reloc_type
)
10502 || is_64bit_pcrel_reloc (reloc_type
))
10504 else if (is_24bit_abs_reloc (reloc_type
))
10506 else if (is_16bit_abs_reloc (reloc_type
))
10510 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10511 reloc_type
, SECTION_NAME (section
));
10515 rloc
= start
+ rp
->r_offset
;
10516 if ((rloc
+ reloc_size
) > end
)
10518 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10519 (unsigned long) rp
->r_offset
,
10520 SECTION_NAME (section
));
10524 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10525 if (sym_index
>= num_syms
)
10527 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10528 sym_index
, SECTION_NAME (section
));
10531 sym
= symtab
+ sym_index
;
10533 /* If the reloc has a symbol associated with it,
10534 make sure that it is of an appropriate type.
10536 Relocations against symbols without type can happen.
10537 Gcc -feliminate-dwarf2-dups may generate symbols
10538 without type for debug info.
10540 Icc generates relocations against function symbols
10541 instead of local labels.
10543 Relocations against object symbols can happen, eg when
10544 referencing a global array. For an example of this see
10545 the _clz.o binary in libgcc.a. */
10547 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10549 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10550 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10551 (long int)(rp
- relocs
),
10552 SECTION_NAME (relsec
));
10558 addend
+= rp
->r_addend
;
10559 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10560 partial_inplace. */
10562 || (elf_header
.e_machine
== EM_XTENSA
10563 && reloc_type
== 1)
10564 || ((elf_header
.e_machine
== EM_PJ
10565 || elf_header
.e_machine
== EM_PJ_OLD
)
10566 && reloc_type
== 1)
10567 || ((elf_header
.e_machine
== EM_D30V
10568 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10569 && reloc_type
== 12))
10570 addend
+= byte_get (rloc
, reloc_size
);
10572 if (is_32bit_pcrel_reloc (reloc_type
)
10573 || is_64bit_pcrel_reloc (reloc_type
))
10575 /* On HPPA, all pc-relative relocations are biased by 8. */
10576 if (elf_header
.e_machine
== EM_PARISC
)
10578 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10582 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10591 #ifdef SUPPORT_DISASSEMBLY
10593 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10595 printf (_("\nAssembly dump of section %s\n"),
10596 SECTION_NAME (section
));
10598 /* XXX -- to be done --- XXX */
10604 /* Reads in the contents of SECTION from FILE, returning a pointer
10605 to a malloc'ed buffer or NULL if something went wrong. */
10608 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10610 bfd_size_type num_bytes
;
10612 num_bytes
= section
->sh_size
;
10614 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10616 printf (_("\nSection '%s' has no data to dump.\n"),
10617 SECTION_NAME (section
));
10621 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10622 _("section contents"));
10627 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10629 Elf_Internal_Shdr
* relsec
;
10630 bfd_size_type num_bytes
;
10634 char * name
= SECTION_NAME (section
);
10635 bfd_boolean some_strings_shown
;
10637 start
= get_section_contents (section
, file
);
10641 printf (_("\nString dump of section '%s':\n"), name
);
10643 /* If the section being dumped has relocations against it the user might
10644 be expecting these relocations to have been applied. Check for this
10645 case and issue a warning message in order to avoid confusion.
10646 FIXME: Maybe we ought to have an option that dumps a section with
10647 relocs applied ? */
10648 for (relsec
= section_headers
;
10649 relsec
< section_headers
+ elf_header
.e_shnum
;
10652 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10653 || relsec
->sh_info
>= elf_header
.e_shnum
10654 || section_headers
+ relsec
->sh_info
!= section
10655 || relsec
->sh_size
== 0
10656 || relsec
->sh_link
>= elf_header
.e_shnum
)
10659 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10663 num_bytes
= section
->sh_size
;
10665 end
= start
+ num_bytes
;
10666 some_strings_shown
= FALSE
;
10670 while (!ISPRINT (* data
))
10671 if (++ data
>= end
)
10677 /* PR 11128: Use two separate invocations in order to work
10678 around bugs in the Solaris 8 implementation of printf. */
10679 printf (" [%6tx] ", data
- start
);
10680 printf ("%s\n", data
);
10682 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10684 data
+= strlen (data
);
10685 some_strings_shown
= TRUE
;
10689 if (! some_strings_shown
)
10690 printf (_(" No strings found in this section."));
10698 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10700 bfd_boolean relocate
)
10702 Elf_Internal_Shdr
* relsec
;
10703 bfd_size_type bytes
;
10705 unsigned char * data
;
10706 unsigned char * start
;
10708 start
= (unsigned char *) get_section_contents (section
, file
);
10712 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10716 apply_relocations (file
, section
, start
);
10720 /* If the section being dumped has relocations against it the user might
10721 be expecting these relocations to have been applied. Check for this
10722 case and issue a warning message in order to avoid confusion.
10723 FIXME: Maybe we ought to have an option that dumps a section with
10724 relocs applied ? */
10725 for (relsec
= section_headers
;
10726 relsec
< section_headers
+ elf_header
.e_shnum
;
10729 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10730 || relsec
->sh_info
>= elf_header
.e_shnum
10731 || section_headers
+ relsec
->sh_info
!= section
10732 || relsec
->sh_size
== 0
10733 || relsec
->sh_link
>= elf_header
.e_shnum
)
10736 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10741 addr
= section
->sh_addr
;
10742 bytes
= section
->sh_size
;
10751 lbytes
= (bytes
> 16 ? 16 : bytes
);
10753 printf (" 0x%8.8lx ", (unsigned long) addr
);
10755 for (j
= 0; j
< 16; j
++)
10758 printf ("%2.2x", data
[j
]);
10766 for (j
= 0; j
< lbytes
; j
++)
10769 if (k
>= ' ' && k
< 0x7f)
10787 /* Uncompresses a section that was compressed using zlib, in place. */
10790 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10791 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10793 #ifndef HAVE_ZLIB_H
10796 dwarf_size_type compressed_size
= *size
;
10797 unsigned char * compressed_buffer
= *buffer
;
10798 dwarf_size_type uncompressed_size
;
10799 unsigned char * uncompressed_buffer
;
10802 dwarf_size_type header_size
= 12;
10804 /* Read the zlib header. In this case, it should be "ZLIB" followed
10805 by the uncompressed section size, 8 bytes in big-endian order. */
10806 if (compressed_size
< header_size
10807 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10810 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10811 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10812 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10813 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10814 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10815 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10816 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10817 uncompressed_size
+= compressed_buffer
[11];
10819 /* It is possible the section consists of several compressed
10820 buffers concatenated together, so we uncompress in a loop. */
10821 strm
.zalloc
= NULL
;
10823 strm
.opaque
= NULL
;
10824 strm
.avail_in
= compressed_size
- header_size
;
10825 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10826 strm
.avail_out
= uncompressed_size
;
10827 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10829 rc
= inflateInit (& strm
);
10830 while (strm
.avail_in
> 0)
10834 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10835 + (uncompressed_size
- strm
.avail_out
));
10836 rc
= inflate (&strm
, Z_FINISH
);
10837 if (rc
!= Z_STREAM_END
)
10839 rc
= inflateReset (& strm
);
10841 rc
= inflateEnd (& strm
);
10843 || strm
.avail_out
!= 0)
10846 free (compressed_buffer
);
10847 *buffer
= uncompressed_buffer
;
10848 *size
= uncompressed_size
;
10852 free (uncompressed_buffer
);
10853 /* Indicate decompression failure. */
10856 #endif /* HAVE_ZLIB_H */
10860 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10861 Elf_Internal_Shdr
* sec
, void * file
)
10863 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10866 /* If it is already loaded, do nothing. */
10867 if (section
->start
!= NULL
)
10870 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10871 section
->address
= sec
->sh_addr
;
10872 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10874 sec
->sh_size
, buf
);
10875 if (section
->start
== NULL
)
10879 section
->size
= sec
->sh_size
;
10880 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10881 sec
->sh_size
= section
->size
;
10884 if (section
->start
== NULL
)
10887 if (debug_displays
[debug
].relocate
)
10888 apply_relocations ((FILE *) file
, sec
, section
->start
);
10893 /* If this is not NULL, load_debug_section will only look for sections
10894 within the list of sections given here. */
10895 unsigned int *section_subset
= NULL
;
10898 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10900 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10901 Elf_Internal_Shdr
* sec
;
10903 /* Locate the debug section. */
10904 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10906 section
->name
= section
->uncompressed_name
;
10909 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10911 section
->name
= section
->compressed_name
;
10916 /* If we're loading from a subset of sections, and we've loaded
10917 a section matching this name before, it's likely that it's a
10919 if (section_subset
!= NULL
)
10920 free_debug_section (debug
);
10922 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10926 free_debug_section (enum dwarf_section_display_enum debug
)
10928 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10930 if (section
->start
== NULL
)
10933 free ((char *) section
->start
);
10934 section
->start
= NULL
;
10935 section
->address
= 0;
10940 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10942 char * name
= SECTION_NAME (section
);
10943 bfd_size_type length
;
10947 length
= section
->sh_size
;
10950 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10953 if (section
->sh_type
== SHT_NOBITS
)
10955 /* There is no point in dumping the contents of a debugging section
10956 which has the NOBITS type - the bits in the file will be random.
10957 This can happen when a file containing a .eh_frame section is
10958 stripped with the --only-keep-debug command line option. */
10959 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10963 if (const_strneq (name
, ".gnu.linkonce.wi."))
10964 name
= ".debug_info";
10966 /* See if we know how to display the contents of this section. */
10967 for (i
= 0; i
< max
; i
++)
10968 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10969 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10971 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10972 int secondary
= (section
!= find_section (name
));
10975 free_debug_section ((enum dwarf_section_display_enum
) i
);
10977 if (streq (sec
->uncompressed_name
, name
))
10978 sec
->name
= sec
->uncompressed_name
;
10980 sec
->name
= sec
->compressed_name
;
10981 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10984 /* If this debug section is part of a CU/TU set in a .dwp file,
10985 restrict load_debug_section to the sections in that set. */
10986 section_subset
= find_cu_tu_set (file
, shndx
);
10988 result
&= debug_displays
[i
].display (sec
, file
);
10990 section_subset
= NULL
;
10992 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10993 free_debug_section ((enum dwarf_section_display_enum
) i
);
11001 printf (_("Unrecognized debug section: %s\n"), name
);
11008 /* Set DUMP_SECTS for all sections where dumps were requested
11009 based on section name. */
11012 initialise_dumps_byname (void)
11014 struct dump_list_entry
* cur
;
11016 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11021 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11022 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11024 request_dump_bynumber (i
, cur
->type
);
11029 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11035 process_section_contents (FILE * file
)
11037 Elf_Internal_Shdr
* section
;
11043 initialise_dumps_byname ();
11045 for (i
= 0, section
= section_headers
;
11046 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11049 #ifdef SUPPORT_DISASSEMBLY
11050 if (dump_sects
[i
] & DISASS_DUMP
)
11051 disassemble_section (section
, file
);
11053 if (dump_sects
[i
] & HEX_DUMP
)
11054 dump_section_as_bytes (section
, file
, FALSE
);
11056 if (dump_sects
[i
] & RELOC_DUMP
)
11057 dump_section_as_bytes (section
, file
, TRUE
);
11059 if (dump_sects
[i
] & STRING_DUMP
)
11060 dump_section_as_strings (section
, file
);
11062 if (dump_sects
[i
] & DEBUG_DUMP
)
11063 display_debug_section (i
, section
, file
);
11066 /* Check to see if the user requested a
11067 dump of a section that does not exist. */
11068 while (i
++ < num_dump_sects
)
11070 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11074 process_mips_fpe_exception (int mask
)
11079 if (mask
& OEX_FPU_INEX
)
11080 fputs ("INEX", stdout
), first
= 0;
11081 if (mask
& OEX_FPU_UFLO
)
11082 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11083 if (mask
& OEX_FPU_OFLO
)
11084 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11085 if (mask
& OEX_FPU_DIV0
)
11086 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11087 if (mask
& OEX_FPU_INVAL
)
11088 printf ("%sINVAL", first
? "" : "|");
11091 fputs ("0", stdout
);
11094 /* ARM EABI attributes section. */
11099 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11101 const char ** table
;
11102 } arm_attr_public_tag
;
11104 static const char * arm_attr_tag_CPU_arch
[] =
11105 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11106 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11107 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11108 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11109 {"No", "Thumb-1", "Thumb-2"};
11110 static const char * arm_attr_tag_FP_arch
[] =
11111 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11113 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11114 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11115 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11116 static const char * arm_attr_tag_PCS_config
[] =
11117 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11118 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11119 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11120 {"V6", "SB", "TLS", "Unused"};
11121 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11122 {"Absolute", "PC-relative", "SB-relative", "None"};
11123 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11124 {"Absolute", "PC-relative", "None"};
11125 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11126 {"None", "direct", "GOT-indirect"};
11127 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11128 {"None", "??? 1", "2", "??? 3", "4"};
11129 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11130 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11131 {"Unused", "Needed", "Sign only"};
11132 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11133 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11134 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11135 {"Unused", "Finite", "RTABI", "IEEE 754"};
11136 static const char * arm_attr_tag_ABI_enum_size
[] =
11137 {"Unused", "small", "int", "forced to int"};
11138 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11139 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11140 static const char * arm_attr_tag_ABI_VFP_args
[] =
11141 {"AAPCS", "VFP registers", "custom"};
11142 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11143 {"AAPCS", "WMMX registers", "custom"};
11144 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11145 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11146 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11147 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11148 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11149 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11150 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11151 static const char * arm_attr_tag_FP_HP_extension
[] =
11152 {"Not Allowed", "Allowed"};
11153 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11154 {"None", "IEEE 754", "Alternative Format"};
11155 static const char * arm_attr_tag_MPextension_use
[] =
11156 {"Not Allowed", "Allowed"};
11157 static const char * arm_attr_tag_DIV_use
[] =
11158 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11159 "Allowed in v7-A with integer division extension"};
11160 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11161 static const char * arm_attr_tag_Virtualization_use
[] =
11162 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11163 "TrustZone and Virtualization Extensions"};
11164 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11165 {"Not Allowed", "Allowed"};
11167 #define LOOKUP(id, name) \
11168 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11169 static arm_attr_public_tag arm_attr_public_tags
[] =
11171 {4, "CPU_raw_name", 1, NULL
},
11172 {5, "CPU_name", 1, NULL
},
11173 LOOKUP(6, CPU_arch
),
11174 {7, "CPU_arch_profile", 0, NULL
},
11175 LOOKUP(8, ARM_ISA_use
),
11176 LOOKUP(9, THUMB_ISA_use
),
11177 LOOKUP(10, FP_arch
),
11178 LOOKUP(11, WMMX_arch
),
11179 LOOKUP(12, Advanced_SIMD_arch
),
11180 LOOKUP(13, PCS_config
),
11181 LOOKUP(14, ABI_PCS_R9_use
),
11182 LOOKUP(15, ABI_PCS_RW_data
),
11183 LOOKUP(16, ABI_PCS_RO_data
),
11184 LOOKUP(17, ABI_PCS_GOT_use
),
11185 LOOKUP(18, ABI_PCS_wchar_t
),
11186 LOOKUP(19, ABI_FP_rounding
),
11187 LOOKUP(20, ABI_FP_denormal
),
11188 LOOKUP(21, ABI_FP_exceptions
),
11189 LOOKUP(22, ABI_FP_user_exceptions
),
11190 LOOKUP(23, ABI_FP_number_model
),
11191 {24, "ABI_align_needed", 0, NULL
},
11192 {25, "ABI_align_preserved", 0, NULL
},
11193 LOOKUP(26, ABI_enum_size
),
11194 LOOKUP(27, ABI_HardFP_use
),
11195 LOOKUP(28, ABI_VFP_args
),
11196 LOOKUP(29, ABI_WMMX_args
),
11197 LOOKUP(30, ABI_optimization_goals
),
11198 LOOKUP(31, ABI_FP_optimization_goals
),
11199 {32, "compatibility", 0, NULL
},
11200 LOOKUP(34, CPU_unaligned_access
),
11201 LOOKUP(36, FP_HP_extension
),
11202 LOOKUP(38, ABI_FP_16bit_format
),
11203 LOOKUP(42, MPextension_use
),
11204 LOOKUP(44, DIV_use
),
11205 {64, "nodefaults", 0, NULL
},
11206 {65, "also_compatible_with", 0, NULL
},
11207 LOOKUP(66, T2EE_use
),
11208 {67, "conformance", 1, NULL
},
11209 LOOKUP(68, Virtualization_use
),
11210 LOOKUP(70, MPextension_use_legacy
)
11214 static unsigned char *
11215 display_arm_attribute (unsigned char * p
)
11220 arm_attr_public_tag
* attr
;
11224 tag
= read_uleb128 (p
, &len
);
11227 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11229 if (arm_attr_public_tags
[i
].tag
== tag
)
11231 attr
= &arm_attr_public_tags
[i
];
11238 printf (" Tag_%s: ", attr
->name
);
11239 switch (attr
->type
)
11244 case 7: /* Tag_CPU_arch_profile. */
11245 val
= read_uleb128 (p
, &len
);
11249 case 0: printf (_("None\n")); break;
11250 case 'A': printf (_("Application\n")); break;
11251 case 'R': printf (_("Realtime\n")); break;
11252 case 'M': printf (_("Microcontroller\n")); break;
11253 case 'S': printf (_("Application or Realtime\n")); break;
11254 default: printf ("??? (%d)\n", val
); break;
11258 case 24: /* Tag_align_needed. */
11259 val
= read_uleb128 (p
, &len
);
11263 case 0: printf (_("None\n")); break;
11264 case 1: printf (_("8-byte\n")); break;
11265 case 2: printf (_("4-byte\n")); break;
11266 case 3: printf ("??? 3\n"); break;
11269 printf (_("8-byte and up to %d-byte extended\n"),
11272 printf ("??? (%d)\n", val
);
11277 case 25: /* Tag_align_preserved. */
11278 val
= read_uleb128 (p
, &len
);
11282 case 0: printf (_("None\n")); break;
11283 case 1: printf (_("8-byte, except leaf SP\n")); break;
11284 case 2: printf (_("8-byte\n")); break;
11285 case 3: printf ("??? 3\n"); break;
11288 printf (_("8-byte and up to %d-byte extended\n"),
11291 printf ("??? (%d)\n", val
);
11296 case 32: /* Tag_compatibility. */
11297 val
= read_uleb128 (p
, &len
);
11299 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11300 p
+= strlen ((char *) p
) + 1;
11303 case 64: /* Tag_nodefaults. */
11305 printf (_("True\n"));
11308 case 65: /* Tag_also_compatible_with. */
11309 val
= read_uleb128 (p
, &len
);
11311 if (val
== 6 /* Tag_CPU_arch. */)
11313 val
= read_uleb128 (p
, &len
);
11315 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11316 printf ("??? (%d)\n", val
);
11318 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11322 while (*(p
++) != '\0' /* NUL terminator. */);
11336 assert (attr
->type
& 0x80);
11337 val
= read_uleb128 (p
, &len
);
11339 type
= attr
->type
& 0x7f;
11341 printf ("??? (%d)\n", val
);
11343 printf ("%s\n", attr
->table
[val
]);
11350 type
= 1; /* String. */
11352 type
= 2; /* uleb128. */
11353 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
);
11371 static unsigned char *
11372 display_gnu_attribute (unsigned char * p
,
11373 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11380 tag
= read_uleb128 (p
, &len
);
11383 /* Tag_compatibility is the only generic GNU attribute defined at
11387 val
= read_uleb128 (p
, &len
);
11389 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11390 p
+= strlen ((char *) p
) + 1;
11394 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11395 return display_proc_gnu_attribute (p
, tag
);
11398 type
= 1; /* String. */
11400 type
= 2; /* uleb128. */
11401 printf (" Tag_unknown_%d: ", tag
);
11405 printf ("\"%s\"\n", p
);
11406 p
+= strlen ((char *) p
) + 1;
11410 val
= read_uleb128 (p
, &len
);
11412 printf ("%d (0x%x)\n", val
, val
);
11418 static unsigned char *
11419 display_power_gnu_attribute (unsigned char * p
, int tag
)
11425 if (tag
== Tag_GNU_Power_ABI_FP
)
11427 val
= read_uleb128 (p
, &len
);
11429 printf (" Tag_GNU_Power_ABI_FP: ");
11434 printf (_("Hard or soft float\n"));
11437 printf (_("Hard float\n"));
11440 printf (_("Soft float\n"));
11443 printf (_("Single-precision hard float\n"));
11446 printf ("??? (%d)\n", val
);
11452 if (tag
== Tag_GNU_Power_ABI_Vector
)
11454 val
= read_uleb128 (p
, &len
);
11456 printf (" Tag_GNU_Power_ABI_Vector: ");
11460 printf (_("Any\n"));
11463 printf (_("Generic\n"));
11466 printf ("AltiVec\n");
11472 printf ("??? (%d)\n", val
);
11478 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11480 val
= read_uleb128 (p
, &len
);
11482 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11486 printf (_("Any\n"));
11489 printf ("r3/r4\n");
11492 printf (_("Memory\n"));
11495 printf ("??? (%d)\n", val
);
11502 type
= 1; /* String. */
11504 type
= 2; /* uleb128. */
11505 printf (" Tag_unknown_%d: ", tag
);
11509 printf ("\"%s\"\n", p
);
11510 p
+= strlen ((char *) p
) + 1;
11514 val
= read_uleb128 (p
, &len
);
11516 printf ("%d (0x%x)\n", val
, val
);
11523 display_sparc_hwcaps (int mask
)
11528 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11529 fputs ("mul32", stdout
), first
= 0;
11530 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11531 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11532 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11533 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11534 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11535 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11536 if (mask
& ELF_SPARC_HWCAP_POPC
)
11537 printf ("%spopc", first
? "" : "|"), first
= 0;
11538 if (mask
& ELF_SPARC_HWCAP_VIS
)
11539 printf ("%svis", first
? "" : "|"), first
= 0;
11540 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11541 printf ("%svis2", first
? "" : "|"), first
= 0;
11542 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11543 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11544 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11545 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11546 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11547 printf ("%svis3", first
? "" : "|"), first
= 0;
11548 if (mask
& ELF_SPARC_HWCAP_HPC
)
11549 printf ("%shpc", first
? "" : "|"), first
= 0;
11550 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11551 printf ("%srandom", first
? "" : "|"), first
= 0;
11552 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11553 printf ("%strans", first
? "" : "|"), first
= 0;
11554 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11555 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11556 if (mask
& ELF_SPARC_HWCAP_IMA
)
11557 printf ("%sima", first
? "" : "|"), first
= 0;
11558 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11559 printf ("%scspare", first
? "" : "|"), first
= 0;
11562 fputc('0', stdout
);
11563 fputc('\n', stdout
);
11566 static unsigned char *
11567 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11573 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11575 val
= read_uleb128 (p
, &len
);
11577 printf (" Tag_GNU_Sparc_HWCAPS: ");
11579 display_sparc_hwcaps (val
);
11584 type
= 1; /* String. */
11586 type
= 2; /* uleb128. */
11587 printf (" Tag_unknown_%d: ", tag
);
11591 printf ("\"%s\"\n", p
);
11592 p
+= strlen ((char *) p
) + 1;
11596 val
= read_uleb128 (p
, &len
);
11598 printf ("%d (0x%x)\n", val
, val
);
11604 static unsigned char *
11605 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11611 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11613 val
= read_uleb128 (p
, &len
);
11615 printf (" Tag_GNU_MIPS_ABI_FP: ");
11620 printf (_("Hard or soft float\n"));
11623 printf (_("Hard float (double precision)\n"));
11626 printf (_("Hard float (single precision)\n"));
11629 printf (_("Soft float\n"));
11632 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11635 printf ("??? (%d)\n", val
);
11642 type
= 1; /* String. */
11644 type
= 2; /* uleb128. */
11645 printf (" Tag_unknown_%d: ", tag
);
11649 printf ("\"%s\"\n", p
);
11650 p
+= strlen ((char *) p
) + 1;
11654 val
= read_uleb128 (p
, &len
);
11656 printf ("%d (0x%x)\n", val
, val
);
11662 static unsigned char *
11663 display_tic6x_attribute (unsigned char * p
)
11669 tag
= read_uleb128 (p
, &len
);
11675 val
= read_uleb128 (p
, &len
);
11677 printf (" Tag_ISA: ");
11681 case C6XABI_Tag_ISA_none
:
11682 printf (_("None\n"));
11684 case C6XABI_Tag_ISA_C62X
:
11687 case C6XABI_Tag_ISA_C67X
:
11690 case C6XABI_Tag_ISA_C67XP
:
11691 printf ("C67x+\n");
11693 case C6XABI_Tag_ISA_C64X
:
11696 case C6XABI_Tag_ISA_C64XP
:
11697 printf ("C64x+\n");
11699 case C6XABI_Tag_ISA_C674X
:
11700 printf ("C674x\n");
11703 printf ("??? (%d)\n", val
);
11708 case Tag_ABI_wchar_t
:
11709 val
= read_uleb128 (p
, &len
);
11711 printf (" Tag_ABI_wchar_t: ");
11715 printf (_("Not used\n"));
11718 printf (_("2 bytes\n"));
11721 printf (_("4 bytes\n"));
11724 printf ("??? (%d)\n", val
);
11729 case Tag_ABI_stack_align_needed
:
11730 val
= read_uleb128 (p
, &len
);
11732 printf (" Tag_ABI_stack_align_needed: ");
11736 printf (_("8-byte\n"));
11739 printf (_("16-byte\n"));
11742 printf ("??? (%d)\n", val
);
11747 case Tag_ABI_stack_align_preserved
:
11748 val
= read_uleb128 (p
, &len
);
11750 printf (" Tag_ABI_stack_align_preserved: ");
11754 printf (_("8-byte\n"));
11757 printf (_("16-byte\n"));
11760 printf ("??? (%d)\n", val
);
11766 val
= read_uleb128 (p
, &len
);
11768 printf (" Tag_ABI_DSBT: ");
11772 printf (_("DSBT addressing not used\n"));
11775 printf (_("DSBT addressing used\n"));
11778 printf ("??? (%d)\n", val
);
11784 val
= read_uleb128 (p
, &len
);
11786 printf (" Tag_ABI_PID: ");
11790 printf (_("Data addressing position-dependent\n"));
11793 printf (_("Data addressing position-independent, GOT near DP\n"));
11796 printf (_("Data addressing position-independent, GOT far from DP\n"));
11799 printf ("??? (%d)\n", val
);
11805 val
= read_uleb128 (p
, &len
);
11807 printf (" Tag_ABI_PIC: ");
11811 printf (_("Code addressing position-dependent\n"));
11814 printf (_("Code addressing position-independent\n"));
11817 printf ("??? (%d)\n", val
);
11822 case Tag_ABI_array_object_alignment
:
11823 val
= read_uleb128 (p
, &len
);
11825 printf (" Tag_ABI_array_object_alignment: ");
11829 printf (_("8-byte\n"));
11832 printf (_("4-byte\n"));
11835 printf (_("16-byte\n"));
11838 printf ("??? (%d)\n", val
);
11843 case Tag_ABI_array_object_align_expected
:
11844 val
= read_uleb128 (p
, &len
);
11846 printf (" Tag_ABI_array_object_align_expected: ");
11850 printf (_("8-byte\n"));
11853 printf (_("4-byte\n"));
11856 printf (_("16-byte\n"));
11859 printf ("??? (%d)\n", val
);
11864 case Tag_ABI_compatibility
:
11865 val
= read_uleb128 (p
, &len
);
11867 printf (" Tag_ABI_compatibility: ");
11868 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11869 p
+= strlen ((char *) p
) + 1;
11872 case Tag_ABI_conformance
:
11873 printf (" Tag_ABI_conformance: ");
11874 printf ("\"%s\"\n", p
);
11875 p
+= strlen ((char *) p
) + 1;
11879 printf (" Tag_unknown_%d: ", tag
);
11883 printf ("\"%s\"\n", p
);
11884 p
+= strlen ((char *) p
) + 1;
11888 val
= read_uleb128 (p
, &len
);
11890 printf ("%d (0x%x)\n", val
, val
);
11897 process_attributes (FILE * file
,
11898 const char * public_name
,
11899 unsigned int proc_type
,
11900 unsigned char * (* display_pub_attribute
) (unsigned char *),
11901 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11903 Elf_Internal_Shdr
* sect
;
11904 unsigned char * contents
;
11906 unsigned char * end
;
11907 bfd_vma section_len
;
11911 /* Find the section header so that we get the size. */
11912 for (i
= 0, sect
= section_headers
;
11913 i
< elf_header
.e_shnum
;
11916 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11919 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11920 sect
->sh_size
, _("attributes"));
11921 if (contents
== NULL
)
11927 len
= sect
->sh_size
- 1;
11933 bfd_boolean public_section
;
11934 bfd_boolean gnu_section
;
11936 section_len
= byte_get (p
, 4);
11939 if (section_len
> len
)
11941 printf (_("ERROR: Bad section length (%d > %d)\n"),
11942 (int) section_len
, (int) len
);
11946 len
-= section_len
;
11947 printf (_("Attribute Section: %s\n"), p
);
11949 if (public_name
&& streq ((char *) p
, public_name
))
11950 public_section
= TRUE
;
11952 public_section
= FALSE
;
11954 if (streq ((char *) p
, "gnu"))
11955 gnu_section
= TRUE
;
11957 gnu_section
= FALSE
;
11959 namelen
= strlen ((char *) p
) + 1;
11961 section_len
-= namelen
+ 4;
11963 while (section_len
> 0)
11969 size
= byte_get (p
, 4);
11970 if (size
> section_len
)
11972 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11973 (int) size
, (int) section_len
);
11974 size
= section_len
;
11977 section_len
-= size
;
11978 end
= p
+ size
- 1;
11984 printf (_("File Attributes\n"));
11987 printf (_("Section Attributes:"));
11990 printf (_("Symbol Attributes:"));
11996 val
= read_uleb128 (p
, &j
);
12000 printf (" %d", val
);
12005 printf (_("Unknown tag: %d\n"), tag
);
12006 public_section
= FALSE
;
12010 if (public_section
)
12013 p
= display_pub_attribute (p
);
12015 else if (gnu_section
)
12018 p
= display_gnu_attribute (p
,
12019 display_proc_gnu_attribute
);
12023 /* ??? Do something sensible, like dump hex. */
12024 printf (_(" Unknown section contexts\n"));
12031 printf (_("Unknown format '%c'\n"), *p
);
12039 process_arm_specific (FILE * file
)
12041 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12042 display_arm_attribute
, NULL
);
12046 process_power_specific (FILE * file
)
12048 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12049 display_power_gnu_attribute
);
12053 process_sparc_specific (FILE * file
)
12055 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12056 display_sparc_gnu_attribute
);
12060 process_tic6x_specific (FILE * file
)
12062 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12063 display_tic6x_attribute
, NULL
);
12066 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12067 Print the Address, Access and Initial fields of an entry at VMA ADDR
12068 and return the VMA of the next entry. */
12071 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12074 print_vma (addr
, LONG_HEX
);
12076 if (addr
< pltgot
+ 0xfff0)
12077 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12079 printf ("%10s", "");
12082 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12087 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12088 print_vma (entry
, LONG_HEX
);
12090 return addr
+ (is_32bit_elf
? 4 : 8);
12093 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12094 PLTGOT. Print the Address and Initial fields of an entry at VMA
12095 ADDR and return the VMA of the next entry. */
12098 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12101 print_vma (addr
, LONG_HEX
);
12104 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12109 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12110 print_vma (entry
, LONG_HEX
);
12112 return addr
+ (is_32bit_elf
? 4 : 8);
12116 process_mips_specific (FILE * file
)
12118 Elf_Internal_Dyn
* entry
;
12119 size_t liblist_offset
= 0;
12120 size_t liblistno
= 0;
12121 size_t conflictsno
= 0;
12122 size_t options_offset
= 0;
12123 size_t conflicts_offset
= 0;
12124 size_t pltrelsz
= 0;
12126 bfd_vma pltgot
= 0;
12127 bfd_vma mips_pltgot
= 0;
12128 bfd_vma jmprel
= 0;
12129 bfd_vma local_gotno
= 0;
12130 bfd_vma gotsym
= 0;
12131 bfd_vma symtabno
= 0;
12133 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12134 display_mips_gnu_attribute
);
12136 /* We have a lot of special sections. Thanks SGI! */
12137 if (dynamic_section
== NULL
)
12138 /* No information available. */
12141 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12142 switch (entry
->d_tag
)
12144 case DT_MIPS_LIBLIST
:
12146 = offset_from_vma (file
, entry
->d_un
.d_val
,
12147 liblistno
* sizeof (Elf32_External_Lib
));
12149 case DT_MIPS_LIBLISTNO
:
12150 liblistno
= entry
->d_un
.d_val
;
12152 case DT_MIPS_OPTIONS
:
12153 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12155 case DT_MIPS_CONFLICT
:
12157 = offset_from_vma (file
, entry
->d_un
.d_val
,
12158 conflictsno
* sizeof (Elf32_External_Conflict
));
12160 case DT_MIPS_CONFLICTNO
:
12161 conflictsno
= entry
->d_un
.d_val
;
12164 pltgot
= entry
->d_un
.d_ptr
;
12166 case DT_MIPS_LOCAL_GOTNO
:
12167 local_gotno
= entry
->d_un
.d_val
;
12169 case DT_MIPS_GOTSYM
:
12170 gotsym
= entry
->d_un
.d_val
;
12172 case DT_MIPS_SYMTABNO
:
12173 symtabno
= entry
->d_un
.d_val
;
12175 case DT_MIPS_PLTGOT
:
12176 mips_pltgot
= entry
->d_un
.d_ptr
;
12179 pltrel
= entry
->d_un
.d_val
;
12182 pltrelsz
= entry
->d_un
.d_val
;
12185 jmprel
= entry
->d_un
.d_ptr
;
12191 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12193 Elf32_External_Lib
* elib
;
12196 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12198 sizeof (Elf32_External_Lib
),
12199 _("liblist section data"));
12202 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12203 (unsigned long) liblistno
);
12204 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12207 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12214 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12215 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12216 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12217 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12218 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12220 tmp
= gmtime (&atime
);
12221 snprintf (timebuf
, sizeof (timebuf
),
12222 "%04u-%02u-%02uT%02u:%02u:%02u",
12223 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12224 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12226 printf ("%3lu: ", (unsigned long) cnt
);
12227 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12228 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12230 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12231 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12232 liblist
.l_version
);
12234 if (liblist
.l_flags
== 0)
12238 static const struct
12245 { " EXACT_MATCH", LL_EXACT_MATCH
},
12246 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12247 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12248 { " EXPORTS", LL_EXPORTS
},
12249 { " DELAY_LOAD", LL_DELAY_LOAD
},
12250 { " DELTA", LL_DELTA
}
12252 int flags
= liblist
.l_flags
;
12255 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12256 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12258 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12259 flags
^= l_flags_vals
[fcnt
].bit
;
12262 printf (" %#x", (unsigned int) flags
);
12272 if (options_offset
!= 0)
12274 Elf_External_Options
* eopt
;
12275 Elf_Internal_Shdr
* sect
= section_headers
;
12276 Elf_Internal_Options
* iopt
;
12277 Elf_Internal_Options
* option
;
12281 /* Find the section header so that we get the size. */
12282 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12285 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12286 sect
->sh_size
, _("options"));
12289 iopt
= (Elf_Internal_Options
*)
12290 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12293 error (_("Out of memory\n"));
12300 while (offset
< sect
->sh_size
)
12302 Elf_External_Options
* eoption
;
12304 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12306 option
->kind
= BYTE_GET (eoption
->kind
);
12307 option
->size
= BYTE_GET (eoption
->size
);
12308 option
->section
= BYTE_GET (eoption
->section
);
12309 option
->info
= BYTE_GET (eoption
->info
);
12311 offset
+= option
->size
;
12317 printf (_("\nSection '%s' contains %d entries:\n"),
12318 SECTION_NAME (sect
), cnt
);
12326 switch (option
->kind
)
12329 /* This shouldn't happen. */
12330 printf (" NULL %d %lx", option
->section
, option
->info
);
12333 printf (" REGINFO ");
12334 if (elf_header
.e_machine
== EM_MIPS
)
12337 Elf32_External_RegInfo
* ereg
;
12338 Elf32_RegInfo reginfo
;
12340 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12341 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12342 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12343 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12344 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12345 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12346 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12348 printf ("GPR %08lx GP 0x%lx\n",
12349 reginfo
.ri_gprmask
,
12350 (unsigned long) reginfo
.ri_gp_value
);
12351 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12352 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12353 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12358 Elf64_External_RegInfo
* ereg
;
12359 Elf64_Internal_RegInfo reginfo
;
12361 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12362 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12363 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12364 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12365 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12366 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12367 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12369 printf ("GPR %08lx GP 0x",
12370 reginfo
.ri_gprmask
);
12371 printf_vma (reginfo
.ri_gp_value
);
12374 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12375 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12376 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12380 case ODK_EXCEPTIONS
:
12381 fputs (" EXCEPTIONS fpe_min(", stdout
);
12382 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12383 fputs (") fpe_max(", stdout
);
12384 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12385 fputs (")", stdout
);
12387 if (option
->info
& OEX_PAGE0
)
12388 fputs (" PAGE0", stdout
);
12389 if (option
->info
& OEX_SMM
)
12390 fputs (" SMM", stdout
);
12391 if (option
->info
& OEX_FPDBUG
)
12392 fputs (" FPDBUG", stdout
);
12393 if (option
->info
& OEX_DISMISS
)
12394 fputs (" DISMISS", stdout
);
12397 fputs (" PAD ", stdout
);
12398 if (option
->info
& OPAD_PREFIX
)
12399 fputs (" PREFIX", stdout
);
12400 if (option
->info
& OPAD_POSTFIX
)
12401 fputs (" POSTFIX", stdout
);
12402 if (option
->info
& OPAD_SYMBOL
)
12403 fputs (" SYMBOL", stdout
);
12406 fputs (" HWPATCH ", stdout
);
12407 if (option
->info
& OHW_R4KEOP
)
12408 fputs (" R4KEOP", stdout
);
12409 if (option
->info
& OHW_R8KPFETCH
)
12410 fputs (" R8KPFETCH", stdout
);
12411 if (option
->info
& OHW_R5KEOP
)
12412 fputs (" R5KEOP", stdout
);
12413 if (option
->info
& OHW_R5KCVTL
)
12414 fputs (" R5KCVTL", stdout
);
12417 fputs (" FILL ", stdout
);
12418 /* XXX Print content of info word? */
12421 fputs (" TAGS ", stdout
);
12422 /* XXX Print content of info word? */
12425 fputs (" HWAND ", stdout
);
12426 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12427 fputs (" R4KEOP_CHECKED", stdout
);
12428 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12429 fputs (" R4KEOP_CLEAN", stdout
);
12432 fputs (" HWOR ", stdout
);
12433 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12434 fputs (" R4KEOP_CHECKED", stdout
);
12435 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12436 fputs (" R4KEOP_CLEAN", stdout
);
12439 printf (" GP_GROUP %#06lx self-contained %#06lx",
12440 option
->info
& OGP_GROUP
,
12441 (option
->info
& OGP_SELF
) >> 16);
12444 printf (" IDENT %#06lx self-contained %#06lx",
12445 option
->info
& OGP_GROUP
,
12446 (option
->info
& OGP_SELF
) >> 16);
12449 /* This shouldn't happen. */
12450 printf (" %3d ??? %d %lx",
12451 option
->kind
, option
->section
, option
->info
);
12455 len
= sizeof (* eopt
);
12456 while (len
< option
->size
)
12457 if (((char *) option
)[len
] >= ' '
12458 && ((char *) option
)[len
] < 0x7f)
12459 printf ("%c", ((char *) option
)[len
++]);
12461 printf ("\\%03o", ((char *) option
)[len
++]);
12463 fputs ("\n", stdout
);
12471 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12473 Elf32_Conflict
* iconf
;
12476 if (dynamic_symbols
== NULL
)
12478 error (_("conflict list found without a dynamic symbol table\n"));
12482 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12485 error (_("Out of memory\n"));
12491 Elf32_External_Conflict
* econf32
;
12493 econf32
= (Elf32_External_Conflict
*)
12494 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12495 sizeof (* econf32
), _("conflict"));
12499 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12500 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12506 Elf64_External_Conflict
* econf64
;
12508 econf64
= (Elf64_External_Conflict
*)
12509 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12510 sizeof (* econf64
), _("conflict"));
12514 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12515 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12520 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12521 (unsigned long) conflictsno
);
12522 puts (_(" Num: Index Value Name"));
12524 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12526 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12528 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12529 print_vma (psym
->st_value
, FULL_HEX
);
12531 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12532 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12534 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12541 if (pltgot
!= 0 && local_gotno
!= 0)
12543 bfd_vma ent
, local_end
, global_end
;
12545 unsigned char * data
;
12549 addr_size
= (is_32bit_elf
? 4 : 8);
12550 local_end
= pltgot
+ local_gotno
* addr_size
;
12551 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12553 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12554 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12555 global_end
- pltgot
, 1,
12556 _("Global Offset Table data"));
12560 printf (_("\nPrimary GOT:\n"));
12561 printf (_(" Canonical gp value: "));
12562 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12565 printf (_(" Reserved entries:\n"));
12566 printf (_(" %*s %10s %*s Purpose\n"),
12567 addr_size
* 2, _("Address"), _("Access"),
12568 addr_size
* 2, _("Initial"));
12569 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12570 printf (_(" Lazy resolver\n"));
12572 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12573 >> (addr_size
* 8 - 1)) != 0)
12575 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12576 printf (_(" Module pointer (GNU extension)\n"));
12580 if (ent
< local_end
)
12582 printf (_(" Local entries:\n"));
12583 printf (" %*s %10s %*s\n",
12584 addr_size
* 2, _("Address"), _("Access"),
12585 addr_size
* 2, _("Initial"));
12586 while (ent
< local_end
)
12588 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12594 if (gotsym
< symtabno
)
12598 printf (_(" Global entries:\n"));
12599 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12600 addr_size
* 2, _("Address"),
12602 addr_size
* 2, _("Initial"),
12603 addr_size
* 2, _("Sym.Val."),
12605 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12606 _("Ndx"), _("Name"));
12608 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12609 for (i
= gotsym
; i
< symtabno
; i
++)
12611 Elf_Internal_Sym
* psym
;
12613 psym
= dynamic_symbols
+ i
;
12614 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12616 print_vma (psym
->st_value
, LONG_HEX
);
12617 printf (" %-7s %3s ",
12618 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12619 get_symbol_index_type (psym
->st_shndx
));
12620 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12621 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12623 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12633 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12636 size_t offset
, rel_offset
;
12637 unsigned long count
, i
;
12638 unsigned char * data
;
12639 int addr_size
, sym_width
;
12640 Elf_Internal_Rela
* rels
;
12642 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12643 if (pltrel
== DT_RELA
)
12645 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12650 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12655 addr_size
= (is_32bit_elf
? 4 : 8);
12656 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12658 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12659 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12660 1, _("Procedure Linkage Table data"));
12664 printf ("\nPLT GOT:\n\n");
12665 printf (_(" Reserved entries:\n"));
12666 printf (_(" %*s %*s Purpose\n"),
12667 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12668 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12669 printf (_(" PLT lazy resolver\n"));
12670 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12671 printf (_(" Module pointer\n"));
12674 printf (_(" Entries:\n"));
12675 printf (" %*s %*s %*s %-7s %3s %s\n",
12676 addr_size
* 2, _("Address"),
12677 addr_size
* 2, _("Initial"),
12678 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12679 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12680 for (i
= 0; i
< count
; i
++)
12682 Elf_Internal_Sym
* psym
;
12684 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12685 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12687 print_vma (psym
->st_value
, LONG_HEX
);
12688 printf (" %-7s %3s ",
12689 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12690 get_symbol_index_type (psym
->st_shndx
));
12691 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12692 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12694 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12708 process_gnu_liblist (FILE * file
)
12710 Elf_Internal_Shdr
* section
;
12711 Elf_Internal_Shdr
* string_sec
;
12712 Elf32_External_Lib
* elib
;
12714 size_t strtab_size
;
12721 for (i
= 0, section
= section_headers
;
12722 i
< elf_header
.e_shnum
;
12725 switch (section
->sh_type
)
12727 case SHT_GNU_LIBLIST
:
12728 if (section
->sh_link
>= elf_header
.e_shnum
)
12731 elib
= (Elf32_External_Lib
*)
12732 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12733 _("liblist section data"));
12737 string_sec
= section_headers
+ section
->sh_link
;
12739 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12740 string_sec
->sh_size
,
12741 _("liblist string table"));
12743 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12749 strtab_size
= string_sec
->sh_size
;
12751 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12752 SECTION_NAME (section
),
12753 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12755 puts (_(" Library Time Stamp Checksum Version Flags"));
12757 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12765 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12766 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12767 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12768 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12769 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12771 tmp
= gmtime (&atime
);
12772 snprintf (timebuf
, sizeof (timebuf
),
12773 "%04u-%02u-%02uT%02u:%02u:%02u",
12774 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12775 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12777 printf ("%3lu: ", (unsigned long) cnt
);
12779 printf ("%-20s", liblist
.l_name
< strtab_size
12780 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12782 printf ("%-20.20s", liblist
.l_name
< strtab_size
12783 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12784 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12785 liblist
.l_version
, liblist
.l_flags
);
12796 static const char *
12797 get_note_type (unsigned e_type
)
12799 static char buff
[64];
12801 if (elf_header
.e_type
== ET_CORE
)
12805 return _("NT_AUXV (auxiliary vector)");
12807 return _("NT_PRSTATUS (prstatus structure)");
12809 return _("NT_FPREGSET (floating point registers)");
12811 return _("NT_PRPSINFO (prpsinfo structure)");
12812 case NT_TASKSTRUCT
:
12813 return _("NT_TASKSTRUCT (task structure)");
12815 return _("NT_PRXFPREG (user_xfpregs structure)");
12817 return _("NT_PPC_VMX (ppc Altivec registers)");
12819 return _("NT_PPC_VSX (ppc VSX registers)");
12821 return _("NT_386_TLS (x86 TLS information)");
12822 case NT_386_IOPERM
:
12823 return _("NT_386_IOPERM (x86 I/O permissions)");
12824 case NT_X86_XSTATE
:
12825 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12826 case NT_S390_HIGH_GPRS
:
12827 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12828 case NT_S390_TIMER
:
12829 return _("NT_S390_TIMER (s390 timer register)");
12830 case NT_S390_TODCMP
:
12831 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12832 case NT_S390_TODPREG
:
12833 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12835 return _("NT_S390_CTRS (s390 control registers)");
12836 case NT_S390_PREFIX
:
12837 return _("NT_S390_PREFIX (s390 prefix register)");
12838 case NT_S390_LAST_BREAK
:
12839 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12840 case NT_S390_SYSTEM_CALL
:
12841 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12843 return _("NT_ARM_VFP (arm VFP registers)");
12845 return _("NT_ARM_TLS (AArch TLS registers)");
12846 case NT_ARM_HW_BREAK
:
12847 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12848 case NT_ARM_HW_WATCH
:
12849 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12851 return _("NT_PSTATUS (pstatus structure)");
12853 return _("NT_FPREGS (floating point registers)");
12855 return _("NT_PSINFO (psinfo structure)");
12857 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12859 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12860 case NT_WIN32PSTATUS
:
12861 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12863 return _("NT_SIGINFO (siginfo_t data)");
12865 return _("NT_FILE (mapped files)");
12873 return _("NT_VERSION (version)");
12875 return _("NT_ARCH (architecture)");
12880 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12885 print_core_note (Elf_Internal_Note
*pnote
)
12887 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12888 bfd_vma count
, page_size
;
12889 unsigned char *descdata
, *filenames
, *descend
;
12891 if (pnote
->type
!= NT_FILE
)
12897 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12898 /* Still "successful". */
12903 if (pnote
->descsz
< 2 * addr_size
)
12905 printf (_(" Malformed note - too short for header\n"));
12909 descdata
= (unsigned char *) pnote
->descdata
;
12910 descend
= descdata
+ pnote
->descsz
;
12912 if (descdata
[pnote
->descsz
- 1] != '\0')
12914 printf (_(" Malformed note - does not end with \\0\n"));
12918 count
= byte_get (descdata
, addr_size
);
12919 descdata
+= addr_size
;
12921 page_size
= byte_get (descdata
, addr_size
);
12922 descdata
+= addr_size
;
12924 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12926 printf (_(" Malformed note - too short for supplied file count\n"));
12930 printf (_(" Page size: "));
12931 print_vma (page_size
, DEC
);
12934 printf (_(" %*s%*s%*s\n"),
12935 (int) (2 + 2 * addr_size
), _("Start"),
12936 (int) (4 + 2 * addr_size
), _("End"),
12937 (int) (4 + 2 * addr_size
), _("Page Offset"));
12938 filenames
= descdata
+ count
* 3 * addr_size
;
12939 while (--count
> 0)
12941 bfd_vma start
, end
, file_ofs
;
12943 if (filenames
== descend
)
12945 printf (_(" Malformed note - filenames end too early\n"));
12949 start
= byte_get (descdata
, addr_size
);
12950 descdata
+= addr_size
;
12951 end
= byte_get (descdata
, addr_size
);
12952 descdata
+= addr_size
;
12953 file_ofs
= byte_get (descdata
, addr_size
);
12954 descdata
+= addr_size
;
12957 print_vma (start
, FULL_HEX
);
12959 print_vma (end
, FULL_HEX
);
12961 print_vma (file_ofs
, FULL_HEX
);
12962 printf ("\n %s\n", filenames
);
12964 filenames
+= 1 + strlen ((char *) filenames
);
12970 static const char *
12971 get_gnu_elf_note_type (unsigned e_type
)
12973 static char buff
[64];
12977 case NT_GNU_ABI_TAG
:
12978 return _("NT_GNU_ABI_TAG (ABI version tag)");
12980 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12981 case NT_GNU_BUILD_ID
:
12982 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12983 case NT_GNU_GOLD_VERSION
:
12984 return _("NT_GNU_GOLD_VERSION (gold version)");
12989 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12994 print_gnu_note (Elf_Internal_Note
*pnote
)
12996 switch (pnote
->type
)
12998 case NT_GNU_BUILD_ID
:
13002 printf (_(" Build ID: "));
13003 for (i
= 0; i
< pnote
->descsz
; ++i
)
13004 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13009 case NT_GNU_ABI_TAG
:
13011 unsigned long os
, major
, minor
, subminor
;
13012 const char *osname
;
13014 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13015 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13016 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13017 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13021 case GNU_ABI_TAG_LINUX
:
13024 case GNU_ABI_TAG_HURD
:
13027 case GNU_ABI_TAG_SOLARIS
:
13028 osname
= "Solaris";
13030 case GNU_ABI_TAG_FREEBSD
:
13031 osname
= "FreeBSD";
13033 case GNU_ABI_TAG_NETBSD
:
13037 osname
= "Unknown";
13041 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13042 major
, minor
, subminor
);
13050 static const char *
13051 get_netbsd_elfcore_note_type (unsigned e_type
)
13053 static char buff
[64];
13055 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13057 /* NetBSD core "procinfo" structure. */
13058 return _("NetBSD procinfo structure");
13061 /* As of Jan 2002 there are no other machine-independent notes
13062 defined for NetBSD core files. If the note type is less
13063 than the start of the machine-dependent note types, we don't
13066 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13068 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13072 switch (elf_header
.e_machine
)
13074 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13075 and PT_GETFPREGS == mach+2. */
13080 case EM_SPARC32PLUS
:
13084 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13085 return _("PT_GETREGS (reg structure)");
13086 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13087 return _("PT_GETFPREGS (fpreg structure)");
13093 /* On all other arch's, PT_GETREGS == mach+1 and
13094 PT_GETFPREGS == mach+3. */
13098 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13099 return _("PT_GETREGS (reg structure)");
13100 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13101 return _("PT_GETFPREGS (fpreg structure)");
13107 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13108 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13112 static const char *
13113 get_stapsdt_note_type (unsigned e_type
)
13115 static char buff
[64];
13120 return _("NT_STAPSDT (SystemTap probe descriptors)");
13126 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13131 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13133 int addr_size
= is_32bit_elf
? 4 : 8;
13134 char *data
= pnote
->descdata
;
13135 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13136 bfd_vma pc
, base_addr
, semaphore
;
13137 char *provider
, *probe
, *arg_fmt
;
13139 pc
= byte_get ((unsigned char *) data
, addr_size
);
13141 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13143 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13147 data
+= strlen (data
) + 1;
13149 data
+= strlen (data
) + 1;
13151 data
+= strlen (data
) + 1;
13153 printf (_(" Provider: %s\n"), provider
);
13154 printf (_(" Name: %s\n"), probe
);
13155 printf (_(" Location: "));
13156 print_vma (pc
, FULL_HEX
);
13157 printf (_(", Base: "));
13158 print_vma (base_addr
, FULL_HEX
);
13159 printf (_(", Semaphore: "));
13160 print_vma (semaphore
, FULL_HEX
);
13162 printf (_(" Arguments: %s\n"), arg_fmt
);
13164 return data
== data_end
;
13167 static const char *
13168 get_ia64_vms_note_type (unsigned e_type
)
13170 static char buff
[64];
13175 return _("NT_VMS_MHD (module header)");
13177 return _("NT_VMS_LNM (language name)");
13179 return _("NT_VMS_SRC (source files)");
13181 return "NT_VMS_TITLE";
13183 return _("NT_VMS_EIDC (consistency check)");
13184 case NT_VMS_FPMODE
:
13185 return _("NT_VMS_FPMODE (FP mode)");
13186 case NT_VMS_LINKTIME
:
13187 return "NT_VMS_LINKTIME";
13188 case NT_VMS_IMGNAM
:
13189 return _("NT_VMS_IMGNAM (image name)");
13191 return _("NT_VMS_IMGID (image id)");
13192 case NT_VMS_LINKID
:
13193 return _("NT_VMS_LINKID (link id)");
13194 case NT_VMS_IMGBID
:
13195 return _("NT_VMS_IMGBID (build id)");
13196 case NT_VMS_GSTNAM
:
13197 return _("NT_VMS_GSTNAM (sym table name)");
13198 case NT_VMS_ORIG_DYN
:
13199 return "NT_VMS_ORIG_DYN";
13200 case NT_VMS_PATCHTIME
:
13201 return "NT_VMS_PATCHTIME";
13203 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13209 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13211 switch (pnote
->type
)
13214 if (pnote
->descsz
> 36)
13216 size_t l
= strlen (pnote
->descdata
+ 34);
13217 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13218 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13219 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13220 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13223 printf (_(" Invalid size\n"));
13226 printf (_(" Language: %s\n"), pnote
->descdata
);
13229 case NT_VMS_FPMODE
:
13230 printf (_(" Floating Point mode: "));
13231 printf ("0x%016" BFD_VMA_FMT
"x\n",
13232 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13234 case NT_VMS_LINKTIME
:
13235 printf (_(" Link time: "));
13237 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13240 case NT_VMS_PATCHTIME
:
13241 printf (_(" Patch time: "));
13243 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13246 case NT_VMS_ORIG_DYN
:
13247 printf (_(" Major id: %u, minor id: %u\n"),
13248 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13249 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13250 printf (_(" Last modified : "));
13252 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13253 printf (_("\n Link flags : "));
13254 printf ("0x%016" BFD_VMA_FMT
"x\n",
13255 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13256 printf (_(" Header flags: 0x%08x\n"),
13257 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13258 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13261 case NT_VMS_IMGNAM
:
13262 printf (_(" Image name: %s\n"), pnote
->descdata
);
13264 case NT_VMS_GSTNAM
:
13265 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13268 printf (_(" Image id: %s\n"), pnote
->descdata
);
13270 case NT_VMS_LINKID
:
13271 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13279 /* Note that by the ELF standard, the name field is already null byte
13280 terminated, and namesz includes the terminating null byte.
13281 I.E. the value of namesz for the name "FSF" is 4.
13283 If the value of namesz is zero, there is no name present. */
13285 process_note (Elf_Internal_Note
* pnote
)
13287 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13290 if (pnote
->namesz
== 0)
13291 /* If there is no note name, then use the default set of
13292 note type strings. */
13293 nt
= get_note_type (pnote
->type
);
13295 else if (const_strneq (pnote
->namedata
, "GNU"))
13296 /* GNU-specific object file notes. */
13297 nt
= get_gnu_elf_note_type (pnote
->type
);
13299 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13300 /* NetBSD-specific core file notes. */
13301 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13303 else if (strneq (pnote
->namedata
, "SPU/", 4))
13305 /* SPU-specific core file notes. */
13306 nt
= pnote
->namedata
+ 4;
13310 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13311 /* VMS/ia64-specific file notes. */
13312 nt
= get_ia64_vms_note_type (pnote
->type
);
13314 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13315 nt
= get_stapsdt_note_type (pnote
->type
);
13318 /* Don't recognize this note name; just use the default set of
13319 note type strings. */
13320 nt
= get_note_type (pnote
->type
);
13322 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13324 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13325 return print_ia64_vms_note (pnote
);
13326 else if (const_strneq (pnote
->namedata
, "GNU"))
13327 return print_gnu_note (pnote
);
13328 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13329 return print_stapsdt_note (pnote
);
13330 else if (const_strneq (pnote
->namedata
, "CORE"))
13331 return print_core_note (pnote
);
13338 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13340 Elf_External_Note
* pnotes
;
13341 Elf_External_Note
* external
;
13343 bfd_signed_vma data_remaining
;
13348 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13350 if (pnotes
== NULL
)
13355 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13356 (unsigned long) offset
, (unsigned long) length
);
13357 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13359 data_remaining
= length
;
13360 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13362 Elf_External_Note
* next
;
13363 Elf_Internal_Note inote
;
13364 char * temp
= NULL
;
13366 if (!is_ia64_vms ())
13368 /* PR binutils/15191
13369 Make sure that there is enough data to read. */
13370 if (data_remaining
< sizeof * next
)
13372 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13373 (int) data_remaining
);
13376 inote
.type
= BYTE_GET (external
->type
);
13377 inote
.namesz
= BYTE_GET (external
->namesz
);
13378 inote
.namedata
= external
->name
;
13379 inote
.descsz
= BYTE_GET (external
->descsz
);
13380 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13381 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13383 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13387 Elf64_External_VMS_Note
*vms_external
;
13389 /* PR binutils/15191
13390 Make sure that there is enough data to read. */
13391 if (data_remaining
< sizeof * vms_external
)
13393 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13394 (int) data_remaining
);
13398 vms_external
= (Elf64_External_VMS_Note
*) external
;
13399 inote
.type
= BYTE_GET (vms_external
->type
);
13400 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13401 inote
.namedata
= vms_external
->name
;
13402 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13403 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13404 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13406 next
= (Elf_External_Note
*)
13407 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13410 data_remaining
-= ((char *) next
- (char *) external
);
13411 if (data_remaining
< 0)
13413 warn (_("note with invalid namesz &/or descsz found at offset 0x%lx\n"),
13414 (unsigned long) ((char *) external
- (char *) pnotes
));
13415 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13416 inote
.type
, inote
.namesz
, inote
.descsz
);
13422 /* Prevent out-of-bounds indexing. */
13423 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13424 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13426 warn (_("note with invalid namesz found at offset 0x%lx\n"),
13427 (unsigned long) ((char *) external
- (char *) pnotes
));
13428 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13429 inote
.type
, inote
.namesz
, inote
.descsz
);
13433 /* Verify that name is null terminated. It appears that at least
13434 one version of Linux (RedHat 6.0) generates corefiles that don't
13435 comply with the ELF spec by failing to include the null byte in
13437 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13439 temp
= (char *) malloc (inote
.namesz
+ 1);
13443 error (_("Out of memory\n"));
13448 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13449 temp
[inote
.namesz
] = 0;
13451 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13452 inote
.namedata
= temp
;
13455 res
&= process_note (& inote
);
13470 process_corefile_note_segments (FILE * file
)
13472 Elf_Internal_Phdr
* segment
;
13476 if (! get_program_headers (file
))
13479 for (i
= 0, segment
= program_headers
;
13480 i
< elf_header
.e_phnum
;
13483 if (segment
->p_type
== PT_NOTE
)
13484 res
&= process_corefile_note_segment (file
,
13485 (bfd_vma
) segment
->p_offset
,
13486 (bfd_vma
) segment
->p_filesz
);
13493 process_note_sections (FILE * file
)
13495 Elf_Internal_Shdr
* section
;
13499 for (i
= 0, section
= section_headers
;
13500 i
< elf_header
.e_shnum
&& section
!= NULL
;
13502 if (section
->sh_type
== SHT_NOTE
)
13503 res
&= process_corefile_note_segment (file
,
13504 (bfd_vma
) section
->sh_offset
,
13505 (bfd_vma
) section
->sh_size
);
13511 process_notes (FILE * file
)
13513 /* If we have not been asked to display the notes then do nothing. */
13517 if (elf_header
.e_type
!= ET_CORE
)
13518 return process_note_sections (file
);
13520 /* No program headers means no NOTE segment. */
13521 if (elf_header
.e_phnum
> 0)
13522 return process_corefile_note_segments (file
);
13524 printf (_("No note segments present in the core file.\n"));
13529 process_arch_specific (FILE * file
)
13534 switch (elf_header
.e_machine
)
13537 return process_arm_specific (file
);
13539 case EM_MIPS_RS3_LE
:
13540 return process_mips_specific (file
);
13543 return process_power_specific (file
);
13546 case EM_SPARC32PLUS
:
13548 return process_sparc_specific (file
);
13551 return process_tic6x_specific (file
);
13560 get_file_header (FILE * file
)
13562 /* Read in the identity array. */
13563 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13566 /* Determine how to read the rest of the header. */
13567 switch (elf_header
.e_ident
[EI_DATA
])
13569 default: /* fall through */
13570 case ELFDATANONE
: /* fall through */
13572 byte_get
= byte_get_little_endian
;
13573 byte_put
= byte_put_little_endian
;
13576 byte_get
= byte_get_big_endian
;
13577 byte_put
= byte_put_big_endian
;
13581 /* For now we only support 32 bit and 64 bit ELF files. */
13582 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13584 /* Read in the rest of the header. */
13587 Elf32_External_Ehdr ehdr32
;
13589 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13592 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13593 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13594 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13595 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13596 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13597 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13598 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13599 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13600 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13601 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13602 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13603 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13604 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13608 Elf64_External_Ehdr ehdr64
;
13610 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13611 we will not be able to cope with the 64bit data found in
13612 64 ELF files. Detect this now and abort before we start
13613 overwriting things. */
13614 if (sizeof (bfd_vma
) < 8)
13616 error (_("This instance of readelf has been built without support for a\n\
13617 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13621 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13624 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13625 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13626 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13627 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13628 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13629 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13630 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13631 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13632 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13633 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13634 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13635 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13636 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13639 if (elf_header
.e_shoff
)
13641 /* There may be some extensions in the first section header. Don't
13642 bomb if we can't read it. */
13644 get_32bit_section_headers (file
, 1);
13646 get_64bit_section_headers (file
, 1);
13652 /* Process one ELF object file according to the command line options.
13653 This file may actually be stored in an archive. The file is
13654 positioned at the start of the ELF object. */
13657 process_object (char * file_name
, FILE * file
)
13661 if (! get_file_header (file
))
13663 error (_("%s: Failed to read file header\n"), file_name
);
13667 /* Initialise per file variables. */
13668 for (i
= ARRAY_SIZE (version_info
); i
--;)
13669 version_info
[i
] = 0;
13671 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13672 dynamic_info
[i
] = 0;
13673 dynamic_info_DT_GNU_HASH
= 0;
13675 /* Process the file. */
13677 printf (_("\nFile: %s\n"), file_name
);
13679 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13680 Note we do this even if cmdline_dump_sects is empty because we
13681 must make sure that the dump_sets array is zeroed out before each
13682 object file is processed. */
13683 if (num_dump_sects
> num_cmdline_dump_sects
)
13684 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13686 if (num_cmdline_dump_sects
> 0)
13688 if (num_dump_sects
== 0)
13689 /* A sneaky way of allocating the dump_sects array. */
13690 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13692 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13693 memcpy (dump_sects
, cmdline_dump_sects
,
13694 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13697 if (! process_file_header ())
13700 if (! process_section_headers (file
))
13702 /* Without loaded section headers we cannot process lots of
13704 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13706 if (! do_using_dynamic
)
13707 do_syms
= do_dyn_syms
= do_reloc
= 0;
13710 if (! process_section_groups (file
))
13712 /* Without loaded section groups we cannot process unwind. */
13716 if (process_program_headers (file
))
13717 process_dynamic_section (file
);
13719 process_relocs (file
);
13721 process_unwind (file
);
13723 process_symbol_table (file
);
13725 process_syminfo (file
);
13727 process_version_sections (file
);
13729 process_section_contents (file
);
13731 process_notes (file
);
13733 process_gnu_liblist (file
);
13735 process_arch_specific (file
);
13737 if (program_headers
)
13739 free (program_headers
);
13740 program_headers
= NULL
;
13743 if (section_headers
)
13745 free (section_headers
);
13746 section_headers
= NULL
;
13751 free (string_table
);
13752 string_table
= NULL
;
13753 string_table_length
= 0;
13756 if (dynamic_strings
)
13758 free (dynamic_strings
);
13759 dynamic_strings
= NULL
;
13760 dynamic_strings_length
= 0;
13763 if (dynamic_symbols
)
13765 free (dynamic_symbols
);
13766 dynamic_symbols
= NULL
;
13767 num_dynamic_syms
= 0;
13770 if (dynamic_syminfo
)
13772 free (dynamic_syminfo
);
13773 dynamic_syminfo
= NULL
;
13776 if (dynamic_section
)
13778 free (dynamic_section
);
13779 dynamic_section
= NULL
;
13782 if (section_headers_groups
)
13784 free (section_headers_groups
);
13785 section_headers_groups
= NULL
;
13788 if (section_groups
)
13790 struct group_list
* g
;
13791 struct group_list
* next
;
13793 for (i
= 0; i
< group_count
; i
++)
13795 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13802 free (section_groups
);
13803 section_groups
= NULL
;
13806 free_debug_memory ();
13811 /* Process an ELF archive.
13812 On entry the file is positioned just after the ARMAG string. */
13815 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13817 struct archive_info arch
;
13818 struct archive_info nested_arch
;
13824 /* The ARCH structure is used to hold information about this archive. */
13825 arch
.file_name
= NULL
;
13827 arch
.index_array
= NULL
;
13828 arch
.sym_table
= NULL
;
13829 arch
.longnames
= NULL
;
13831 /* The NESTED_ARCH structure is used as a single-item cache of information
13832 about a nested archive (when members of a thin archive reside within
13833 another regular archive file). */
13834 nested_arch
.file_name
= NULL
;
13835 nested_arch
.file
= NULL
;
13836 nested_arch
.index_array
= NULL
;
13837 nested_arch
.sym_table
= NULL
;
13838 nested_arch
.longnames
= NULL
;
13840 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13846 if (do_archive_index
)
13848 if (arch
.sym_table
== NULL
)
13849 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13853 unsigned long current_pos
;
13855 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13856 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13857 current_pos
= ftell (file
);
13859 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13861 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13863 char * member_name
;
13865 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13867 if (member_name
!= NULL
)
13869 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13871 if (qualified_name
!= NULL
)
13873 printf (_("Contents of binary %s at offset "), qualified_name
);
13874 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13876 free (qualified_name
);
13881 if (l
>= arch
.sym_size
)
13883 error (_("%s: end of the symbol table reached before the end of the index\n"),
13887 printf ("\t%s\n", arch
.sym_table
+ l
);
13888 l
+= strlen (arch
.sym_table
+ l
) + 1;
13891 if (arch
.uses_64bit_indicies
)
13896 if (l
< arch
.sym_size
)
13897 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13898 file_name
, arch
.sym_size
- l
);
13900 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13902 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13908 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13909 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13910 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13911 && !do_section_groups
&& !do_dyn_syms
)
13913 ret
= 0; /* Archive index only. */
13924 char * qualified_name
;
13926 /* Read the next archive header. */
13927 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13929 error (_("%s: failed to seek to next archive header\n"), file_name
);
13932 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13933 if (got
!= sizeof arch
.arhdr
)
13937 error (_("%s: failed to read archive header\n"), file_name
);
13941 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13943 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13948 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13950 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13951 if (archive_file_size
& 01)
13952 ++archive_file_size
;
13954 name
= get_archive_member_name (&arch
, &nested_arch
);
13957 error (_("%s: bad archive file name\n"), file_name
);
13961 namelen
= strlen (name
);
13963 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13964 if (qualified_name
== NULL
)
13966 error (_("%s: bad archive file name\n"), file_name
);
13971 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13973 /* This is a proxy for an external member of a thin archive. */
13974 FILE * member_file
;
13975 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13976 if (member_file_name
== NULL
)
13982 member_file
= fopen (member_file_name
, "rb");
13983 if (member_file
== NULL
)
13985 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13986 free (member_file_name
);
13991 archive_file_offset
= arch
.nested_member_origin
;
13993 ret
|= process_object (qualified_name
, member_file
);
13995 fclose (member_file
);
13996 free (member_file_name
);
13998 else if (is_thin_archive
)
14000 /* PR 15140: Allow for corrupt thin archives. */
14001 if (nested_arch
.file
== NULL
)
14003 error (_("%s: contains corrupt thin archive: %s\n"),
14009 /* This is a proxy for a member of a nested archive. */
14010 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14012 /* The nested archive file will have been opened and setup by
14013 get_archive_member_name. */
14014 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14016 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14021 ret
|= process_object (qualified_name
, nested_arch
.file
);
14025 archive_file_offset
= arch
.next_arhdr_offset
;
14026 arch
.next_arhdr_offset
+= archive_file_size
;
14028 ret
|= process_object (qualified_name
, file
);
14031 if (dump_sects
!= NULL
)
14035 num_dump_sects
= 0;
14038 free (qualified_name
);
14042 if (nested_arch
.file
!= NULL
)
14043 fclose (nested_arch
.file
);
14044 release_archive (&nested_arch
);
14045 release_archive (&arch
);
14051 process_file (char * file_name
)
14054 struct stat statbuf
;
14055 char armag
[SARMAG
];
14058 if (stat (file_name
, &statbuf
) < 0)
14060 if (errno
== ENOENT
)
14061 error (_("'%s': No such file\n"), file_name
);
14063 error (_("Could not locate '%s'. System error message: %s\n"),
14064 file_name
, strerror (errno
));
14068 if (! S_ISREG (statbuf
.st_mode
))
14070 error (_("'%s' is not an ordinary file\n"), file_name
);
14074 file
= fopen (file_name
, "rb");
14077 error (_("Input file '%s' is not readable.\n"), file_name
);
14081 if (fread (armag
, SARMAG
, 1, file
) != 1)
14083 error (_("%s: Failed to read file's magic number\n"), file_name
);
14088 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14089 ret
= process_archive (file_name
, file
, FALSE
);
14090 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14091 ret
= process_archive (file_name
, file
, TRUE
);
14094 if (do_archive_index
)
14095 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14099 archive_file_size
= archive_file_offset
= 0;
14100 ret
= process_object (file_name
, file
);
14108 #ifdef SUPPORT_DISASSEMBLY
14109 /* Needed by the i386 disassembler. For extra credit, someone could
14110 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14114 print_address (unsigned int addr
, FILE * outfile
)
14116 fprintf (outfile
,"0x%8.8x", addr
);
14119 /* Needed by the i386 disassembler. */
14121 db_task_printsym (unsigned int addr
)
14123 print_address (addr
, stderr
);
14128 main (int argc
, char ** argv
)
14132 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14133 setlocale (LC_MESSAGES
, "");
14135 #if defined (HAVE_SETLOCALE)
14136 setlocale (LC_CTYPE
, "");
14138 bindtextdomain (PACKAGE
, LOCALEDIR
);
14139 textdomain (PACKAGE
);
14141 expandargv (&argc
, &argv
);
14143 parse_args (argc
, argv
);
14145 if (num_dump_sects
> 0)
14147 /* Make a copy of the dump_sects array. */
14148 cmdline_dump_sects
= (dump_type
*)
14149 malloc (num_dump_sects
* sizeof (* dump_sects
));
14150 if (cmdline_dump_sects
== NULL
)
14151 error (_("Out of memory allocating dump request table.\n"));
14154 memcpy (cmdline_dump_sects
, dump_sects
,
14155 num_dump_sects
* sizeof (* dump_sects
));
14156 num_cmdline_dump_sects
= num_dump_sects
;
14160 if (optind
< (argc
- 1))
14164 while (optind
< argc
)
14165 err
|= process_file (argv
[optind
++]);
14167 if (dump_sects
!= NULL
)
14169 if (cmdline_dump_sects
!= NULL
)
14170 free (cmdline_dump_sects
);