1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 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. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.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/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/visium.h"
153 #include "elf/x86-64.h"
154 #include "elf/xc16x.h"
155 #include "elf/xgate.h"
156 #include "elf/xstormy16.h"
157 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
162 #include "filenames.h"
165 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168 typedef struct elf_section_list
170 Elf_Internal_Shdr
* hdr
;
171 struct elf_section_list
* next
;
174 char * program_name
= "readelf";
175 static unsigned long archive_file_offset
;
176 static unsigned long archive_file_size
;
177 static bfd_size_type current_file_size
;
178 static unsigned long dynamic_addr
;
179 static bfd_size_type dynamic_size
;
180 static size_t dynamic_nent
;
181 static char * dynamic_strings
;
182 static unsigned long dynamic_strings_length
;
183 static char * string_table
;
184 static unsigned long string_table_length
;
185 static unsigned long num_dynamic_syms
;
186 static Elf_Internal_Sym
* dynamic_symbols
;
187 static Elf_Internal_Syminfo
* dynamic_syminfo
;
188 static unsigned long dynamic_syminfo_offset
;
189 static unsigned int dynamic_syminfo_nent
;
190 static char program_interpreter
[PATH_MAX
];
191 static bfd_vma dynamic_info
[DT_ENCODING
];
192 static bfd_vma dynamic_info_DT_GNU_HASH
;
193 static bfd_vma version_info
[16];
194 static Elf_Internal_Ehdr elf_header
;
195 static Elf_Internal_Shdr
* section_headers
;
196 static Elf_Internal_Phdr
* program_headers
;
197 static Elf_Internal_Dyn
* dynamic_section
;
198 static elf_section_list
* symtab_shndx_list
;
199 static int show_name
;
200 static int do_dynamic
;
202 static int do_dyn_syms
;
204 static int do_sections
;
205 static int do_section_groups
;
206 static int do_section_details
;
207 static int do_segments
;
208 static int do_unwind
;
209 static int do_using_dynamic
;
210 static int do_header
;
212 static int do_version
;
213 static int do_histogram
;
214 static int do_debugging
;
217 static int do_archive_index
;
218 static int is_32bit_elf
;
219 static int decompress_dumps
;
223 struct group_list
* next
;
224 unsigned int section_index
;
229 struct group_list
* root
;
230 unsigned int group_index
;
233 static size_t group_count
;
234 static struct group
* section_groups
;
235 static struct group
** section_headers_groups
;
238 /* Flag bits indicating particular types of dump. */
239 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
240 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
241 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
242 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
243 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
245 typedef unsigned char dump_type
;
247 /* A linked list of the section names for which dumps were requested. */
248 struct dump_list_entry
252 struct dump_list_entry
* next
;
254 static struct dump_list_entry
* dump_sects_byname
;
256 /* A dynamic array of flags indicating for which sections a dump
257 has been requested via command line switches. */
258 static dump_type
* cmdline_dump_sects
= NULL
;
259 static unsigned int num_cmdline_dump_sects
= 0;
261 /* A dynamic array of flags indicating for which sections a dump of
262 some kind has been requested. It is reset on a per-object file
263 basis and then initialised from the cmdline_dump_sects array,
264 the results of interpreting the -w switch, and the
265 dump_sects_byname list. */
266 static dump_type
* dump_sects
= NULL
;
267 static unsigned int num_dump_sects
= 0;
270 /* How to print a vma value. */
271 typedef enum print_mode
283 /* Versioned symbol info. */
284 enum versioned_symbol_info
291 static const char *get_symbol_version_string
292 (FILE *file
, int is_dynsym
, const char *strtab
,
293 unsigned long int strtab_size
, unsigned int si
,
294 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
295 unsigned short *vna_other
);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value. */
422 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
450 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
453 return printf ("%" BFD_VMA_FMT
"d", vma
);
456 return printf ("%" BFD_VMA_FMT
"u", vma
);
461 /* Display a symbol on stdout. Handles the display of control characters and
462 multibye characters (assuming the host environment supports them).
464 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
466 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
467 padding as necessary.
469 Returns the number of emitted characters. */
472 print_symbol (int width
, const char *symbol
)
474 bfd_boolean extra_padding
= FALSE
;
476 #ifdef HAVE_MBSTATE_T
483 /* Keep the width positive. This also helps. */
485 extra_padding
= TRUE
;
490 /* Set the remaining width to a very large value.
491 This simplifies the code below. */
492 width_remaining
= INT_MAX
;
494 width_remaining
= width
;
496 #ifdef HAVE_MBSTATE_T
497 /* Initialise the multibyte conversion state. */
498 memset (& state
, 0, sizeof (state
));
501 while (width_remaining
)
504 const char c
= *symbol
++;
509 /* Do not print control characters directly as they can affect terminal
510 settings. Such characters usually appear in the names generated
511 by the assembler for local labels. */
514 if (width_remaining
< 2)
517 printf ("^%c", c
+ 0x40);
518 width_remaining
-= 2;
521 else if (ISPRINT (c
))
529 #ifdef HAVE_MBSTATE_T
532 /* Let printf do the hard work of displaying multibyte characters. */
533 printf ("%.1s", symbol
- 1);
537 #ifdef HAVE_MBSTATE_T
538 /* Try to find out how many bytes made up the character that was
539 just printed. Advance the symbol pointer past the bytes that
541 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
545 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
550 if (extra_padding
&& num_printed
< width
)
552 /* Fill in the remaining spaces. */
553 printf ("%-*s", width
- num_printed
, " ");
560 /* Returns a pointer to a static buffer containing a printable version of
561 the given section's name. Like print_symbol, except that it does not try
562 to print multibyte characters, it just interprets them as hex values. */
565 printable_section_name (const Elf_Internal_Shdr
* sec
)
567 #define MAX_PRINT_SEC_NAME_LEN 128
568 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
569 const char * name
= SECTION_NAME (sec
);
570 char * buf
= sec_name_buf
;
572 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
574 while ((c
= * name
++) != 0)
585 else if (ISPRINT (c
))
592 static char hex
[17] = "0123456789ABCDEF";
597 * buf
++ = hex
[(c
& 0xf0) >> 4];
598 * buf
++ = hex
[c
& 0x0f];
612 printable_section_name_from_index (unsigned long ndx
)
614 if (ndx
>= elf_header
.e_shnum
)
615 return _("<corrupt>");
617 return printable_section_name (section_headers
+ ndx
);
620 /* Return a pointer to section NAME, or NULL if no such section exists. */
622 static Elf_Internal_Shdr
*
623 find_section (const char * name
)
627 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
628 if (streq (SECTION_NAME (section_headers
+ i
), name
))
629 return section_headers
+ i
;
634 /* Return a pointer to a section containing ADDR, or NULL if no such
637 static Elf_Internal_Shdr
*
638 find_section_by_address (bfd_vma addr
)
642 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
644 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
645 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
652 static Elf_Internal_Shdr
*
653 find_section_by_type (unsigned int type
)
657 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
659 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
660 if (sec
->sh_type
== type
)
667 /* Return a pointer to section NAME, or NULL if no such section exists,
668 restricted to the list of sections given in SET. */
670 static Elf_Internal_Shdr
*
671 find_section_in_set (const char * name
, unsigned int * set
)
677 while ((i
= *set
++) > 0)
678 if (streq (SECTION_NAME (section_headers
+ i
), name
))
679 return section_headers
+ i
;
682 return find_section (name
);
685 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
688 static inline unsigned long
689 read_uleb128 (unsigned char *data
,
690 unsigned int *length_return
,
691 const unsigned char * const end
)
693 return read_leb128 (data
, length_return
, FALSE
, end
);
696 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
697 This OS has so many departures from the ELF standard that we test it at
703 return elf_header
.e_machine
== EM_IA_64
704 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
707 /* Guess the relocation size commonly used by the specific machines. */
710 guess_is_rela (unsigned int e_machine
)
714 /* Targets that use REL relocations. */
729 /* Targets that use RELA relocations. */
733 case EM_ADAPTEVA_EPIPHANY
:
735 case EM_ALTERA_NIOS2
:
738 case EM_ARC_COMPACT2
:
758 case EM_LATTICEMICO32
:
767 case EM_CYGNUS_MN10200
:
769 case EM_CYGNUS_MN10300
:
804 case EM_MICROBLAZE_OLD
:
825 warn (_("Don't know about relocations on this machine architecture\n"));
831 slurp_rela_relocs (FILE * file
,
832 unsigned long rel_offset
,
833 unsigned long rel_size
,
834 Elf_Internal_Rela
** relasp
,
835 unsigned long * nrelasp
)
837 Elf_Internal_Rela
* relas
;
843 Elf32_External_Rela
* erelas
;
845 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
846 rel_size
, _("32-bit relocation data"));
850 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
852 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
853 sizeof (Elf_Internal_Rela
));
858 error (_("out of memory parsing relocs\n"));
862 for (i
= 0; i
< nrelas
; i
++)
864 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
865 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
866 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
873 Elf64_External_Rela
* erelas
;
875 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
876 rel_size
, _("64-bit relocation data"));
880 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
882 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
883 sizeof (Elf_Internal_Rela
));
888 error (_("out of memory parsing relocs\n"));
892 for (i
= 0; i
< nrelas
; i
++)
894 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
895 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
896 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
898 /* The #ifdef BFD64 below is to prevent a compile time
899 warning. We know that if we do not have a 64 bit data
900 type that we will never execute this code anyway. */
902 if (elf_header
.e_machine
== EM_MIPS
903 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
905 /* In little-endian objects, r_info isn't really a
906 64-bit little-endian value: it has a 32-bit
907 little-endian symbol index followed by four
908 individual byte fields. Reorder INFO
910 bfd_vma inf
= relas
[i
].r_info
;
911 inf
= (((inf
& 0xffffffff) << 32)
912 | ((inf
>> 56) & 0xff)
913 | ((inf
>> 40) & 0xff00)
914 | ((inf
>> 24) & 0xff0000)
915 | ((inf
>> 8) & 0xff000000));
916 relas
[i
].r_info
= inf
;
929 slurp_rel_relocs (FILE * file
,
930 unsigned long rel_offset
,
931 unsigned long rel_size
,
932 Elf_Internal_Rela
** relsp
,
933 unsigned long * nrelsp
)
935 Elf_Internal_Rela
* rels
;
941 Elf32_External_Rel
* erels
;
943 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
944 rel_size
, _("32-bit relocation data"));
948 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
950 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
955 error (_("out of memory parsing relocs\n"));
959 for (i
= 0; i
< nrels
; i
++)
961 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
962 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
963 rels
[i
].r_addend
= 0;
970 Elf64_External_Rel
* erels
;
972 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
973 rel_size
, _("64-bit relocation data"));
977 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
979 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
984 error (_("out of memory parsing relocs\n"));
988 for (i
= 0; i
< nrels
; i
++)
990 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
991 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
992 rels
[i
].r_addend
= 0;
994 /* The #ifdef BFD64 below is to prevent a compile time
995 warning. We know that if we do not have a 64 bit data
996 type that we will never execute this code anyway. */
998 if (elf_header
.e_machine
== EM_MIPS
999 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1001 /* In little-endian objects, r_info isn't really a
1002 64-bit little-endian value: it has a 32-bit
1003 little-endian symbol index followed by four
1004 individual byte fields. Reorder INFO
1006 bfd_vma inf
= rels
[i
].r_info
;
1007 inf
= (((inf
& 0xffffffff) << 32)
1008 | ((inf
>> 56) & 0xff)
1009 | ((inf
>> 40) & 0xff00)
1010 | ((inf
>> 24) & 0xff0000)
1011 | ((inf
>> 8) & 0xff000000));
1012 rels
[i
].r_info
= inf
;
1024 /* Returns the reloc type extracted from the reloc info field. */
1027 get_reloc_type (bfd_vma reloc_info
)
1030 return ELF32_R_TYPE (reloc_info
);
1032 switch (elf_header
.e_machine
)
1035 /* Note: We assume that reloc_info has already been adjusted for us. */
1036 return ELF64_MIPS_R_TYPE (reloc_info
);
1039 return ELF64_R_TYPE_ID (reloc_info
);
1042 return ELF64_R_TYPE (reloc_info
);
1046 /* Return the symbol index extracted from the reloc info field. */
1049 get_reloc_symindex (bfd_vma reloc_info
)
1051 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1054 static inline bfd_boolean
1055 uses_msp430x_relocs (void)
1058 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1059 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1060 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1061 /* TI compiler uses ELFOSABI_NONE. */
1062 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1065 /* Display the contents of the relocation data found at the specified
1069 dump_relocations (FILE * file
,
1070 unsigned long rel_offset
,
1071 unsigned long rel_size
,
1072 Elf_Internal_Sym
* symtab
,
1073 unsigned long nsyms
,
1075 unsigned long strtablen
,
1080 Elf_Internal_Rela
* rels
;
1082 if (is_rela
== UNKNOWN
)
1083 is_rela
= guess_is_rela (elf_header
.e_machine
);
1087 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1092 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1101 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1103 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1108 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1110 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1118 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1120 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1125 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1127 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1131 for (i
= 0; i
< rel_size
; i
++)
1136 bfd_vma symtab_index
;
1139 offset
= rels
[i
].r_offset
;
1140 inf
= rels
[i
].r_info
;
1142 type
= get_reloc_type (inf
);
1143 symtab_index
= get_reloc_symindex (inf
);
1147 printf ("%8.8lx %8.8lx ",
1148 (unsigned long) offset
& 0xffffffff,
1149 (unsigned long) inf
& 0xffffffff);
1153 #if BFD_HOST_64BIT_LONG
1155 ? "%16.16lx %16.16lx "
1156 : "%12.12lx %12.12lx ",
1158 #elif BFD_HOST_64BIT_LONG_LONG
1161 ? "%16.16llx %16.16llx "
1162 : "%12.12llx %12.12llx ",
1166 ? "%16.16I64x %16.16I64x "
1167 : "%12.12I64x %12.12I64x ",
1172 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1173 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1174 _bfd_int64_high (offset
),
1175 _bfd_int64_low (offset
),
1176 _bfd_int64_high (inf
),
1177 _bfd_int64_low (inf
));
1181 switch (elf_header
.e_machine
)
1188 rtype
= elf_aarch64_reloc_type (type
);
1192 case EM_CYGNUS_M32R
:
1193 rtype
= elf_m32r_reloc_type (type
);
1198 rtype
= elf_i386_reloc_type (type
);
1203 rtype
= elf_m68hc11_reloc_type (type
);
1207 rtype
= elf_m68k_reloc_type (type
);
1211 rtype
= elf_i960_reloc_type (type
);
1216 rtype
= elf_avr_reloc_type (type
);
1219 case EM_OLD_SPARCV9
:
1220 case EM_SPARC32PLUS
:
1223 rtype
= elf_sparc_reloc_type (type
);
1227 rtype
= elf_spu_reloc_type (type
);
1231 rtype
= v800_reloc_type (type
);
1234 case EM_CYGNUS_V850
:
1235 rtype
= v850_reloc_type (type
);
1239 case EM_CYGNUS_D10V
:
1240 rtype
= elf_d10v_reloc_type (type
);
1244 case EM_CYGNUS_D30V
:
1245 rtype
= elf_d30v_reloc_type (type
);
1249 rtype
= elf_dlx_reloc_type (type
);
1253 rtype
= elf_sh_reloc_type (type
);
1257 case EM_CYGNUS_MN10300
:
1258 rtype
= elf_mn10300_reloc_type (type
);
1262 case EM_CYGNUS_MN10200
:
1263 rtype
= elf_mn10200_reloc_type (type
);
1267 case EM_CYGNUS_FR30
:
1268 rtype
= elf_fr30_reloc_type (type
);
1272 rtype
= elf_frv_reloc_type (type
);
1276 rtype
= elf_ft32_reloc_type (type
);
1280 rtype
= elf_mcore_reloc_type (type
);
1284 rtype
= elf_mmix_reloc_type (type
);
1288 rtype
= elf_moxie_reloc_type (type
);
1292 if (uses_msp430x_relocs ())
1294 rtype
= elf_msp430x_reloc_type (type
);
1299 rtype
= elf_msp430_reloc_type (type
);
1303 rtype
= elf_nds32_reloc_type (type
);
1307 rtype
= elf_ppc_reloc_type (type
);
1311 rtype
= elf_ppc64_reloc_type (type
);
1315 case EM_MIPS_RS3_LE
:
1316 rtype
= elf_mips_reloc_type (type
);
1320 rtype
= elf_riscv_reloc_type (type
);
1324 rtype
= elf_alpha_reloc_type (type
);
1328 rtype
= elf_arm_reloc_type (type
);
1332 case EM_ARC_COMPACT
:
1333 case EM_ARC_COMPACT2
:
1334 rtype
= elf_arc_reloc_type (type
);
1338 rtype
= elf_hppa_reloc_type (type
);
1344 rtype
= elf_h8_reloc_type (type
);
1348 rtype
= elf_or1k_reloc_type (type
);
1353 rtype
= elf_pj_reloc_type (type
);
1356 rtype
= elf_ia64_reloc_type (type
);
1360 rtype
= elf_cris_reloc_type (type
);
1364 rtype
= elf_i860_reloc_type (type
);
1370 rtype
= elf_x86_64_reloc_type (type
);
1374 rtype
= i370_reloc_type (type
);
1379 rtype
= elf_s390_reloc_type (type
);
1383 rtype
= elf_score_reloc_type (type
);
1387 rtype
= elf_xstormy16_reloc_type (type
);
1391 rtype
= elf_crx_reloc_type (type
);
1395 rtype
= elf_vax_reloc_type (type
);
1399 rtype
= elf_visium_reloc_type (type
);
1402 case EM_ADAPTEVA_EPIPHANY
:
1403 rtype
= elf_epiphany_reloc_type (type
);
1408 rtype
= elf_ip2k_reloc_type (type
);
1412 rtype
= elf_iq2000_reloc_type (type
);
1417 rtype
= elf_xtensa_reloc_type (type
);
1420 case EM_LATTICEMICO32
:
1421 rtype
= elf_lm32_reloc_type (type
);
1426 rtype
= elf_m32c_reloc_type (type
);
1430 rtype
= elf_mt_reloc_type (type
);
1434 rtype
= elf_bfin_reloc_type (type
);
1438 rtype
= elf_mep_reloc_type (type
);
1442 rtype
= elf_cr16_reloc_type (type
);
1446 case EM_MICROBLAZE_OLD
:
1447 rtype
= elf_microblaze_reloc_type (type
);
1451 rtype
= elf_rl78_reloc_type (type
);
1455 rtype
= elf_rx_reloc_type (type
);
1459 rtype
= elf_metag_reloc_type (type
);
1464 rtype
= elf_xc16x_reloc_type (type
);
1468 rtype
= elf_tic6x_reloc_type (type
);
1472 rtype
= elf_tilegx_reloc_type (type
);
1476 rtype
= elf_tilepro_reloc_type (type
);
1480 rtype
= elf_xgate_reloc_type (type
);
1483 case EM_ALTERA_NIOS2
:
1484 rtype
= elf_nios2_reloc_type (type
);
1489 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1491 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1493 if (elf_header
.e_machine
== EM_ALPHA
1495 && streq (rtype
, "R_ALPHA_LITUSE")
1498 switch (rels
[i
].r_addend
)
1500 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1501 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1502 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1503 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1504 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1505 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1506 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1507 default: rtype
= NULL
;
1510 printf (" (%s)", rtype
);
1514 printf (_("<unknown addend: %lx>"),
1515 (unsigned long) rels
[i
].r_addend
);
1518 else if (symtab_index
)
1520 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1521 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1524 Elf_Internal_Sym
* psym
;
1525 const char * version_string
;
1526 enum versioned_symbol_info sym_info
;
1527 unsigned short vna_other
;
1529 psym
= symtab
+ symtab_index
;
1532 = get_symbol_version_string (file
, is_dynsym
,
1541 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1545 unsigned int width
= is_32bit_elf
? 8 : 14;
1547 /* Relocations against GNU_IFUNC symbols do not use the value
1548 of the symbol as the address to relocate against. Instead
1549 they invoke the function named by the symbol and use its
1550 result as the address for relocation.
1552 To indicate this to the user, do not display the value of
1553 the symbol in the "Symbols's Value" field. Instead show
1554 its name followed by () as a hint that the symbol is
1558 || psym
->st_name
== 0
1559 || psym
->st_name
>= strtablen
)
1562 name
= strtab
+ psym
->st_name
;
1564 len
= print_symbol (width
, name
);
1566 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1568 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1572 print_vma (psym
->st_value
, LONG_HEX
);
1574 printf (is_32bit_elf
? " " : " ");
1577 if (psym
->st_name
== 0)
1579 const char * sec_name
= "<null>";
1582 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1584 if (psym
->st_shndx
< elf_header
.e_shnum
)
1585 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1586 else if (psym
->st_shndx
== SHN_ABS
)
1588 else if (psym
->st_shndx
== SHN_COMMON
)
1589 sec_name
= "COMMON";
1590 else if ((elf_header
.e_machine
== EM_MIPS
1591 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1592 || (elf_header
.e_machine
== EM_TI_C6000
1593 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1594 sec_name
= "SCOMMON";
1595 else if (elf_header
.e_machine
== EM_MIPS
1596 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1597 sec_name
= "SUNDEF";
1598 else if ((elf_header
.e_machine
== EM_X86_64
1599 || elf_header
.e_machine
== EM_L1OM
1600 || elf_header
.e_machine
== EM_K1OM
)
1601 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1602 sec_name
= "LARGE_COMMON";
1603 else if (elf_header
.e_machine
== EM_IA_64
1604 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1605 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1606 sec_name
= "ANSI_COM";
1607 else if (is_ia64_vms ()
1608 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1609 sec_name
= "VMS_SYMVEC";
1612 sprintf (name_buf
, "<section 0x%x>",
1613 (unsigned int) psym
->st_shndx
);
1614 sec_name
= name_buf
;
1617 print_symbol (22, sec_name
);
1619 else if (strtab
== NULL
)
1620 printf (_("<string table index: %3ld>"), psym
->st_name
);
1621 else if (psym
->st_name
>= strtablen
)
1622 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1625 print_symbol (22, strtab
+ psym
->st_name
);
1627 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1633 bfd_vma off
= rels
[i
].r_addend
;
1635 if ((bfd_signed_vma
) off
< 0)
1636 printf (" - %" BFD_VMA_FMT
"x", - off
);
1638 printf (" + %" BFD_VMA_FMT
"x", off
);
1644 bfd_vma off
= rels
[i
].r_addend
;
1646 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1647 if ((bfd_signed_vma
) off
< 0)
1648 printf ("-%" BFD_VMA_FMT
"x", - off
);
1650 printf ("%" BFD_VMA_FMT
"x", off
);
1653 if (elf_header
.e_machine
== EM_SPARCV9
1655 && streq (rtype
, "R_SPARC_OLO10"))
1656 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1661 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1663 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1664 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1665 const char * rtype2
= elf_mips_reloc_type (type2
);
1666 const char * rtype3
= elf_mips_reloc_type (type3
);
1668 printf (" Type2: ");
1671 printf (_("unrecognized: %-7lx"),
1672 (unsigned long) type2
& 0xffffffff);
1674 printf ("%-17.17s", rtype2
);
1676 printf ("\n Type3: ");
1679 printf (_("unrecognized: %-7lx"),
1680 (unsigned long) type3
& 0xffffffff);
1682 printf ("%-17.17s", rtype3
);
1693 get_mips_dynamic_type (unsigned long type
)
1697 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1698 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1699 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1700 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1701 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1702 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1703 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1704 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1705 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1706 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1707 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1708 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1709 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1710 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1711 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1712 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1713 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1714 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1715 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1716 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1717 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1718 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1719 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1720 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1721 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1722 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1723 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1724 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1725 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1726 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1727 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1728 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1729 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1730 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1731 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1732 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1733 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1734 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1735 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1736 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1737 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1738 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1739 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1740 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1741 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1742 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1749 get_sparc64_dynamic_type (unsigned long type
)
1753 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1760 get_ppc_dynamic_type (unsigned long type
)
1764 case DT_PPC_GOT
: return "PPC_GOT";
1765 case DT_PPC_OPT
: return "PPC_OPT";
1772 get_ppc64_dynamic_type (unsigned long type
)
1776 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1777 case DT_PPC64_OPD
: return "PPC64_OPD";
1778 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1779 case DT_PPC64_OPT
: return "PPC64_OPT";
1786 get_parisc_dynamic_type (unsigned long type
)
1790 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1791 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1792 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1793 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1794 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1795 case DT_HP_PREINIT
: return "HP_PREINIT";
1796 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1797 case DT_HP_NEEDED
: return "HP_NEEDED";
1798 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1799 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1800 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1801 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1802 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1803 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1804 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1805 case DT_HP_FILTERED
: return "HP_FILTERED";
1806 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1807 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1808 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1809 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1810 case DT_PLT
: return "PLT";
1811 case DT_PLT_SIZE
: return "PLT_SIZE";
1812 case DT_DLT
: return "DLT";
1813 case DT_DLT_SIZE
: return "DLT_SIZE";
1820 get_ia64_dynamic_type (unsigned long type
)
1824 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1825 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1826 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1827 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1828 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1829 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1830 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1831 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1832 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1833 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1834 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1835 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1836 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1837 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1838 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1839 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1840 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1841 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1842 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1843 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1844 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1845 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1846 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1847 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1848 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1849 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1850 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1851 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1852 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1853 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1854 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1861 get_solaris_section_type (unsigned long type
)
1865 case 0x6fffffee: return "SUNW_ancillary";
1866 case 0x6fffffef: return "SUNW_capchain";
1867 case 0x6ffffff0: return "SUNW_capinfo";
1868 case 0x6ffffff1: return "SUNW_symsort";
1869 case 0x6ffffff2: return "SUNW_tlssort";
1870 case 0x6ffffff3: return "SUNW_LDYNSYM";
1871 case 0x6ffffff4: return "SUNW_dof";
1872 case 0x6ffffff5: return "SUNW_cap";
1873 case 0x6ffffff6: return "SUNW_SIGNATURE";
1874 case 0x6ffffff7: return "SUNW_ANNOTATE";
1875 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1876 case 0x6ffffff9: return "SUNW_DEBUG";
1877 case 0x6ffffffa: return "SUNW_move";
1878 case 0x6ffffffb: return "SUNW_COMDAT";
1879 case 0x6ffffffc: return "SUNW_syminfo";
1880 case 0x6ffffffd: return "SUNW_verdef";
1881 case 0x6ffffffe: return "SUNW_verneed";
1882 case 0x6fffffff: return "SUNW_versym";
1883 case 0x70000000: return "SPARC_GOTDATA";
1884 default: return NULL
;
1889 get_alpha_dynamic_type (unsigned long type
)
1893 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1900 get_score_dynamic_type (unsigned long type
)
1904 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1905 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1906 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1907 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1908 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1909 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1916 get_tic6x_dynamic_type (unsigned long type
)
1920 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1921 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1922 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1923 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1924 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1925 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1932 get_nios2_dynamic_type (unsigned long type
)
1936 case DT_NIOS2_GP
: return "NIOS2_GP";
1943 get_solaris_dynamic_type (unsigned long type
)
1947 case 0x6000000d: return "SUNW_AUXILIARY";
1948 case 0x6000000e: return "SUNW_RTLDINF";
1949 case 0x6000000f: return "SUNW_FILTER";
1950 case 0x60000010: return "SUNW_CAP";
1951 case 0x60000011: return "SUNW_SYMTAB";
1952 case 0x60000012: return "SUNW_SYMSZ";
1953 case 0x60000013: return "SUNW_SORTENT";
1954 case 0x60000014: return "SUNW_SYMSORT";
1955 case 0x60000015: return "SUNW_SYMSORTSZ";
1956 case 0x60000016: return "SUNW_TLSSORT";
1957 case 0x60000017: return "SUNW_TLSSORTSZ";
1958 case 0x60000018: return "SUNW_CAPINFO";
1959 case 0x60000019: return "SUNW_STRPAD";
1960 case 0x6000001a: return "SUNW_CAPCHAIN";
1961 case 0x6000001b: return "SUNW_LDMACH";
1962 case 0x6000001d: return "SUNW_CAPCHAINENT";
1963 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1964 case 0x60000021: return "SUNW_PARENT";
1965 case 0x60000023: return "SUNW_ASLR";
1966 case 0x60000025: return "SUNW_RELAX";
1967 case 0x60000029: return "SUNW_NXHEAP";
1968 case 0x6000002b: return "SUNW_NXSTACK";
1970 case 0x70000001: return "SPARC_REGISTER";
1971 case 0x7ffffffd: return "AUXILIARY";
1972 case 0x7ffffffe: return "USED";
1973 case 0x7fffffff: return "FILTER";
1975 default: return NULL
;
1980 get_dynamic_type (unsigned long type
)
1982 static char buff
[64];
1986 case DT_NULL
: return "NULL";
1987 case DT_NEEDED
: return "NEEDED";
1988 case DT_PLTRELSZ
: return "PLTRELSZ";
1989 case DT_PLTGOT
: return "PLTGOT";
1990 case DT_HASH
: return "HASH";
1991 case DT_STRTAB
: return "STRTAB";
1992 case DT_SYMTAB
: return "SYMTAB";
1993 case DT_RELA
: return "RELA";
1994 case DT_RELASZ
: return "RELASZ";
1995 case DT_RELAENT
: return "RELAENT";
1996 case DT_STRSZ
: return "STRSZ";
1997 case DT_SYMENT
: return "SYMENT";
1998 case DT_INIT
: return "INIT";
1999 case DT_FINI
: return "FINI";
2000 case DT_SONAME
: return "SONAME";
2001 case DT_RPATH
: return "RPATH";
2002 case DT_SYMBOLIC
: return "SYMBOLIC";
2003 case DT_REL
: return "REL";
2004 case DT_RELSZ
: return "RELSZ";
2005 case DT_RELENT
: return "RELENT";
2006 case DT_PLTREL
: return "PLTREL";
2007 case DT_DEBUG
: return "DEBUG";
2008 case DT_TEXTREL
: return "TEXTREL";
2009 case DT_JMPREL
: return "JMPREL";
2010 case DT_BIND_NOW
: return "BIND_NOW";
2011 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2012 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2013 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2014 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2015 case DT_RUNPATH
: return "RUNPATH";
2016 case DT_FLAGS
: return "FLAGS";
2018 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2019 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2020 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2022 case DT_CHECKSUM
: return "CHECKSUM";
2023 case DT_PLTPADSZ
: return "PLTPADSZ";
2024 case DT_MOVEENT
: return "MOVEENT";
2025 case DT_MOVESZ
: return "MOVESZ";
2026 case DT_FEATURE
: return "FEATURE";
2027 case DT_POSFLAG_1
: return "POSFLAG_1";
2028 case DT_SYMINSZ
: return "SYMINSZ";
2029 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2031 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2032 case DT_CONFIG
: return "CONFIG";
2033 case DT_DEPAUDIT
: return "DEPAUDIT";
2034 case DT_AUDIT
: return "AUDIT";
2035 case DT_PLTPAD
: return "PLTPAD";
2036 case DT_MOVETAB
: return "MOVETAB";
2037 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2039 case DT_VERSYM
: return "VERSYM";
2041 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2042 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2043 case DT_RELACOUNT
: return "RELACOUNT";
2044 case DT_RELCOUNT
: return "RELCOUNT";
2045 case DT_FLAGS_1
: return "FLAGS_1";
2046 case DT_VERDEF
: return "VERDEF";
2047 case DT_VERDEFNUM
: return "VERDEFNUM";
2048 case DT_VERNEED
: return "VERNEED";
2049 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2051 case DT_AUXILIARY
: return "AUXILIARY";
2052 case DT_USED
: return "USED";
2053 case DT_FILTER
: return "FILTER";
2055 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2056 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2057 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2058 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2059 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2060 case DT_GNU_HASH
: return "GNU_HASH";
2063 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2065 const char * result
;
2067 switch (elf_header
.e_machine
)
2070 case EM_MIPS_RS3_LE
:
2071 result
= get_mips_dynamic_type (type
);
2074 result
= get_sparc64_dynamic_type (type
);
2077 result
= get_ppc_dynamic_type (type
);
2080 result
= get_ppc64_dynamic_type (type
);
2083 result
= get_ia64_dynamic_type (type
);
2086 result
= get_alpha_dynamic_type (type
);
2089 result
= get_score_dynamic_type (type
);
2092 result
= get_tic6x_dynamic_type (type
);
2094 case EM_ALTERA_NIOS2
:
2095 result
= get_nios2_dynamic_type (type
);
2098 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2099 result
= get_solaris_dynamic_type (type
);
2108 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2110 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2111 || (elf_header
.e_machine
== EM_PARISC
2112 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2114 const char * result
;
2116 switch (elf_header
.e_machine
)
2119 result
= get_parisc_dynamic_type (type
);
2122 result
= get_ia64_dynamic_type (type
);
2125 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2126 result
= get_solaris_dynamic_type (type
);
2135 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2139 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2146 get_file_type (unsigned e_type
)
2148 static char buff
[32];
2152 case ET_NONE
: return _("NONE (None)");
2153 case ET_REL
: return _("REL (Relocatable file)");
2154 case ET_EXEC
: return _("EXEC (Executable file)");
2155 case ET_DYN
: return _("DYN (Shared object file)");
2156 case ET_CORE
: return _("CORE (Core file)");
2159 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2160 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2161 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2162 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2164 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2170 get_machine_name (unsigned e_machine
)
2172 static char buff
[64]; /* XXX */
2176 case EM_NONE
: return _("None");
2177 case EM_AARCH64
: return "AArch64";
2178 case EM_M32
: return "WE32100";
2179 case EM_SPARC
: return "Sparc";
2180 case EM_SPU
: return "SPU";
2181 case EM_386
: return "Intel 80386";
2182 case EM_68K
: return "MC68000";
2183 case EM_88K
: return "MC88000";
2184 case EM_IAMCU
: return "Intel MCU";
2185 case EM_860
: return "Intel 80860";
2186 case EM_MIPS
: return "MIPS R3000";
2187 case EM_S370
: return "IBM System/370";
2188 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2189 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2190 case EM_PARISC
: return "HPPA";
2191 case EM_PPC_OLD
: return "Power PC (old)";
2192 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2193 case EM_960
: return "Intel 90860";
2194 case EM_PPC
: return "PowerPC";
2195 case EM_PPC64
: return "PowerPC64";
2196 case EM_FR20
: return "Fujitsu FR20";
2197 case EM_FT32
: return "FTDI FT32";
2198 case EM_RH32
: return "TRW RH32";
2199 case EM_MCORE
: return "MCORE";
2200 case EM_ARM
: return "ARM";
2201 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2202 case EM_SH
: return "Renesas / SuperH SH";
2203 case EM_SPARCV9
: return "Sparc v9";
2204 case EM_TRICORE
: return "Siemens Tricore";
2205 case EM_ARC
: return "ARC";
2206 case EM_ARC_COMPACT
: return "ARCompact";
2207 case EM_ARC_COMPACT2
: return "ARCv2";
2208 case EM_H8_300
: return "Renesas H8/300";
2209 case EM_H8_300H
: return "Renesas H8/300H";
2210 case EM_H8S
: return "Renesas H8S";
2211 case EM_H8_500
: return "Renesas H8/500";
2212 case EM_IA_64
: return "Intel IA-64";
2213 case EM_MIPS_X
: return "Stanford MIPS-X";
2214 case EM_COLDFIRE
: return "Motorola Coldfire";
2215 case EM_ALPHA
: return "Alpha";
2216 case EM_CYGNUS_D10V
:
2217 case EM_D10V
: return "d10v";
2218 case EM_CYGNUS_D30V
:
2219 case EM_D30V
: return "d30v";
2220 case EM_CYGNUS_M32R
:
2221 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2222 case EM_CYGNUS_V850
:
2223 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2224 case EM_V850
: return "Renesas V850";
2225 case EM_CYGNUS_MN10300
:
2226 case EM_MN10300
: return "mn10300";
2227 case EM_CYGNUS_MN10200
:
2228 case EM_MN10200
: return "mn10200";
2229 case EM_MOXIE
: return "Moxie";
2230 case EM_CYGNUS_FR30
:
2231 case EM_FR30
: return "Fujitsu FR30";
2232 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2234 case EM_PJ
: return "picoJava";
2235 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2236 case EM_PCP
: return "Siemens PCP";
2237 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2238 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2239 case EM_STARCORE
: return "Motorola Star*Core processor";
2240 case EM_ME16
: return "Toyota ME16 processor";
2241 case EM_ST100
: return "STMicroelectronics ST100 processor";
2242 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2243 case EM_PDSP
: return "Sony DSP processor";
2244 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2245 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2246 case EM_FX66
: return "Siemens FX66 microcontroller";
2247 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2248 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2249 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2250 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2251 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2252 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2253 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2254 case EM_SVX
: return "Silicon Graphics SVx";
2255 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2256 case EM_VAX
: return "Digital VAX";
2257 case EM_VISIUM
: return "CDS VISIUMcore processor";
2259 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2260 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2261 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2262 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2263 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2264 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2265 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2266 case EM_PRISM
: return "Vitesse Prism";
2267 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2268 case EM_L1OM
: return "Intel L1OM";
2269 case EM_K1OM
: return "Intel K1OM";
2271 case EM_S390
: return "IBM S/390";
2272 case EM_SCORE
: return "SUNPLUS S+Core";
2273 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2274 case EM_OR1K
: return "OpenRISC 1000";
2275 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2276 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2277 case EM_DLX
: return "OpenDLX";
2279 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2280 case EM_IQ2000
: return "Vitesse IQ2000";
2282 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2283 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2284 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2285 case EM_NS32K
: return "National Semiconductor 32000 series";
2286 case EM_TPC
: return "Tenor Network TPC processor";
2287 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2288 case EM_MAX
: return "MAX Processor";
2289 case EM_CR
: return "National Semiconductor CompactRISC";
2290 case EM_F2MC16
: return "Fujitsu F2MC16";
2291 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2292 case EM_LATTICEMICO32
: return "Lattice Mico32";
2294 case EM_M32C
: return "Renesas M32c";
2295 case EM_MT
: return "Morpho Techologies MT processor";
2296 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2297 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2298 case EM_SEP
: return "Sharp embedded microprocessor";
2299 case EM_ARCA
: return "Arca RISC microprocessor";
2300 case EM_UNICORE
: return "Unicore";
2301 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2302 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2303 case EM_NIOS32
: return "Altera Nios";
2304 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2306 case EM_XC16X
: return "Infineon Technologies xc16x";
2307 case EM_M16C
: return "Renesas M16C series microprocessors";
2308 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2309 case EM_CE
: return "Freescale Communication Engine RISC core";
2310 case EM_TSK3000
: return "Altium TSK3000 core";
2311 case EM_RS08
: return "Freescale RS08 embedded processor";
2312 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2313 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2314 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2315 case EM_SE_C17
: return "Seiko Epson C17 family";
2316 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2317 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2318 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2319 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2320 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2321 case EM_R32C
: return "Renesas R32C series microprocessors";
2322 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2323 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2324 case EM_8051
: return "Intel 8051 and variants";
2325 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2326 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2327 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2328 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2329 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2330 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2331 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2332 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2335 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2336 case EM_RISCV
: return "RISC-V";
2337 case EM_RL78
: return "Renesas RL78";
2338 case EM_RX
: return "Renesas RX";
2339 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2340 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2341 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2342 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2343 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2344 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2345 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2346 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2347 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2348 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2349 case EM_CUDA
: return "NVIDIA CUDA architecture";
2350 case EM_XGATE
: return "Motorola XGATE embedded processor";
2351 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2352 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2353 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2354 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2355 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2356 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2357 case EM_BA1
: return "Beyond BA1 CPU architecture";
2358 case EM_BA2
: return "Beyond BA2 CPU architecture";
2359 case EM_XCORE
: return "XMOS xCORE processor family";
2360 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2361 case EM_KM32
: return "KM211 KM32 32-bit processor";
2362 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2363 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2364 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2365 case EM_KVARC
: return "KM211 KVARC processor";
2366 case EM_CDP
: return "Paneve CDP architecture family";
2367 case EM_COGE
: return "Cognitive Smart Memory Processor";
2368 case EM_COOL
: return "Bluechip Systems CoolEngine";
2369 case EM_NORC
: return "Nanoradio Optimized RISC";
2370 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2371 case EM_Z80
: return "Zilog Z80";
2372 case EM_AMDGPU
: return "AMD GPU architecture";
2374 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2380 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2382 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2383 other compilers don't a specific architecture type in the e_flags, and
2384 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2385 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2388 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2389 but also sets a specific architecture type in the e_flags field.
2391 However, when decoding the flags we don't worry if we see an
2392 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2393 ARCEM architecture type. */
2395 switch (e_flags
& EF_ARC_MACH_MSK
)
2397 /* We only expect these to occur for EM_ARC_COMPACT2. */
2398 case EF_ARC_CPU_ARCV2EM
:
2399 strcat (buf
, ", ARC EM");
2401 case EF_ARC_CPU_ARCV2HS
:
2402 strcat (buf
, ", ARC HS");
2405 /* We only expect these to occur for EM_ARC_COMPACT. */
2406 case E_ARC_MACH_ARC600
:
2407 strcat (buf
, ", ARC600");
2409 case E_ARC_MACH_ARC601
:
2410 strcat (buf
, ", ARC601");
2412 case E_ARC_MACH_ARC700
:
2413 strcat (buf
, ", ARC700");
2416 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2417 new ELF with new architecture being read by an old version of
2418 readelf, or (c) An ELF built with non-GNU compiler that does not
2419 set the architecture in the e_flags. */
2421 if (e_machine
== EM_ARC_COMPACT
)
2422 strcat (buf
, ", Unknown ARCompact");
2424 strcat (buf
, ", Unknown ARC");
2428 switch (e_flags
& EF_ARC_OSABI_MSK
)
2430 case E_ARC_OSABI_ORIG
:
2431 strcat (buf
, ", (ABI:legacy)");
2433 case E_ARC_OSABI_V2
:
2434 strcat (buf
, ", (ABI:v2)");
2436 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2437 case E_ARC_OSABI_V3
:
2438 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2441 strcat (buf
, ", unrecognised ARC OSABI flag");
2447 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2452 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2453 e_flags
&= ~ EF_ARM_EABIMASK
;
2455 /* Handle "generic" ARM flags. */
2456 if (e_flags
& EF_ARM_RELEXEC
)
2458 strcat (buf
, ", relocatable executable");
2459 e_flags
&= ~ EF_ARM_RELEXEC
;
2462 /* Now handle EABI specific flags. */
2466 strcat (buf
, ", <unrecognized EABI>");
2471 case EF_ARM_EABI_VER1
:
2472 strcat (buf
, ", Version1 EABI");
2477 /* Process flags one bit at a time. */
2478 flag
= e_flags
& - e_flags
;
2483 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2484 strcat (buf
, ", sorted symbol tables");
2494 case EF_ARM_EABI_VER2
:
2495 strcat (buf
, ", Version2 EABI");
2500 /* Process flags one bit at a time. */
2501 flag
= e_flags
& - e_flags
;
2506 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2507 strcat (buf
, ", sorted symbol tables");
2510 case EF_ARM_DYNSYMSUSESEGIDX
:
2511 strcat (buf
, ", dynamic symbols use segment index");
2514 case EF_ARM_MAPSYMSFIRST
:
2515 strcat (buf
, ", mapping symbols precede others");
2525 case EF_ARM_EABI_VER3
:
2526 strcat (buf
, ", Version3 EABI");
2529 case EF_ARM_EABI_VER4
:
2530 strcat (buf
, ", Version4 EABI");
2535 /* Process flags one bit at a time. */
2536 flag
= e_flags
& - e_flags
;
2542 strcat (buf
, ", BE8");
2546 strcat (buf
, ", LE8");
2557 case EF_ARM_EABI_VER5
:
2558 strcat (buf
, ", Version5 EABI");
2563 /* Process flags one bit at a time. */
2564 flag
= e_flags
& - e_flags
;
2570 strcat (buf
, ", BE8");
2574 strcat (buf
, ", LE8");
2577 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2578 strcat (buf
, ", soft-float ABI");
2581 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2582 strcat (buf
, ", hard-float ABI");
2592 case EF_ARM_EABI_UNKNOWN
:
2593 strcat (buf
, ", GNU EABI");
2598 /* Process flags one bit at a time. */
2599 flag
= e_flags
& - e_flags
;
2604 case EF_ARM_INTERWORK
:
2605 strcat (buf
, ", interworking enabled");
2608 case EF_ARM_APCS_26
:
2609 strcat (buf
, ", uses APCS/26");
2612 case EF_ARM_APCS_FLOAT
:
2613 strcat (buf
, ", uses APCS/float");
2617 strcat (buf
, ", position independent");
2621 strcat (buf
, ", 8 bit structure alignment");
2624 case EF_ARM_NEW_ABI
:
2625 strcat (buf
, ", uses new ABI");
2628 case EF_ARM_OLD_ABI
:
2629 strcat (buf
, ", uses old ABI");
2632 case EF_ARM_SOFT_FLOAT
:
2633 strcat (buf
, ", software FP");
2636 case EF_ARM_VFP_FLOAT
:
2637 strcat (buf
, ", VFP");
2640 case EF_ARM_MAVERICK_FLOAT
:
2641 strcat (buf
, ", Maverick FP");
2652 strcat (buf
,_(", <unknown>"));
2656 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2658 --size
; /* Leave space for null terminator. */
2660 switch (e_flags
& EF_AVR_MACH
)
2662 case E_AVR_MACH_AVR1
:
2663 strncat (buf
, ", avr:1", size
);
2665 case E_AVR_MACH_AVR2
:
2666 strncat (buf
, ", avr:2", size
);
2668 case E_AVR_MACH_AVR25
:
2669 strncat (buf
, ", avr:25", size
);
2671 case E_AVR_MACH_AVR3
:
2672 strncat (buf
, ", avr:3", size
);
2674 case E_AVR_MACH_AVR31
:
2675 strncat (buf
, ", avr:31", size
);
2677 case E_AVR_MACH_AVR35
:
2678 strncat (buf
, ", avr:35", size
);
2680 case E_AVR_MACH_AVR4
:
2681 strncat (buf
, ", avr:4", size
);
2683 case E_AVR_MACH_AVR5
:
2684 strncat (buf
, ", avr:5", size
);
2686 case E_AVR_MACH_AVR51
:
2687 strncat (buf
, ", avr:51", size
);
2689 case E_AVR_MACH_AVR6
:
2690 strncat (buf
, ", avr:6", size
);
2692 case E_AVR_MACH_AVRTINY
:
2693 strncat (buf
, ", avr:100", size
);
2695 case E_AVR_MACH_XMEGA1
:
2696 strncat (buf
, ", avr:101", size
);
2698 case E_AVR_MACH_XMEGA2
:
2699 strncat (buf
, ", avr:102", size
);
2701 case E_AVR_MACH_XMEGA3
:
2702 strncat (buf
, ", avr:103", size
);
2704 case E_AVR_MACH_XMEGA4
:
2705 strncat (buf
, ", avr:104", size
);
2707 case E_AVR_MACH_XMEGA5
:
2708 strncat (buf
, ", avr:105", size
);
2710 case E_AVR_MACH_XMEGA6
:
2711 strncat (buf
, ", avr:106", size
);
2713 case E_AVR_MACH_XMEGA7
:
2714 strncat (buf
, ", avr:107", size
);
2717 strncat (buf
, ", avr:<unknown>", size
);
2721 size
-= strlen (buf
);
2722 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2723 strncat (buf
, ", link-relax", size
);
2727 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2736 static const char *ABI_STRINGS
[] =
2738 "ABI v0", /* use r5 as return register; only used in N1213HC */
2739 "ABI v1", /* use r0 as return register */
2740 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2741 "ABI v2fp", /* for FPU */
2745 static const char *VER_STRINGS
[] =
2747 "Andes ELF V1.3 or older",
2751 static const char *ARCH_STRINGS
[] =
2760 abi
= EF_NDS_ABI
& e_flags
;
2761 arch
= EF_NDS_ARCH
& e_flags
;
2762 config
= EF_NDS_INST
& e_flags
;
2763 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2765 memset (buf
, 0, size
);
2772 case E_NDS_ABI_V2FP
:
2773 case E_NDS_ABI_AABI
:
2774 case E_NDS_ABI_V2FP_PLUS
:
2775 /* In case there are holes in the array. */
2776 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2780 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2786 case E_NDS32_ELF_VER_1_2
:
2787 case E_NDS32_ELF_VER_1_3
:
2788 case E_NDS32_ELF_VER_1_4
:
2789 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2793 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2797 if (E_NDS_ABI_V0
== abi
)
2799 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2800 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2801 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2802 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2808 case E_NDS_ARCH_STAR_V1_0
:
2809 case E_NDS_ARCH_STAR_V2_0
:
2810 case E_NDS_ARCH_STAR_V3_0
:
2811 case E_NDS_ARCH_STAR_V3_M
:
2812 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2816 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2817 /* ARCH version determines how the e_flags are interpreted.
2818 If it is unknown, we cannot proceed. */
2822 /* Newer ABI; Now handle architecture specific flags. */
2823 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2825 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2826 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2828 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2829 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2831 if (config
& E_NDS32_HAS_DIV_INST
)
2832 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2834 if (config
& E_NDS32_HAS_16BIT_INST
)
2835 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2839 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2841 if (version
<= E_NDS32_ELF_VER_1_3
)
2842 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2844 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2847 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2848 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2850 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2851 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2853 if (config
& E_NDS32_HAS_16BIT_INST
)
2855 if (version
<= E_NDS32_ELF_VER_1_3
)
2856 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2858 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2862 if (config
& E_NDS32_HAS_EXT_INST
)
2863 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2865 if (config
& E_NDS32_HAS_EXT2_INST
)
2866 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2868 if (config
& E_NDS32_HAS_FPU_INST
)
2871 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2874 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2877 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2880 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2883 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2888 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2890 case E_NDS32_FPU_REG_8SP_4DP
:
2891 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2893 case E_NDS32_FPU_REG_16SP_8DP
:
2894 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2896 case E_NDS32_FPU_REG_32SP_16DP
:
2897 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2899 case E_NDS32_FPU_REG_32SP_32DP
:
2900 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2905 if (config
& E_NDS32_HAS_AUDIO_INST
)
2906 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2908 if (config
& E_NDS32_HAS_STRING_INST
)
2909 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2911 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2912 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2914 if (config
& E_NDS32_HAS_VIDEO_INST
)
2916 if (version
<= E_NDS32_ELF_VER_1_3
)
2917 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2919 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2922 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2923 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2925 if (config
& E_NDS32_HAS_L2C_INST
)
2926 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2930 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2932 static char buf
[1024];
2943 case EM_ARC_COMPACT2
:
2944 case EM_ARC_COMPACT
:
2945 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2949 decode_ARM_machine_flags (e_flags
, buf
);
2953 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2957 if (e_flags
& EF_BFIN_PIC
)
2958 strcat (buf
, ", PIC");
2960 if (e_flags
& EF_BFIN_FDPIC
)
2961 strcat (buf
, ", FDPIC");
2963 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2964 strcat (buf
, ", code in L1");
2966 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2967 strcat (buf
, ", data in L1");
2972 switch (e_flags
& EF_FRV_CPU_MASK
)
2974 case EF_FRV_CPU_GENERIC
:
2978 strcat (buf
, ", fr???");
2981 case EF_FRV_CPU_FR300
:
2982 strcat (buf
, ", fr300");
2985 case EF_FRV_CPU_FR400
:
2986 strcat (buf
, ", fr400");
2988 case EF_FRV_CPU_FR405
:
2989 strcat (buf
, ", fr405");
2992 case EF_FRV_CPU_FR450
:
2993 strcat (buf
, ", fr450");
2996 case EF_FRV_CPU_FR500
:
2997 strcat (buf
, ", fr500");
2999 case EF_FRV_CPU_FR550
:
3000 strcat (buf
, ", fr550");
3003 case EF_FRV_CPU_SIMPLE
:
3004 strcat (buf
, ", simple");
3006 case EF_FRV_CPU_TOMCAT
:
3007 strcat (buf
, ", tomcat");
3013 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3014 strcat (buf
, ", m68000");
3015 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3016 strcat (buf
, ", cpu32");
3017 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3018 strcat (buf
, ", fido_a");
3021 char const * isa
= _("unknown");
3022 char const * mac
= _("unknown mac");
3023 char const * additional
= NULL
;
3025 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3027 case EF_M68K_CF_ISA_A_NODIV
:
3029 additional
= ", nodiv";
3031 case EF_M68K_CF_ISA_A
:
3034 case EF_M68K_CF_ISA_A_PLUS
:
3037 case EF_M68K_CF_ISA_B_NOUSP
:
3039 additional
= ", nousp";
3041 case EF_M68K_CF_ISA_B
:
3044 case EF_M68K_CF_ISA_C
:
3047 case EF_M68K_CF_ISA_C_NODIV
:
3049 additional
= ", nodiv";
3052 strcat (buf
, ", cf, isa ");
3055 strcat (buf
, additional
);
3056 if (e_flags
& EF_M68K_CF_FLOAT
)
3057 strcat (buf
, ", float");
3058 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3063 case EF_M68K_CF_MAC
:
3066 case EF_M68K_CF_EMAC
:
3069 case EF_M68K_CF_EMAC_B
:
3082 switch (e_flags
& EF_MEP_CPU_MASK
)
3084 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3085 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3086 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3087 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3088 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3089 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3090 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3093 switch (e_flags
& EF_MEP_COP_MASK
)
3095 case EF_MEP_COP_NONE
: break;
3096 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3097 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3098 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3099 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3100 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3103 if (e_flags
& EF_MEP_LIBRARY
)
3104 strcat (buf
, ", Built for Library");
3106 if (e_flags
& EF_MEP_INDEX_MASK
)
3107 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3108 e_flags
& EF_MEP_INDEX_MASK
);
3110 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3111 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3112 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3116 if (e_flags
& EF_PPC_EMB
)
3117 strcat (buf
, ", emb");
3119 if (e_flags
& EF_PPC_RELOCATABLE
)
3120 strcat (buf
, _(", relocatable"));
3122 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3123 strcat (buf
, _(", relocatable-lib"));
3127 if (e_flags
& EF_PPC64_ABI
)
3129 char abi
[] = ", abiv0";
3131 abi
[6] += e_flags
& EF_PPC64_ABI
;
3137 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3138 strcat (buf
, ", RH850 ABI");
3140 if (e_flags
& EF_V800_850E3
)
3141 strcat (buf
, ", V3 architecture");
3143 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3144 strcat (buf
, ", FPU not used");
3146 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3147 strcat (buf
, ", regmode: COMMON");
3149 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3150 strcat (buf
, ", r4 not used");
3152 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3153 strcat (buf
, ", r30 not used");
3155 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3156 strcat (buf
, ", r5 not used");
3158 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3159 strcat (buf
, ", r2 not used");
3161 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3163 switch (e_flags
& - e_flags
)
3165 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3166 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3167 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3168 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3169 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3170 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3171 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3172 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3173 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3174 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3175 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3176 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3183 case EM_CYGNUS_V850
:
3184 switch (e_flags
& EF_V850_ARCH
)
3186 case E_V850E3V5_ARCH
:
3187 strcat (buf
, ", v850e3v5");
3189 case E_V850E2V3_ARCH
:
3190 strcat (buf
, ", v850e2v3");
3193 strcat (buf
, ", v850e2");
3196 strcat (buf
, ", v850e1");
3199 strcat (buf
, ", v850e");
3202 strcat (buf
, ", v850");
3205 strcat (buf
, _(", unknown v850 architecture variant"));
3211 case EM_CYGNUS_M32R
:
3212 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3213 strcat (buf
, ", m32r");
3217 case EM_MIPS_RS3_LE
:
3218 if (e_flags
& EF_MIPS_NOREORDER
)
3219 strcat (buf
, ", noreorder");
3221 if (e_flags
& EF_MIPS_PIC
)
3222 strcat (buf
, ", pic");
3224 if (e_flags
& EF_MIPS_CPIC
)
3225 strcat (buf
, ", cpic");
3227 if (e_flags
& EF_MIPS_UCODE
)
3228 strcat (buf
, ", ugen_reserved");
3230 if (e_flags
& EF_MIPS_ABI2
)
3231 strcat (buf
, ", abi2");
3233 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3234 strcat (buf
, ", odk first");
3236 if (e_flags
& EF_MIPS_32BITMODE
)
3237 strcat (buf
, ", 32bitmode");
3239 if (e_flags
& EF_MIPS_NAN2008
)
3240 strcat (buf
, ", nan2008");
3242 if (e_flags
& EF_MIPS_FP64
)
3243 strcat (buf
, ", fp64");
3245 switch ((e_flags
& EF_MIPS_MACH
))
3247 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3248 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3249 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3250 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3251 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3252 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3253 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3254 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3255 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3256 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3257 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3258 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3259 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3260 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3261 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3262 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3263 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3265 /* We simply ignore the field in this case to avoid confusion:
3266 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3269 default: strcat (buf
, _(", unknown CPU")); break;
3272 switch ((e_flags
& EF_MIPS_ABI
))
3274 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3275 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3276 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3277 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3279 /* We simply ignore the field in this case to avoid confusion:
3280 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3281 This means it is likely to be an o32 file, but not for
3284 default: strcat (buf
, _(", unknown ABI")); break;
3287 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3288 strcat (buf
, ", mdmx");
3290 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3291 strcat (buf
, ", mips16");
3293 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3294 strcat (buf
, ", micromips");
3296 switch ((e_flags
& EF_MIPS_ARCH
))
3298 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3299 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3300 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3301 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3302 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3303 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3304 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3305 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3306 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3307 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3308 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3309 default: strcat (buf
, _(", unknown ISA")); break;
3314 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3318 if (e_flags
& EF_RISCV_RVC
)
3319 strcat (buf
, ", RVC");
3321 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3323 case EF_RISCV_FLOAT_ABI_SOFT
:
3324 strcat (buf
, ", soft-float ABI");
3327 case EF_RISCV_FLOAT_ABI_SINGLE
:
3328 strcat (buf
, ", single-float ABI");
3331 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3332 strcat (buf
, ", double-float ABI");
3335 case EF_RISCV_FLOAT_ABI_QUAD
:
3336 strcat (buf
, ", quad-float ABI");
3342 switch ((e_flags
& EF_SH_MACH_MASK
))
3344 case EF_SH1
: strcat (buf
, ", sh1"); break;
3345 case EF_SH2
: strcat (buf
, ", sh2"); break;
3346 case EF_SH3
: strcat (buf
, ", sh3"); break;
3347 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3348 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3349 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3350 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3351 case EF_SH4
: strcat (buf
, ", sh4"); break;
3352 case EF_SH5
: strcat (buf
, ", sh5"); break;
3353 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3354 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3355 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3356 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3357 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3358 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3359 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3360 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3361 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3362 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3363 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3364 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3365 default: strcat (buf
, _(", unknown ISA")); break;
3368 if (e_flags
& EF_SH_PIC
)
3369 strcat (buf
, ", pic");
3371 if (e_flags
& EF_SH_FDPIC
)
3372 strcat (buf
, ", fdpic");
3376 if (e_flags
& EF_OR1K_NODELAY
)
3377 strcat (buf
, ", no delay");
3381 if (e_flags
& EF_SPARC_32PLUS
)
3382 strcat (buf
, ", v8+");
3384 if (e_flags
& EF_SPARC_SUN_US1
)
3385 strcat (buf
, ", ultrasparcI");
3387 if (e_flags
& EF_SPARC_SUN_US3
)
3388 strcat (buf
, ", ultrasparcIII");
3390 if (e_flags
& EF_SPARC_HAL_R1
)
3391 strcat (buf
, ", halr1");
3393 if (e_flags
& EF_SPARC_LEDATA
)
3394 strcat (buf
, ", ledata");
3396 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3397 strcat (buf
, ", tso");
3399 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3400 strcat (buf
, ", pso");
3402 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3403 strcat (buf
, ", rmo");
3407 switch (e_flags
& EF_PARISC_ARCH
)
3409 case EFA_PARISC_1_0
:
3410 strcpy (buf
, ", PA-RISC 1.0");
3412 case EFA_PARISC_1_1
:
3413 strcpy (buf
, ", PA-RISC 1.1");
3415 case EFA_PARISC_2_0
:
3416 strcpy (buf
, ", PA-RISC 2.0");
3421 if (e_flags
& EF_PARISC_TRAPNIL
)
3422 strcat (buf
, ", trapnil");
3423 if (e_flags
& EF_PARISC_EXT
)
3424 strcat (buf
, ", ext");
3425 if (e_flags
& EF_PARISC_LSB
)
3426 strcat (buf
, ", lsb");
3427 if (e_flags
& EF_PARISC_WIDE
)
3428 strcat (buf
, ", wide");
3429 if (e_flags
& EF_PARISC_NO_KABP
)
3430 strcat (buf
, ", no kabp");
3431 if (e_flags
& EF_PARISC_LAZYSWAP
)
3432 strcat (buf
, ", lazyswap");
3437 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3438 strcat (buf
, ", new calling convention");
3440 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3441 strcat (buf
, ", gnu calling convention");
3445 if ((e_flags
& EF_IA_64_ABI64
))
3446 strcat (buf
, ", 64-bit");
3448 strcat (buf
, ", 32-bit");
3449 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3450 strcat (buf
, ", reduced fp model");
3451 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3452 strcat (buf
, ", no function descriptors, constant gp");
3453 else if ((e_flags
& EF_IA_64_CONS_GP
))
3454 strcat (buf
, ", constant gp");
3455 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3456 strcat (buf
, ", absolute");
3457 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3459 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3460 strcat (buf
, ", vms_linkages");
3461 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3463 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3465 case EF_IA_64_VMS_COMCOD_WARNING
:
3466 strcat (buf
, ", warning");
3468 case EF_IA_64_VMS_COMCOD_ERROR
:
3469 strcat (buf
, ", error");
3471 case EF_IA_64_VMS_COMCOD_ABORT
:
3472 strcat (buf
, ", abort");
3475 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3476 e_flags
& EF_IA_64_VMS_COMCOD
);
3477 strcat (buf
, ", <unknown>");
3483 if ((e_flags
& EF_VAX_NONPIC
))
3484 strcat (buf
, ", non-PIC");
3485 if ((e_flags
& EF_VAX_DFLOAT
))
3486 strcat (buf
, ", D-Float");
3487 if ((e_flags
& EF_VAX_GFLOAT
))
3488 strcat (buf
, ", G-Float");
3492 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3493 strcat (buf
, ", mcm");
3494 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3495 strcat (buf
, ", mcm24");
3496 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3497 strcat (buf
, ", gr6");
3501 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3503 case E_FLAG_RL78_ANY_CPU
: break;
3504 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3505 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3506 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3508 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3509 strcat (buf
, ", 64-bit doubles");
3513 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3514 strcat (buf
, ", 64-bit doubles");
3515 if (e_flags
& E_FLAG_RX_DSP
)
3516 strcat (buf
, ", dsp");
3517 if (e_flags
& E_FLAG_RX_PID
)
3518 strcat (buf
, ", pid");
3519 if (e_flags
& E_FLAG_RX_ABI
)
3520 strcat (buf
, ", RX ABI");
3521 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3522 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3523 ? ", uses String instructions" : ", bans String instructions");
3524 if (e_flags
& E_FLAG_RX_V2
)
3525 strcat (buf
, ", V2");
3529 if (e_flags
& EF_S390_HIGH_GPRS
)
3530 strcat (buf
, ", highgprs");
3534 if ((e_flags
& EF_C6000_REL
))
3535 strcat (buf
, ", relocatable module");
3539 strcat (buf
, _(": architecture variant: "));
3540 switch (e_flags
& EF_MSP430_MACH
)
3542 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3543 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3544 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3545 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3546 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3547 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3548 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3549 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3550 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3551 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3552 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3553 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3554 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3555 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3556 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3558 strcat (buf
, _(": unknown")); break;
3561 if (e_flags
& ~ EF_MSP430_MACH
)
3562 strcat (buf
, _(": unknown extra flag bits also present"));
3570 get_osabi_name (unsigned int osabi
)
3572 static char buff
[32];
3576 case ELFOSABI_NONE
: return "UNIX - System V";
3577 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3578 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3579 case ELFOSABI_GNU
: return "UNIX - GNU";
3580 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3581 case ELFOSABI_AIX
: return "UNIX - AIX";
3582 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3583 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3584 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3585 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3586 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3587 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3588 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3589 case ELFOSABI_AROS
: return "AROS";
3590 case ELFOSABI_FENIXOS
: return "FenixOS";
3591 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3592 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3595 switch (elf_header
.e_machine
)
3600 case ELFOSABI_ARM
: return "ARM";
3611 case ELFOSABI_STANDALONE
: return _("Standalone App");
3620 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3621 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3630 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3636 get_aarch64_segment_type (unsigned long type
)
3640 case PT_AARCH64_ARCHEXT
:
3641 return "AARCH64_ARCHEXT";
3650 get_arm_segment_type (unsigned long type
)
3664 get_mips_segment_type (unsigned long type
)
3668 case PT_MIPS_REGINFO
:
3670 case PT_MIPS_RTPROC
:
3672 case PT_MIPS_OPTIONS
:
3674 case PT_MIPS_ABIFLAGS
:
3684 get_parisc_segment_type (unsigned long type
)
3688 case PT_HP_TLS
: return "HP_TLS";
3689 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3690 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3691 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3692 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3693 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3694 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3695 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3696 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3697 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3698 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3699 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3700 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3701 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3702 case PT_HP_STACK
: return "HP_STACK";
3703 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3704 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3705 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3706 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3715 get_ia64_segment_type (unsigned long type
)
3719 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3720 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3721 case PT_HP_TLS
: return "HP_TLS";
3722 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3723 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3724 case PT_IA_64_HP_STACK
: return "HP_STACK";
3733 get_tic6x_segment_type (unsigned long type
)
3737 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3746 get_solaris_segment_type (unsigned long type
)
3750 case 0x6464e550: return "PT_SUNW_UNWIND";
3751 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3752 case 0x6ffffff7: return "PT_LOSUNW";
3753 case 0x6ffffffa: return "PT_SUNWBSS";
3754 case 0x6ffffffb: return "PT_SUNWSTACK";
3755 case 0x6ffffffc: return "PT_SUNWDTRACE";
3756 case 0x6ffffffd: return "PT_SUNWCAP";
3757 case 0x6fffffff: return "PT_HISUNW";
3758 default: return NULL
;
3763 get_segment_type (unsigned long p_type
)
3765 static char buff
[32];
3769 case PT_NULL
: return "NULL";
3770 case PT_LOAD
: return "LOAD";
3771 case PT_DYNAMIC
: return "DYNAMIC";
3772 case PT_INTERP
: return "INTERP";
3773 case PT_NOTE
: return "NOTE";
3774 case PT_SHLIB
: return "SHLIB";
3775 case PT_PHDR
: return "PHDR";
3776 case PT_TLS
: return "TLS";
3778 case PT_GNU_EH_FRAME
:
3779 return "GNU_EH_FRAME";
3780 case PT_GNU_STACK
: return "GNU_STACK";
3781 case PT_GNU_RELRO
: return "GNU_RELRO";
3784 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3786 const char * result
;
3788 switch (elf_header
.e_machine
)
3791 result
= get_aarch64_segment_type (p_type
);
3794 result
= get_arm_segment_type (p_type
);
3797 case EM_MIPS_RS3_LE
:
3798 result
= get_mips_segment_type (p_type
);
3801 result
= get_parisc_segment_type (p_type
);
3804 result
= get_ia64_segment_type (p_type
);
3807 result
= get_tic6x_segment_type (p_type
);
3817 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3819 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3821 const char * result
;
3823 switch (elf_header
.e_machine
)
3826 result
= get_parisc_segment_type (p_type
);
3829 result
= get_ia64_segment_type (p_type
);
3832 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3833 result
= get_solaris_segment_type (p_type
);
3842 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3845 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3852 get_mips_section_type_name (unsigned int sh_type
)
3856 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3857 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3858 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3859 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3860 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3861 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3862 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3863 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3864 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3865 case SHT_MIPS_RELD
: return "MIPS_RELD";
3866 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3867 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3868 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3869 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3870 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3871 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3872 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3873 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3874 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3875 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3876 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3877 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3878 case SHT_MIPS_LINE
: return "MIPS_LINE";
3879 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3880 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3881 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3882 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3883 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3884 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3885 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3886 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3887 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3888 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3889 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3890 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3891 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3892 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3893 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3894 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3895 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3903 get_parisc_section_type_name (unsigned int sh_type
)
3907 case SHT_PARISC_EXT
: return "PARISC_EXT";
3908 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3909 case SHT_PARISC_DOC
: return "PARISC_DOC";
3910 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3911 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3912 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3913 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3921 get_ia64_section_type_name (unsigned int sh_type
)
3923 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3924 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3925 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3929 case SHT_IA_64_EXT
: return "IA_64_EXT";
3930 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3931 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3932 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3933 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3934 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3935 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3936 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3937 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3938 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3946 get_x86_64_section_type_name (unsigned int sh_type
)
3950 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3958 get_aarch64_section_type_name (unsigned int sh_type
)
3962 case SHT_AARCH64_ATTRIBUTES
:
3963 return "AARCH64_ATTRIBUTES";
3971 get_arm_section_type_name (unsigned int sh_type
)
3975 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3976 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3977 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3978 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3979 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3987 get_tic6x_section_type_name (unsigned int sh_type
)
3991 case SHT_C6000_UNWIND
:
3992 return "C6000_UNWIND";
3993 case SHT_C6000_PREEMPTMAP
:
3994 return "C6000_PREEMPTMAP";
3995 case SHT_C6000_ATTRIBUTES
:
3996 return "C6000_ATTRIBUTES";
4001 case SHT_TI_HANDLER
:
4002 return "TI_HANDLER";
4003 case SHT_TI_INITINFO
:
4004 return "TI_INITINFO";
4005 case SHT_TI_PHATTRS
:
4006 return "TI_PHATTRS";
4014 get_msp430x_section_type_name (unsigned int sh_type
)
4018 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4019 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4020 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4021 default: return NULL
;
4026 get_v850_section_type_name (unsigned int sh_type
)
4030 case SHT_V850_SCOMMON
: return "V850 Small Common";
4031 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4032 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4033 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4034 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4035 default: return NULL
;
4040 get_section_type_name (unsigned int sh_type
)
4042 static char buff
[32];
4043 const char * result
;
4047 case SHT_NULL
: return "NULL";
4048 case SHT_PROGBITS
: return "PROGBITS";
4049 case SHT_SYMTAB
: return "SYMTAB";
4050 case SHT_STRTAB
: return "STRTAB";
4051 case SHT_RELA
: return "RELA";
4052 case SHT_HASH
: return "HASH";
4053 case SHT_DYNAMIC
: return "DYNAMIC";
4054 case SHT_NOTE
: return "NOTE";
4055 case SHT_NOBITS
: return "NOBITS";
4056 case SHT_REL
: return "REL";
4057 case SHT_SHLIB
: return "SHLIB";
4058 case SHT_DYNSYM
: return "DYNSYM";
4059 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4060 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4061 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4062 case SHT_GNU_HASH
: return "GNU_HASH";
4063 case SHT_GROUP
: return "GROUP";
4064 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4065 case SHT_GNU_verdef
: return "VERDEF";
4066 case SHT_GNU_verneed
: return "VERNEED";
4067 case SHT_GNU_versym
: return "VERSYM";
4068 case 0x6ffffff0: return "VERSYM";
4069 case 0x6ffffffc: return "VERDEF";
4070 case 0x7ffffffd: return "AUXILIARY";
4071 case 0x7fffffff: return "FILTER";
4072 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4075 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4077 switch (elf_header
.e_machine
)
4080 case EM_MIPS_RS3_LE
:
4081 result
= get_mips_section_type_name (sh_type
);
4084 result
= get_parisc_section_type_name (sh_type
);
4087 result
= get_ia64_section_type_name (sh_type
);
4092 result
= get_x86_64_section_type_name (sh_type
);
4095 result
= get_aarch64_section_type_name (sh_type
);
4098 result
= get_arm_section_type_name (sh_type
);
4101 result
= get_tic6x_section_type_name (sh_type
);
4104 result
= get_msp430x_section_type_name (sh_type
);
4108 case EM_CYGNUS_V850
:
4109 result
= get_v850_section_type_name (sh_type
);
4119 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4121 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4123 switch (elf_header
.e_machine
)
4126 result
= get_ia64_section_type_name (sh_type
);
4129 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4130 result
= get_solaris_section_type (sh_type
);
4139 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4141 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4143 switch (elf_header
.e_machine
)
4147 case EM_CYGNUS_V850
:
4148 result
= get_v850_section_type_name (sh_type
);
4158 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4161 /* This message is probably going to be displayed in a 15
4162 character wide field, so put the hex value first. */
4163 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4169 #define OPTION_DEBUG_DUMP 512
4170 #define OPTION_DYN_SYMS 513
4171 #define OPTION_DWARF_DEPTH 514
4172 #define OPTION_DWARF_START 515
4173 #define OPTION_DWARF_CHECK 516
4175 static struct option options
[] =
4177 {"all", no_argument
, 0, 'a'},
4178 {"file-header", no_argument
, 0, 'h'},
4179 {"program-headers", no_argument
, 0, 'l'},
4180 {"headers", no_argument
, 0, 'e'},
4181 {"histogram", no_argument
, 0, 'I'},
4182 {"segments", no_argument
, 0, 'l'},
4183 {"sections", no_argument
, 0, 'S'},
4184 {"section-headers", no_argument
, 0, 'S'},
4185 {"section-groups", no_argument
, 0, 'g'},
4186 {"section-details", no_argument
, 0, 't'},
4187 {"full-section-name",no_argument
, 0, 'N'},
4188 {"symbols", no_argument
, 0, 's'},
4189 {"syms", no_argument
, 0, 's'},
4190 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4191 {"relocs", no_argument
, 0, 'r'},
4192 {"notes", no_argument
, 0, 'n'},
4193 {"dynamic", no_argument
, 0, 'd'},
4194 {"arch-specific", no_argument
, 0, 'A'},
4195 {"version-info", no_argument
, 0, 'V'},
4196 {"use-dynamic", no_argument
, 0, 'D'},
4197 {"unwind", no_argument
, 0, 'u'},
4198 {"archive-index", no_argument
, 0, 'c'},
4199 {"hex-dump", required_argument
, 0, 'x'},
4200 {"relocated-dump", required_argument
, 0, 'R'},
4201 {"string-dump", required_argument
, 0, 'p'},
4202 {"decompress", no_argument
, 0, 'z'},
4203 #ifdef SUPPORT_DISASSEMBLY
4204 {"instruction-dump", required_argument
, 0, 'i'},
4206 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4208 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4209 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4210 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4212 {"version", no_argument
, 0, 'v'},
4213 {"wide", no_argument
, 0, 'W'},
4214 {"help", no_argument
, 0, 'H'},
4215 {0, no_argument
, 0, 0}
4219 usage (FILE * stream
)
4221 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4222 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4223 fprintf (stream
, _(" Options are:\n\
4224 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4225 -h --file-header Display the ELF file header\n\
4226 -l --program-headers Display the program headers\n\
4227 --segments An alias for --program-headers\n\
4228 -S --section-headers Display the sections' header\n\
4229 --sections An alias for --section-headers\n\
4230 -g --section-groups Display the section groups\n\
4231 -t --section-details Display the section details\n\
4232 -e --headers Equivalent to: -h -l -S\n\
4233 -s --syms Display the symbol table\n\
4234 --symbols An alias for --syms\n\
4235 --dyn-syms Display the dynamic symbol table\n\
4236 -n --notes Display the core notes (if present)\n\
4237 -r --relocs Display the relocations (if present)\n\
4238 -u --unwind Display the unwind info (if present)\n\
4239 -d --dynamic Display the dynamic section (if present)\n\
4240 -V --version-info Display the version sections (if present)\n\
4241 -A --arch-specific Display architecture specific information (if any)\n\
4242 -c --archive-index Display the symbol/file index in an archive\n\
4243 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4244 -x --hex-dump=<number|name>\n\
4245 Dump the contents of section <number|name> as bytes\n\
4246 -p --string-dump=<number|name>\n\
4247 Dump the contents of section <number|name> as strings\n\
4248 -R --relocated-dump=<number|name>\n\
4249 Dump the contents of section <number|name> as relocated bytes\n\
4250 -z --decompress Decompress section before dumping it\n\
4251 -w[lLiaprmfFsoRt] or\n\
4252 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4253 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4254 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4256 Display the contents of DWARF2 debug sections\n"));
4257 fprintf (stream
, _("\
4258 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4259 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4261 #ifdef SUPPORT_DISASSEMBLY
4262 fprintf (stream
, _("\
4263 -i --instruction-dump=<number|name>\n\
4264 Disassemble the contents of section <number|name>\n"));
4266 fprintf (stream
, _("\
4267 -I --histogram Display histogram of bucket list lengths\n\
4268 -W --wide Allow output width to exceed 80 characters\n\
4269 @<file> Read options from <file>\n\
4270 -H --help Display this information\n\
4271 -v --version Display the version number of readelf\n"));
4273 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4274 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4276 exit (stream
== stdout
? 0 : 1);
4279 /* Record the fact that the user wants the contents of section number
4280 SECTION to be displayed using the method(s) encoded as flags bits
4281 in TYPE. Note, TYPE can be zero if we are creating the array for
4285 request_dump_bynumber (unsigned int section
, dump_type type
)
4287 if (section
>= num_dump_sects
)
4289 dump_type
* new_dump_sects
;
4291 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4292 sizeof (* dump_sects
));
4294 if (new_dump_sects
== NULL
)
4295 error (_("Out of memory allocating dump request table.\n"));
4300 /* Copy current flag settings. */
4301 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4306 dump_sects
= new_dump_sects
;
4307 num_dump_sects
= section
+ 1;
4312 dump_sects
[section
] |= type
;
4317 /* Request a dump by section name. */
4320 request_dump_byname (const char * section
, dump_type type
)
4322 struct dump_list_entry
* new_request
;
4324 new_request
= (struct dump_list_entry
*)
4325 malloc (sizeof (struct dump_list_entry
));
4327 error (_("Out of memory allocating dump request table.\n"));
4329 new_request
->name
= strdup (section
);
4330 if (!new_request
->name
)
4331 error (_("Out of memory allocating dump request table.\n"));
4333 new_request
->type
= type
;
4335 new_request
->next
= dump_sects_byname
;
4336 dump_sects_byname
= new_request
;
4340 request_dump (dump_type type
)
4346 section
= strtoul (optarg
, & cp
, 0);
4348 if (! *cp
&& section
>= 0)
4349 request_dump_bynumber (section
, type
);
4351 request_dump_byname (optarg
, type
);
4356 parse_args (int argc
, char ** argv
)
4363 while ((c
= getopt_long
4364 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4382 do_section_groups
++;
4390 do_section_groups
++;
4395 do_section_details
++;
4439 request_dump (HEX_DUMP
);
4442 request_dump (STRING_DUMP
);
4445 request_dump (RELOC_DUMP
);
4455 dwarf_select_sections_all ();
4460 dwarf_select_sections_by_letters (optarg
);
4463 case OPTION_DEBUG_DUMP
:
4470 dwarf_select_sections_by_names (optarg
);
4473 case OPTION_DWARF_DEPTH
:
4477 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4480 case OPTION_DWARF_START
:
4484 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4487 case OPTION_DWARF_CHECK
:
4490 case OPTION_DYN_SYMS
:
4493 #ifdef SUPPORT_DISASSEMBLY
4495 request_dump (DISASS_DUMP
);
4499 print_version (program_name
);
4508 /* xgettext:c-format */
4509 error (_("Invalid option '-%c'\n"), c
);
4516 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4517 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4518 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4519 && !do_section_groups
&& !do_archive_index
4525 get_elf_class (unsigned int elf_class
)
4527 static char buff
[32];
4531 case ELFCLASSNONE
: return _("none");
4532 case ELFCLASS32
: return "ELF32";
4533 case ELFCLASS64
: return "ELF64";
4535 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4541 get_data_encoding (unsigned int encoding
)
4543 static char buff
[32];
4547 case ELFDATANONE
: return _("none");
4548 case ELFDATA2LSB
: return _("2's complement, little endian");
4549 case ELFDATA2MSB
: return _("2's complement, big endian");
4551 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4556 /* Decode the data held in 'elf_header'. */
4559 process_file_header (void)
4561 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4562 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4563 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4564 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4567 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4571 init_dwarf_regnames (elf_header
.e_machine
);
4577 printf (_("ELF Header:\n"));
4578 printf (_(" Magic: "));
4579 for (i
= 0; i
< EI_NIDENT
; i
++)
4580 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4582 printf (_(" Class: %s\n"),
4583 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4584 printf (_(" Data: %s\n"),
4585 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4586 printf (_(" Version: %d %s\n"),
4587 elf_header
.e_ident
[EI_VERSION
],
4588 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4590 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4591 ? _("<unknown: %lx>")
4593 printf (_(" OS/ABI: %s\n"),
4594 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4595 printf (_(" ABI Version: %d\n"),
4596 elf_header
.e_ident
[EI_ABIVERSION
]);
4597 printf (_(" Type: %s\n"),
4598 get_file_type (elf_header
.e_type
));
4599 printf (_(" Machine: %s\n"),
4600 get_machine_name (elf_header
.e_machine
));
4601 printf (_(" Version: 0x%lx\n"),
4602 (unsigned long) elf_header
.e_version
);
4604 printf (_(" Entry point address: "));
4605 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4606 printf (_("\n Start of program headers: "));
4607 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4608 printf (_(" (bytes into file)\n Start of section headers: "));
4609 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4610 printf (_(" (bytes into file)\n"));
4612 printf (_(" Flags: 0x%lx%s\n"),
4613 (unsigned long) elf_header
.e_flags
,
4614 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4615 printf (_(" Size of this header: %ld (bytes)\n"),
4616 (long) elf_header
.e_ehsize
);
4617 printf (_(" Size of program headers: %ld (bytes)\n"),
4618 (long) elf_header
.e_phentsize
);
4619 printf (_(" Number of program headers: %ld"),
4620 (long) elf_header
.e_phnum
);
4621 if (section_headers
!= NULL
4622 && elf_header
.e_phnum
== PN_XNUM
4623 && section_headers
[0].sh_info
!= 0)
4624 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4625 putc ('\n', stdout
);
4626 printf (_(" Size of section headers: %ld (bytes)\n"),
4627 (long) elf_header
.e_shentsize
);
4628 printf (_(" Number of section headers: %ld"),
4629 (long) elf_header
.e_shnum
);
4630 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4631 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4632 putc ('\n', stdout
);
4633 printf (_(" Section header string table index: %ld"),
4634 (long) elf_header
.e_shstrndx
);
4635 if (section_headers
!= NULL
4636 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4637 printf (" (%u)", section_headers
[0].sh_link
);
4638 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4639 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4640 printf (_(" <corrupt: out of range>"));
4641 putc ('\n', stdout
);
4644 if (section_headers
!= NULL
)
4646 if (elf_header
.e_phnum
== PN_XNUM
4647 && section_headers
[0].sh_info
!= 0)
4648 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4649 if (elf_header
.e_shnum
== SHN_UNDEF
)
4650 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4651 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4652 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4653 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4654 elf_header
.e_shstrndx
= SHN_UNDEF
;
4655 free (section_headers
);
4656 section_headers
= NULL
;
4663 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4665 Elf32_External_Phdr
* phdrs
;
4666 Elf32_External_Phdr
* external
;
4667 Elf_Internal_Phdr
* internal
;
4669 unsigned int size
= elf_header
.e_phentsize
;
4670 unsigned int num
= elf_header
.e_phnum
;
4672 /* PR binutils/17531: Cope with unexpected section header sizes. */
4673 if (size
== 0 || num
== 0)
4675 if (size
< sizeof * phdrs
)
4677 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4680 if (size
> sizeof * phdrs
)
4681 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4683 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4684 size
, num
, _("program headers"));
4688 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4689 i
< elf_header
.e_phnum
;
4690 i
++, internal
++, external
++)
4692 internal
->p_type
= BYTE_GET (external
->p_type
);
4693 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4694 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4695 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4696 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4697 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4698 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4699 internal
->p_align
= BYTE_GET (external
->p_align
);
4707 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4709 Elf64_External_Phdr
* phdrs
;
4710 Elf64_External_Phdr
* external
;
4711 Elf_Internal_Phdr
* internal
;
4713 unsigned int size
= elf_header
.e_phentsize
;
4714 unsigned int num
= elf_header
.e_phnum
;
4716 /* PR binutils/17531: Cope with unexpected section header sizes. */
4717 if (size
== 0 || num
== 0)
4719 if (size
< sizeof * phdrs
)
4721 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4724 if (size
> sizeof * phdrs
)
4725 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4727 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4728 size
, num
, _("program headers"));
4732 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4733 i
< elf_header
.e_phnum
;
4734 i
++, internal
++, external
++)
4736 internal
->p_type
= BYTE_GET (external
->p_type
);
4737 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4738 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4739 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4740 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4741 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4742 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4743 internal
->p_align
= BYTE_GET (external
->p_align
);
4750 /* Returns 1 if the program headers were read into `program_headers'. */
4753 get_program_headers (FILE * file
)
4755 Elf_Internal_Phdr
* phdrs
;
4757 /* Check cache of prior read. */
4758 if (program_headers
!= NULL
)
4761 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4762 sizeof (Elf_Internal_Phdr
));
4766 error (_("Out of memory reading %u program headers\n"),
4767 elf_header
.e_phnum
);
4772 ? get_32bit_program_headers (file
, phdrs
)
4773 : get_64bit_program_headers (file
, phdrs
))
4775 program_headers
= phdrs
;
4783 /* Returns 1 if the program headers were loaded. */
4786 process_program_headers (FILE * file
)
4788 Elf_Internal_Phdr
* segment
;
4790 Elf_Internal_Phdr
* previous_load
= NULL
;
4792 if (elf_header
.e_phnum
== 0)
4794 /* PR binutils/12467. */
4795 if (elf_header
.e_phoff
!= 0)
4796 warn (_("possibly corrupt ELF header - it has a non-zero program"
4797 " header offset, but no program headers\n"));
4798 else if (do_segments
)
4799 printf (_("\nThere are no program headers in this file.\n"));
4803 if (do_segments
&& !do_header
)
4805 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4806 printf (_("Entry point "));
4807 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4808 printf (_("\nThere are %d program headers, starting at offset "),
4809 elf_header
.e_phnum
);
4810 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4814 if (! get_program_headers (file
))
4819 if (elf_header
.e_phnum
> 1)
4820 printf (_("\nProgram Headers:\n"));
4822 printf (_("\nProgram Headers:\n"));
4826 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4829 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4833 (_(" Type Offset VirtAddr PhysAddr\n"));
4835 (_(" FileSiz MemSiz Flags Align\n"));
4842 for (i
= 0, segment
= program_headers
;
4843 i
< elf_header
.e_phnum
;
4848 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4852 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4853 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4854 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4855 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4856 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4858 (segment
->p_flags
& PF_R
? 'R' : ' '),
4859 (segment
->p_flags
& PF_W
? 'W' : ' '),
4860 (segment
->p_flags
& PF_X
? 'E' : ' '));
4861 printf ("%#lx", (unsigned long) segment
->p_align
);
4865 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4866 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4869 print_vma (segment
->p_offset
, FULL_HEX
);
4873 print_vma (segment
->p_vaddr
, FULL_HEX
);
4875 print_vma (segment
->p_paddr
, FULL_HEX
);
4878 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4879 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4882 print_vma (segment
->p_filesz
, FULL_HEX
);
4886 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4887 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4890 print_vma (segment
->p_memsz
, FULL_HEX
);
4894 (segment
->p_flags
& PF_R
? 'R' : ' '),
4895 (segment
->p_flags
& PF_W
? 'W' : ' '),
4896 (segment
->p_flags
& PF_X
? 'E' : ' '));
4898 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4899 printf ("%#lx", (unsigned long) segment
->p_align
);
4902 print_vma (segment
->p_align
, PREFIX_HEX
);
4907 print_vma (segment
->p_offset
, FULL_HEX
);
4909 print_vma (segment
->p_vaddr
, FULL_HEX
);
4911 print_vma (segment
->p_paddr
, FULL_HEX
);
4913 print_vma (segment
->p_filesz
, FULL_HEX
);
4915 print_vma (segment
->p_memsz
, FULL_HEX
);
4917 (segment
->p_flags
& PF_R
? 'R' : ' '),
4918 (segment
->p_flags
& PF_W
? 'W' : ' '),
4919 (segment
->p_flags
& PF_X
? 'E' : ' '));
4920 print_vma (segment
->p_align
, PREFIX_HEX
);
4923 putc ('\n', stdout
);
4926 switch (segment
->p_type
)
4929 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4930 required by the ELF standard, several programs, including the Linux
4931 kernel, make use of non-ordered segments. */
4933 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4934 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4936 if (segment
->p_memsz
< segment
->p_filesz
)
4937 error (_("the segment's file size is larger than its memory size\n"));
4938 previous_load
= segment
;
4942 /* PR 20815 - Verify that the program header is loaded into memory. */
4943 if (i
> 0 && previous_load
!= NULL
)
4944 error (_("the PHDR segment must occur before any LOAD segment\n"));
4945 if (elf_header
.e_machine
!= EM_PARISC
)
4949 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4950 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4951 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4952 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4954 if (j
== elf_header
.e_phnum
)
4955 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4961 error (_("more than one dynamic segment\n"));
4963 /* By default, assume that the .dynamic section is the first
4964 section in the DYNAMIC segment. */
4965 dynamic_addr
= segment
->p_offset
;
4966 dynamic_size
= segment
->p_filesz
;
4967 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4968 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4970 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4971 dynamic_addr
= dynamic_size
= 0;
4974 /* Try to locate the .dynamic section. If there is
4975 a section header table, we can easily locate it. */
4976 if (section_headers
!= NULL
)
4978 Elf_Internal_Shdr
* sec
;
4980 sec
= find_section (".dynamic");
4981 if (sec
== NULL
|| sec
->sh_size
== 0)
4983 /* A corresponding .dynamic section is expected, but on
4984 IA-64/OpenVMS it is OK for it to be missing. */
4985 if (!is_ia64_vms ())
4986 error (_("no .dynamic section in the dynamic segment\n"));
4990 if (sec
->sh_type
== SHT_NOBITS
)
4996 dynamic_addr
= sec
->sh_offset
;
4997 dynamic_size
= sec
->sh_size
;
4999 if (dynamic_addr
< segment
->p_offset
5000 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5001 warn (_("the .dynamic section is not contained"
5002 " within the dynamic segment\n"));
5003 else if (dynamic_addr
> segment
->p_offset
)
5004 warn (_("the .dynamic section is not the first section"
5005 " in the dynamic segment.\n"));
5010 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5012 error (_("Unable to find program interpreter name\n"));
5016 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5018 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5019 error (_("Internal error: failed to create format string to display program interpreter\n"));
5021 program_interpreter
[0] = 0;
5022 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5023 error (_("Unable to read program interpreter name\n"));
5026 printf (_(" [Requesting program interpreter: %s]\n"),
5027 program_interpreter
);
5033 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5035 printf (_("\n Section to Segment mapping:\n"));
5036 printf (_(" Segment Sections...\n"));
5038 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5041 Elf_Internal_Shdr
* section
;
5043 segment
= program_headers
+ i
;
5044 section
= section_headers
+ 1;
5046 printf (" %2.2d ", i
);
5048 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5050 if (!ELF_TBSS_SPECIAL (section
, segment
)
5051 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5052 printf ("%s ", printable_section_name (section
));
5063 /* Find the file offset corresponding to VMA by using the program headers. */
5066 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5068 Elf_Internal_Phdr
* seg
;
5070 if (! get_program_headers (file
))
5072 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5076 for (seg
= program_headers
;
5077 seg
< program_headers
+ elf_header
.e_phnum
;
5080 if (seg
->p_type
!= PT_LOAD
)
5083 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5084 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5085 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5088 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5089 (unsigned long) vma
);
5094 /* Allocate memory and load the sections headers into the global pointer
5095 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5096 generate any error messages if the load fails. */
5099 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5101 Elf32_External_Shdr
* shdrs
;
5102 Elf_Internal_Shdr
* internal
;
5104 unsigned int size
= elf_header
.e_shentsize
;
5105 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5107 /* PR binutils/17531: Cope with unexpected section header sizes. */
5108 if (size
== 0 || num
== 0)
5110 if (size
< sizeof * shdrs
)
5113 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5116 if (!probe
&& size
> sizeof * shdrs
)
5117 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5119 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5121 probe
? NULL
: _("section headers"));
5125 if (section_headers
!= NULL
)
5126 free (section_headers
);
5127 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5128 sizeof (Elf_Internal_Shdr
));
5129 if (section_headers
== NULL
)
5132 error (_("Out of memory reading %u section headers\n"), num
);
5136 for (i
= 0, internal
= section_headers
;
5140 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5141 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5142 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5143 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5144 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5145 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5146 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5147 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5148 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5149 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5150 if (!probe
&& internal
->sh_link
> num
)
5151 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5152 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5153 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5161 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5163 Elf64_External_Shdr
* shdrs
;
5164 Elf_Internal_Shdr
* internal
;
5166 unsigned int size
= elf_header
.e_shentsize
;
5167 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5169 /* PR binutils/17531: Cope with unexpected section header sizes. */
5170 if (size
== 0 || num
== 0)
5172 if (size
< sizeof * shdrs
)
5175 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5178 if (! probe
&& size
> sizeof * shdrs
)
5179 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5181 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5183 probe
? NULL
: _("section headers"));
5187 if (section_headers
!= NULL
)
5188 free (section_headers
);
5189 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5190 sizeof (Elf_Internal_Shdr
));
5191 if (section_headers
== NULL
)
5194 error (_("Out of memory reading %u section headers\n"), num
);
5198 for (i
= 0, internal
= section_headers
;
5202 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5203 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5204 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5205 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5206 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5207 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5208 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5209 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5210 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5211 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5212 if (!probe
&& internal
->sh_link
> num
)
5213 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5214 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5215 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5222 static Elf_Internal_Sym
*
5223 get_32bit_elf_symbols (FILE * file
,
5224 Elf_Internal_Shdr
* section
,
5225 unsigned long * num_syms_return
)
5227 unsigned long number
= 0;
5228 Elf32_External_Sym
* esyms
= NULL
;
5229 Elf_External_Sym_Shndx
* shndx
= NULL
;
5230 Elf_Internal_Sym
* isyms
= NULL
;
5231 Elf_Internal_Sym
* psym
;
5234 if (section
->sh_size
== 0)
5236 if (num_syms_return
!= NULL
)
5237 * num_syms_return
= 0;
5241 /* Run some sanity checks first. */
5242 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5244 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5245 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5249 if (section
->sh_size
> current_file_size
)
5251 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5252 printable_section_name (section
), (unsigned long) section
->sh_size
);
5256 number
= section
->sh_size
/ section
->sh_entsize
;
5258 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5260 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5261 (unsigned long) section
->sh_size
,
5262 printable_section_name (section
),
5263 (unsigned long) section
->sh_entsize
);
5267 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5268 section
->sh_size
, _("symbols"));
5273 elf_section_list
* entry
;
5276 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5277 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5279 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5280 entry
->hdr
->sh_offset
,
5281 1, entry
->hdr
->sh_size
,
5282 _("symbol table section indicies"));
5285 /* PR17531: file: heap-buffer-overflow */
5286 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5288 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5289 printable_section_name (entry
->hdr
),
5290 (unsigned long) entry
->hdr
->sh_size
,
5291 (unsigned long) section
->sh_size
);
5297 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5301 error (_("Out of memory reading %lu symbols\n"),
5302 (unsigned long) number
);
5306 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5308 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5309 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5310 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5311 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5312 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5314 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5315 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5316 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5317 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5318 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5327 if (num_syms_return
!= NULL
)
5328 * num_syms_return
= isyms
== NULL
? 0 : number
;
5333 static Elf_Internal_Sym
*
5334 get_64bit_elf_symbols (FILE * file
,
5335 Elf_Internal_Shdr
* section
,
5336 unsigned long * num_syms_return
)
5338 unsigned long number
= 0;
5339 Elf64_External_Sym
* esyms
= NULL
;
5340 Elf_External_Sym_Shndx
* shndx
= NULL
;
5341 Elf_Internal_Sym
* isyms
= NULL
;
5342 Elf_Internal_Sym
* psym
;
5345 if (section
->sh_size
== 0)
5347 if (num_syms_return
!= NULL
)
5348 * num_syms_return
= 0;
5352 /* Run some sanity checks first. */
5353 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5355 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5356 printable_section_name (section
),
5357 (unsigned long) section
->sh_entsize
);
5361 if (section
->sh_size
> current_file_size
)
5363 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5364 printable_section_name (section
),
5365 (unsigned long) section
->sh_size
);
5369 number
= section
->sh_size
/ section
->sh_entsize
;
5371 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5373 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5374 (unsigned long) section
->sh_size
,
5375 printable_section_name (section
),
5376 (unsigned long) section
->sh_entsize
);
5380 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5381 section
->sh_size
, _("symbols"));
5386 elf_section_list
* entry
;
5389 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5390 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5392 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5393 entry
->hdr
->sh_offset
,
5394 1, entry
->hdr
->sh_size
,
5395 _("symbol table section indicies"));
5398 /* PR17531: file: heap-buffer-overflow */
5399 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5401 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5402 printable_section_name (entry
->hdr
),
5403 (unsigned long) entry
->hdr
->sh_size
,
5404 (unsigned long) section
->sh_size
);
5410 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5414 error (_("Out of memory reading %lu symbols\n"),
5415 (unsigned long) number
);
5419 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5421 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5422 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5423 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5424 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5426 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5428 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5429 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5430 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5432 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5433 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5442 if (num_syms_return
!= NULL
)
5443 * num_syms_return
= isyms
== NULL
? 0 : number
;
5449 get_elf_section_flags (bfd_vma sh_flags
)
5451 static char buff
[1024];
5453 int field_size
= is_32bit_elf
? 8 : 16;
5455 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5456 bfd_vma os_flags
= 0;
5457 bfd_vma proc_flags
= 0;
5458 bfd_vma unknown_flags
= 0;
5466 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5467 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5468 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5469 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5470 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5471 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5472 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5473 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5474 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5475 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5476 /* IA-64 specific. */
5477 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5478 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5479 /* IA-64 OpenVMS specific. */
5480 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5481 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5482 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5483 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5484 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5485 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5487 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5488 /* SPARC specific. */
5489 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5490 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5492 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5493 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5494 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5497 if (do_section_details
)
5499 sprintf (buff
, "[%*.*lx]: ",
5500 field_size
, field_size
, (unsigned long) sh_flags
);
5501 p
+= field_size
+ 4;
5508 flag
= sh_flags
& - sh_flags
;
5511 if (do_section_details
)
5515 case SHF_WRITE
: sindex
= 0; break;
5516 case SHF_ALLOC
: sindex
= 1; break;
5517 case SHF_EXECINSTR
: sindex
= 2; break;
5518 case SHF_MERGE
: sindex
= 3; break;
5519 case SHF_STRINGS
: sindex
= 4; break;
5520 case SHF_INFO_LINK
: sindex
= 5; break;
5521 case SHF_LINK_ORDER
: sindex
= 6; break;
5522 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5523 case SHF_GROUP
: sindex
= 8; break;
5524 case SHF_TLS
: sindex
= 9; break;
5525 case SHF_EXCLUDE
: sindex
= 18; break;
5526 case SHF_COMPRESSED
: sindex
= 20; break;
5530 switch (elf_header
.e_machine
)
5533 if (flag
== SHF_IA_64_SHORT
)
5535 else if (flag
== SHF_IA_64_NORECOV
)
5538 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5541 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5542 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5543 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5544 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5545 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5546 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5557 case EM_OLD_SPARCV9
:
5558 case EM_SPARC32PLUS
:
5561 if (flag
== SHF_ORDERED
)
5568 case SHF_ENTRYSECT
: sindex
= 21; break;
5569 case SHF_ARM_PURECODE
: sindex
= 22; break;
5570 case SHF_COMDEF
: sindex
= 23; break;
5582 if (p
!= buff
+ field_size
+ 4)
5584 if (size
< (10 + 2))
5586 warn (_("Internal error: not enough buffer room for section flag info"));
5587 return _("<unknown>");
5594 size
-= flags
[sindex
].len
;
5595 p
= stpcpy (p
, flags
[sindex
].str
);
5597 else if (flag
& SHF_MASKOS
)
5599 else if (flag
& SHF_MASKPROC
)
5602 unknown_flags
|= flag
;
5608 case SHF_WRITE
: *p
= 'W'; break;
5609 case SHF_ALLOC
: *p
= 'A'; break;
5610 case SHF_EXECINSTR
: *p
= 'X'; break;
5611 case SHF_MERGE
: *p
= 'M'; break;
5612 case SHF_STRINGS
: *p
= 'S'; break;
5613 case SHF_INFO_LINK
: *p
= 'I'; break;
5614 case SHF_LINK_ORDER
: *p
= 'L'; break;
5615 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5616 case SHF_GROUP
: *p
= 'G'; break;
5617 case SHF_TLS
: *p
= 'T'; break;
5618 case SHF_EXCLUDE
: *p
= 'E'; break;
5619 case SHF_COMPRESSED
: *p
= 'C'; break;
5622 if ((elf_header
.e_machine
== EM_X86_64
5623 || elf_header
.e_machine
== EM_L1OM
5624 || elf_header
.e_machine
== EM_K1OM
)
5625 && flag
== SHF_X86_64_LARGE
)
5627 else if (elf_header
.e_machine
== EM_ARM
5628 && flag
== SHF_ARM_PURECODE
)
5630 else if (flag
& SHF_MASKOS
)
5633 sh_flags
&= ~ SHF_MASKOS
;
5635 else if (flag
& SHF_MASKPROC
)
5638 sh_flags
&= ~ SHF_MASKPROC
;
5648 if (do_section_details
)
5652 size
-= 5 + field_size
;
5653 if (p
!= buff
+ field_size
+ 4)
5657 warn (_("Internal error: not enough buffer room for section flag info"));
5658 return _("<unknown>");
5664 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5665 (unsigned long) os_flags
);
5666 p
+= 5 + field_size
;
5670 size
-= 7 + field_size
;
5671 if (p
!= buff
+ field_size
+ 4)
5675 warn (_("Internal error: not enough buffer room for section flag info"));
5676 return _("<unknown>");
5682 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5683 (unsigned long) proc_flags
);
5684 p
+= 7 + field_size
;
5688 size
-= 10 + field_size
;
5689 if (p
!= buff
+ field_size
+ 4)
5693 warn (_("Internal error: not enough buffer room for section flag info"));
5694 return _("<unknown>");
5700 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5701 (unsigned long) unknown_flags
);
5702 p
+= 10 + field_size
;
5711 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5715 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5717 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5718 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5719 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5720 return sizeof (*echdr
);
5724 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5726 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5727 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5728 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5729 return sizeof (*echdr
);
5734 process_section_headers (FILE * file
)
5736 Elf_Internal_Shdr
* section
;
5739 section_headers
= NULL
;
5741 if (elf_header
.e_shnum
== 0)
5743 /* PR binutils/12467. */
5744 if (elf_header
.e_shoff
!= 0)
5745 warn (_("possibly corrupt ELF file header - it has a non-zero"
5746 " section header offset, but no section headers\n"));
5747 else if (do_sections
)
5748 printf (_("\nThere are no sections in this file.\n"));
5753 if (do_sections
&& !do_header
)
5754 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5755 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5759 if (! get_32bit_section_headers (file
, FALSE
))
5762 else if (! get_64bit_section_headers (file
, FALSE
))
5765 /* Read in the string table, so that we have names to display. */
5766 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5767 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5769 section
= section_headers
+ elf_header
.e_shstrndx
;
5771 if (section
->sh_size
!= 0)
5773 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5774 1, section
->sh_size
,
5777 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5781 /* Scan the sections for the dynamic symbol table
5782 and dynamic string table and debug sections. */
5783 dynamic_symbols
= NULL
;
5784 dynamic_strings
= NULL
;
5785 dynamic_syminfo
= NULL
;
5786 symtab_shndx_list
= NULL
;
5788 eh_addr_size
= is_32bit_elf
? 4 : 8;
5789 switch (elf_header
.e_machine
)
5792 case EM_MIPS_RS3_LE
:
5793 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5794 FDE addresses. However, the ABI also has a semi-official ILP32
5795 variant for which the normal FDE address size rules apply.
5797 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5798 section, where XX is the size of longs in bits. Unfortunately,
5799 earlier compilers provided no way of distinguishing ILP32 objects
5800 from LP64 objects, so if there's any doubt, we should assume that
5801 the official LP64 form is being used. */
5802 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5803 && find_section (".gcc_compiled_long32") == NULL
)
5809 switch (elf_header
.e_flags
& EF_H8_MACH
)
5811 case E_H8_MACH_H8300
:
5812 case E_H8_MACH_H8300HN
:
5813 case E_H8_MACH_H8300SN
:
5814 case E_H8_MACH_H8300SXN
:
5817 case E_H8_MACH_H8300H
:
5818 case E_H8_MACH_H8300S
:
5819 case E_H8_MACH_H8300SX
:
5827 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5829 case EF_M32C_CPU_M16C
:
5836 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5839 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5840 if (section->sh_entsize != expected_entsize) \
5843 sprintf_vma (buf, section->sh_entsize); \
5844 /* Note: coded this way so that there is a single string for \
5846 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5847 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5848 (unsigned) expected_entsize); \
5849 section->sh_entsize = expected_entsize; \
5854 #define CHECK_ENTSIZE(section, i, type) \
5855 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5856 sizeof (Elf64_External_##type))
5858 for (i
= 0, section
= section_headers
;
5859 i
< elf_header
.e_shnum
;
5862 char * name
= SECTION_NAME (section
);
5864 if (section
->sh_type
== SHT_DYNSYM
)
5866 if (dynamic_symbols
!= NULL
)
5868 error (_("File contains multiple dynamic symbol tables\n"));
5872 CHECK_ENTSIZE (section
, i
, Sym
);
5873 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5875 else if (section
->sh_type
== SHT_STRTAB
5876 && streq (name
, ".dynstr"))
5878 if (dynamic_strings
!= NULL
)
5880 error (_("File contains multiple dynamic string tables\n"));
5884 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5885 1, section
->sh_size
,
5886 _("dynamic strings"));
5887 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5889 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5891 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5892 entry
->hdr
= section
;
5893 entry
->next
= symtab_shndx_list
;
5894 symtab_shndx_list
= entry
;
5896 else if (section
->sh_type
== SHT_SYMTAB
)
5897 CHECK_ENTSIZE (section
, i
, Sym
);
5898 else if (section
->sh_type
== SHT_GROUP
)
5899 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5900 else if (section
->sh_type
== SHT_REL
)
5901 CHECK_ENTSIZE (section
, i
, Rel
);
5902 else if (section
->sh_type
== SHT_RELA
)
5903 CHECK_ENTSIZE (section
, i
, Rela
);
5904 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5905 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5906 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5907 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5908 || do_debug_addr
|| do_debug_cu_index
)
5909 && (const_strneq (name
, ".debug_")
5910 || const_strneq (name
, ".zdebug_")))
5913 name
+= sizeof (".zdebug_") - 1;
5915 name
+= sizeof (".debug_") - 1;
5918 || (do_debug_info
&& const_strneq (name
, "info"))
5919 || (do_debug_info
&& const_strneq (name
, "types"))
5920 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5921 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5922 || (do_debug_lines
&& const_strneq (name
, "line."))
5923 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5924 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5925 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5926 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5927 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5928 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5929 || (do_debug_frames
&& const_strneq (name
, "frame"))
5930 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5931 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5932 || (do_debug_str
&& const_strneq (name
, "str"))
5933 || (do_debug_loc
&& const_strneq (name
, "loc"))
5934 || (do_debug_addr
&& const_strneq (name
, "addr"))
5935 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5936 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5938 request_dump_bynumber (i
, DEBUG_DUMP
);
5940 /* Linkonce section to be combined with .debug_info at link time. */
5941 else if ((do_debugging
|| do_debug_info
)
5942 && const_strneq (name
, ".gnu.linkonce.wi."))
5943 request_dump_bynumber (i
, DEBUG_DUMP
);
5944 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5945 request_dump_bynumber (i
, DEBUG_DUMP
);
5946 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5947 request_dump_bynumber (i
, DEBUG_DUMP
);
5948 /* Trace sections for Itanium VMS. */
5949 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5950 || do_trace_aranges
)
5951 && const_strneq (name
, ".trace_"))
5953 name
+= sizeof (".trace_") - 1;
5956 || (do_trace_info
&& streq (name
, "info"))
5957 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5958 || (do_trace_aranges
&& streq (name
, "aranges"))
5960 request_dump_bynumber (i
, DEBUG_DUMP
);
5967 if (elf_header
.e_shnum
> 1)
5968 printf (_("\nSection Headers:\n"));
5970 printf (_("\nSection Header:\n"));
5974 if (do_section_details
)
5976 printf (_(" [Nr] Name\n"));
5977 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5981 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5985 if (do_section_details
)
5987 printf (_(" [Nr] Name\n"));
5988 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5992 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5996 if (do_section_details
)
5998 printf (_(" [Nr] Name\n"));
5999 printf (_(" Type Address Offset Link\n"));
6000 printf (_(" Size EntSize Info Align\n"));
6004 printf (_(" [Nr] Name Type Address Offset\n"));
6005 printf (_(" Size EntSize Flags Link Info Align\n"));
6009 if (do_section_details
)
6010 printf (_(" Flags\n"));
6012 for (i
= 0, section
= section_headers
;
6013 i
< elf_header
.e_shnum
;
6016 /* Run some sanity checks on the section header. */
6018 /* Check the sh_link field. */
6019 switch (section
->sh_type
)
6021 case SHT_SYMTAB_SHNDX
:
6025 case SHT_GNU_versym
:
6028 if (section
->sh_link
< 1
6029 || section
->sh_link
>= elf_header
.e_shnum
6030 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6031 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6032 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6033 i
, section
->sh_link
);
6039 case SHT_GNU_verneed
:
6040 case SHT_GNU_verdef
:
6041 case SHT_GNU_LIBLIST
:
6042 if (section
->sh_link
< 1
6043 || section
->sh_link
>= elf_header
.e_shnum
6044 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6045 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6046 i
, section
->sh_link
);
6049 case SHT_INIT_ARRAY
:
6050 case SHT_FINI_ARRAY
:
6051 case SHT_PREINIT_ARRAY
:
6052 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6053 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6054 i
, section
->sh_link
);
6058 /* FIXME: Add support for target specific section types. */
6059 #if 0 /* Currently we do not check other section types as there are too
6060 many special cases. Stab sections for example have a type
6061 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6063 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6064 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6065 i
, section
->sh_link
);
6070 /* Check the sh_info field. */
6071 switch (section
->sh_type
)
6075 if (section
->sh_info
< 1
6076 || section
->sh_info
>= elf_header
.e_shnum
6077 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6078 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6079 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6080 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6081 /* FIXME: Are other section types valid ? */
6082 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6084 if (section
->sh_info
== 0
6085 && (streq (SECTION_NAME (section
), ".rel.dyn")
6086 || streq (SECTION_NAME (section
), ".rela.dyn")))
6087 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6088 of zero. No idea why. I would have expected the index
6089 of the .plt section. */
6092 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6093 i
, section
->sh_info
);
6099 case SHT_SYMTAB_SHNDX
:
6100 case SHT_INIT_ARRAY
:
6101 case SHT_FINI_ARRAY
:
6102 case SHT_PREINIT_ARRAY
:
6103 if (section
->sh_info
!= 0)
6104 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6105 i
, section
->sh_info
);
6111 /* A symbol index - we assume that it is valid. */
6115 /* FIXME: Add support for target specific section types. */
6116 if (section
->sh_type
== SHT_NOBITS
)
6117 /* NOBITS section headers with non-zero sh_info fields can be
6118 created when a binary is stripped of everything but its debug
6119 information. The stripped sections have their headers
6120 preserved but their types set to SHT_NOBITS. So do not check
6121 this type of section. */
6123 else if (section
->sh_flags
& SHF_INFO_LINK
)
6125 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6126 warn (_("[%2u]: Expected link to another section in info field"), i
);
6128 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6129 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6130 i
, section
->sh_info
);
6134 printf (" [%2u] ", i
);
6135 if (do_section_details
)
6136 printf ("%s\n ", printable_section_name (section
));
6138 print_symbol (-17, SECTION_NAME (section
));
6140 printf (do_wide
? " %-15s " : " %-15.15s ",
6141 get_section_type_name (section
->sh_type
));
6145 const char * link_too_big
= NULL
;
6147 print_vma (section
->sh_addr
, LONG_HEX
);
6149 printf ( " %6.6lx %6.6lx %2.2lx",
6150 (unsigned long) section
->sh_offset
,
6151 (unsigned long) section
->sh_size
,
6152 (unsigned long) section
->sh_entsize
);
6154 if (do_section_details
)
6155 fputs (" ", stdout
);
6157 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6159 if (section
->sh_link
>= elf_header
.e_shnum
)
6162 /* The sh_link value is out of range. Normally this indicates
6163 an error but it can have special values in Solaris binaries. */
6164 switch (elf_header
.e_machine
)
6171 case EM_OLD_SPARCV9
:
6172 case EM_SPARC32PLUS
:
6175 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6176 link_too_big
= "BEFORE";
6177 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6178 link_too_big
= "AFTER";
6185 if (do_section_details
)
6187 if (link_too_big
!= NULL
&& * link_too_big
)
6188 printf ("<%s> ", link_too_big
);
6190 printf ("%2u ", section
->sh_link
);
6191 printf ("%3u %2lu\n", section
->sh_info
,
6192 (unsigned long) section
->sh_addralign
);
6195 printf ("%2u %3u %2lu\n",
6198 (unsigned long) section
->sh_addralign
);
6200 if (link_too_big
&& ! * link_too_big
)
6201 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6202 i
, section
->sh_link
);
6206 print_vma (section
->sh_addr
, LONG_HEX
);
6208 if ((long) section
->sh_offset
== section
->sh_offset
)
6209 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6213 print_vma (section
->sh_offset
, LONG_HEX
);
6216 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6217 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6221 print_vma (section
->sh_size
, LONG_HEX
);
6224 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6225 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6229 print_vma (section
->sh_entsize
, LONG_HEX
);
6232 if (do_section_details
)
6233 fputs (" ", stdout
);
6235 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6237 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6239 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6240 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6243 print_vma (section
->sh_addralign
, DEC
);
6247 else if (do_section_details
)
6249 printf (" %-15.15s ",
6250 get_section_type_name (section
->sh_type
));
6251 print_vma (section
->sh_addr
, LONG_HEX
);
6252 if ((long) section
->sh_offset
== section
->sh_offset
)
6253 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6257 print_vma (section
->sh_offset
, LONG_HEX
);
6259 printf (" %u\n ", section
->sh_link
);
6260 print_vma (section
->sh_size
, LONG_HEX
);
6262 print_vma (section
->sh_entsize
, LONG_HEX
);
6264 printf (" %-16u %lu\n",
6266 (unsigned long) section
->sh_addralign
);
6271 print_vma (section
->sh_addr
, LONG_HEX
);
6272 if ((long) section
->sh_offset
== section
->sh_offset
)
6273 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6277 print_vma (section
->sh_offset
, LONG_HEX
);
6280 print_vma (section
->sh_size
, LONG_HEX
);
6282 print_vma (section
->sh_entsize
, LONG_HEX
);
6284 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6286 printf (" %2u %3u %lu\n",
6289 (unsigned long) section
->sh_addralign
);
6292 if (do_section_details
)
6294 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6295 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6297 /* Minimum section size is 12 bytes for 32-bit compression
6298 header + 12 bytes for compressed data header. */
6299 unsigned char buf
[24];
6301 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6302 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6303 sizeof (buf
), _("compression header")))
6305 Elf_Internal_Chdr chdr
;
6307 (void) get_compression_header (&chdr
, buf
);
6309 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6312 printf (_(" [<unknown>: 0x%x], "),
6314 print_vma (chdr
.ch_size
, LONG_HEX
);
6315 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6321 if (!do_section_details
)
6323 /* The ordering of the letters shown here matches the ordering of the
6324 corresponding SHF_xxx values, and hence the order in which these
6325 letters will be displayed to the user. */
6326 printf (_("Key to Flags:\n\
6327 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6328 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6329 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6330 if (elf_header
.e_machine
== EM_X86_64
6331 || elf_header
.e_machine
== EM_L1OM
6332 || elf_header
.e_machine
== EM_K1OM
)
6333 printf (_("l (large), "));
6334 else if (elf_header
.e_machine
== EM_ARM
)
6335 printf (_("y (purecode), "));
6336 printf ("p (processor specific)\n");
6343 get_group_flags (unsigned int flags
)
6345 static char buff
[128];
6349 else if (flags
== GRP_COMDAT
)
6352 snprintf (buff
, 14, _("[0x%x: "), flags
);
6354 flags
&= ~ GRP_COMDAT
;
6355 if (flags
& GRP_MASKOS
)
6357 strcat (buff
, "<OS specific>");
6358 flags
&= ~ GRP_MASKOS
;
6361 if (flags
& GRP_MASKPROC
)
6363 strcat (buff
, "<PROC specific>");
6364 flags
&= ~ GRP_MASKPROC
;
6368 strcat (buff
, "<unknown>");
6375 process_section_groups (FILE * file
)
6377 Elf_Internal_Shdr
* section
;
6379 struct group
* group
;
6380 Elf_Internal_Shdr
* symtab_sec
;
6381 Elf_Internal_Shdr
* strtab_sec
;
6382 Elf_Internal_Sym
* symtab
;
6383 unsigned long num_syms
;
6387 /* Don't process section groups unless needed. */
6388 if (!do_unwind
&& !do_section_groups
)
6391 if (elf_header
.e_shnum
== 0)
6393 if (do_section_groups
)
6394 printf (_("\nThere are no sections to group in this file.\n"));
6399 if (section_headers
== NULL
)
6401 error (_("Section headers are not available!\n"));
6402 /* PR 13622: This can happen with a corrupt ELF header. */
6406 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6407 sizeof (struct group
*));
6409 if (section_headers_groups
== NULL
)
6411 error (_("Out of memory reading %u section group headers\n"),
6412 elf_header
.e_shnum
);
6416 /* Scan the sections for the group section. */
6418 for (i
= 0, section
= section_headers
;
6419 i
< elf_header
.e_shnum
;
6421 if (section
->sh_type
== SHT_GROUP
)
6424 if (group_count
== 0)
6426 if (do_section_groups
)
6427 printf (_("\nThere are no section groups in this file.\n"));
6432 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6434 if (section_groups
== NULL
)
6436 error (_("Out of memory reading %lu groups\n"),
6437 (unsigned long) group_count
);
6447 for (i
= 0, section
= section_headers
, group
= section_groups
;
6448 i
< elf_header
.e_shnum
;
6451 if (section
->sh_type
== SHT_GROUP
)
6453 const char * name
= printable_section_name (section
);
6454 const char * group_name
;
6455 unsigned char * start
;
6456 unsigned char * indices
;
6457 unsigned int entry
, j
, size
;
6458 Elf_Internal_Shdr
* sec
;
6459 Elf_Internal_Sym
* sym
;
6461 /* Get the symbol table. */
6462 if (section
->sh_link
>= elf_header
.e_shnum
6463 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6466 error (_("Bad sh_link in group section `%s'\n"), name
);
6470 if (symtab_sec
!= sec
)
6475 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6480 error (_("Corrupt header in group section `%s'\n"), name
);
6484 if (section
->sh_info
>= num_syms
)
6486 error (_("Bad sh_info in group section `%s'\n"), name
);
6490 sym
= symtab
+ section
->sh_info
;
6492 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6494 if (sym
->st_shndx
== 0
6495 || sym
->st_shndx
>= elf_header
.e_shnum
)
6497 error (_("Bad sh_info in group section `%s'\n"), name
);
6501 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6510 /* Get the string table. */
6511 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6520 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6526 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6527 1, strtab_sec
->sh_size
,
6529 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6531 group_name
= sym
->st_name
< strtab_size
6532 ? strtab
+ sym
->st_name
: _("<corrupt>");
6535 /* PR 17531: file: loop. */
6536 if (section
->sh_entsize
> section
->sh_size
)
6538 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6539 printable_section_name (section
),
6540 (unsigned long) section
->sh_entsize
,
6541 (unsigned long) section
->sh_size
);
6545 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6546 1, section
->sh_size
,
6552 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6553 entry
= byte_get (indices
, 4);
6556 if (do_section_groups
)
6558 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6559 get_group_flags (entry
), i
, name
, group_name
, size
);
6561 printf (_(" [Index] Name\n"));
6564 group
->group_index
= i
;
6566 for (j
= 0; j
< size
; j
++)
6568 struct group_list
* g
;
6570 entry
= byte_get (indices
, 4);
6573 if (entry
>= elf_header
.e_shnum
)
6575 static unsigned num_group_errors
= 0;
6577 if (num_group_errors
++ < 10)
6579 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6580 entry
, i
, elf_header
.e_shnum
- 1);
6581 if (num_group_errors
== 10)
6582 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6587 if (section_headers_groups
[entry
] != NULL
)
6591 static unsigned num_errs
= 0;
6593 if (num_errs
++ < 10)
6595 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6597 section_headers_groups
[entry
]->group_index
);
6599 warn (_("Further error messages about already contained group sections suppressed\n"));
6605 /* Intel C/C++ compiler may put section 0 in a
6606 section group. We just warn it the first time
6607 and ignore it afterwards. */
6608 static int warned
= 0;
6611 error (_("section 0 in group section [%5u]\n"),
6612 section_headers_groups
[entry
]->group_index
);
6618 section_headers_groups
[entry
] = group
;
6620 if (do_section_groups
)
6622 sec
= section_headers
+ entry
;
6623 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6626 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6627 g
->section_index
= entry
;
6628 g
->next
= group
->root
;
6646 /* Data used to display dynamic fixups. */
6648 struct ia64_vms_dynfixup
6650 bfd_vma needed_ident
; /* Library ident number. */
6651 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6652 bfd_vma fixup_needed
; /* Index of the library. */
6653 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6654 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6657 /* Data used to display dynamic relocations. */
6659 struct ia64_vms_dynimgrela
6661 bfd_vma img_rela_cnt
; /* Number of relocations. */
6662 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6665 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6669 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6670 const char *strtab
, unsigned int strtab_sz
)
6672 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6674 const char *lib_name
;
6676 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6677 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6678 _("dynamic section image fixups"));
6682 if (fixup
->needed
< strtab_sz
)
6683 lib_name
= strtab
+ fixup
->needed
;
6686 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6687 (unsigned long) fixup
->needed
);
6690 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6691 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6693 (_("Seg Offset Type SymVec DataType\n"));
6695 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6700 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6701 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6702 type
= BYTE_GET (imfs
[i
].type
);
6703 rtype
= elf_ia64_reloc_type (type
);
6705 printf (" 0x%08x ", type
);
6707 printf (" %-32s ", rtype
);
6708 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6709 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6715 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6718 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6720 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6723 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6724 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6725 _("dynamic section image relocations"));
6729 printf (_("\nImage relocs\n"));
6731 (_("Seg Offset Type Addend Seg Sym Off\n"));
6733 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6738 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6739 printf ("%08" BFD_VMA_FMT
"x ",
6740 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6741 type
= BYTE_GET (imrs
[i
].type
);
6742 rtype
= elf_ia64_reloc_type (type
);
6744 printf ("0x%08x ", type
);
6746 printf ("%-31s ", rtype
);
6747 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6748 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6749 printf ("%08" BFD_VMA_FMT
"x\n",
6750 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6756 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6759 process_ia64_vms_dynamic_relocs (FILE *file
)
6761 struct ia64_vms_dynfixup fixup
;
6762 struct ia64_vms_dynimgrela imgrela
;
6763 Elf_Internal_Dyn
*entry
;
6765 bfd_vma strtab_off
= 0;
6766 bfd_vma strtab_sz
= 0;
6767 char *strtab
= NULL
;
6769 memset (&fixup
, 0, sizeof (fixup
));
6770 memset (&imgrela
, 0, sizeof (imgrela
));
6772 /* Note: the order of the entries is specified by the OpenVMS specs. */
6773 for (entry
= dynamic_section
;
6774 entry
< dynamic_section
+ dynamic_nent
;
6777 switch (entry
->d_tag
)
6779 case DT_IA_64_VMS_STRTAB_OFFSET
:
6780 strtab_off
= entry
->d_un
.d_val
;
6783 strtab_sz
= entry
->d_un
.d_val
;
6785 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6786 1, strtab_sz
, _("dynamic string section"));
6789 case DT_IA_64_VMS_NEEDED_IDENT
:
6790 fixup
.needed_ident
= entry
->d_un
.d_val
;
6793 fixup
.needed
= entry
->d_un
.d_val
;
6795 case DT_IA_64_VMS_FIXUP_NEEDED
:
6796 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6798 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6799 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6801 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6802 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6804 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6807 case DT_IA_64_VMS_IMG_RELA_CNT
:
6808 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6810 case DT_IA_64_VMS_IMG_RELA_OFF
:
6811 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6813 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6833 } dynamic_relocations
[] =
6835 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6836 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6837 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6840 /* Process the reloc section. */
6843 process_relocs (FILE * file
)
6845 unsigned long rel_size
;
6846 unsigned long rel_offset
;
6852 if (do_using_dynamic
)
6856 int has_dynamic_reloc
;
6859 has_dynamic_reloc
= 0;
6861 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6863 is_rela
= dynamic_relocations
[i
].rela
;
6864 name
= dynamic_relocations
[i
].name
;
6865 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6866 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6868 has_dynamic_reloc
|= rel_size
;
6870 if (is_rela
== UNKNOWN
)
6872 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6873 switch (dynamic_info
[DT_PLTREL
])
6887 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6888 name
, rel_offset
, rel_size
);
6890 dump_relocations (file
,
6891 offset_from_vma (file
, rel_offset
, rel_size
),
6893 dynamic_symbols
, num_dynamic_syms
,
6894 dynamic_strings
, dynamic_strings_length
,
6900 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6902 if (! has_dynamic_reloc
)
6903 printf (_("\nThere are no dynamic relocations in this file.\n"));
6907 Elf_Internal_Shdr
* section
;
6911 for (i
= 0, section
= section_headers
;
6912 i
< elf_header
.e_shnum
;
6915 if ( section
->sh_type
!= SHT_RELA
6916 && section
->sh_type
!= SHT_REL
)
6919 rel_offset
= section
->sh_offset
;
6920 rel_size
= section
->sh_size
;
6924 Elf_Internal_Shdr
* strsec
;
6927 printf (_("\nRelocation section "));
6929 if (string_table
== NULL
)
6930 printf ("%d", section
->sh_name
);
6932 printf ("'%s'", printable_section_name (section
));
6934 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6935 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6937 is_rela
= section
->sh_type
== SHT_RELA
;
6939 if (section
->sh_link
!= 0
6940 && section
->sh_link
< elf_header
.e_shnum
)
6942 Elf_Internal_Shdr
* symsec
;
6943 Elf_Internal_Sym
* symtab
;
6944 unsigned long nsyms
;
6945 unsigned long strtablen
= 0;
6946 char * strtab
= NULL
;
6948 symsec
= section_headers
+ section
->sh_link
;
6949 if (symsec
->sh_type
!= SHT_SYMTAB
6950 && symsec
->sh_type
!= SHT_DYNSYM
)
6953 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6958 if (symsec
->sh_link
!= 0
6959 && symsec
->sh_link
< elf_header
.e_shnum
)
6961 strsec
= section_headers
+ symsec
->sh_link
;
6963 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6966 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6969 dump_relocations (file
, rel_offset
, rel_size
,
6970 symtab
, nsyms
, strtab
, strtablen
,
6972 symsec
->sh_type
== SHT_DYNSYM
);
6978 dump_relocations (file
, rel_offset
, rel_size
,
6979 NULL
, 0, NULL
, 0, is_rela
, 0);
6986 printf (_("\nThere are no relocations in this file.\n"));
6992 /* An absolute address consists of a section and an offset. If the
6993 section is NULL, the offset itself is the address, otherwise, the
6994 address equals to LOAD_ADDRESS(section) + offset. */
6998 unsigned short section
;
7002 #define ABSADDR(a) \
7004 ? section_headers [(a).section].sh_addr + (a).offset \
7007 /* Find the nearest symbol at or below ADDR. Returns the symbol
7008 name, if found, and the offset from the symbol to ADDR. */
7011 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7012 unsigned long nsyms
,
7013 const char * strtab
,
7014 unsigned long strtab_size
,
7015 struct absaddr addr
,
7016 const char ** symname
,
7019 bfd_vma dist
= 0x100000;
7020 Elf_Internal_Sym
* sym
;
7021 Elf_Internal_Sym
* beg
;
7022 Elf_Internal_Sym
* end
;
7023 Elf_Internal_Sym
* best
= NULL
;
7025 REMOVE_ARCH_BITS (addr
.offset
);
7027 end
= symtab
+ nsyms
;
7033 sym
= beg
+ (end
- beg
) / 2;
7035 value
= sym
->st_value
;
7036 REMOVE_ARCH_BITS (value
);
7038 if (sym
->st_name
!= 0
7039 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7040 && addr
.offset
>= value
7041 && addr
.offset
- value
< dist
)
7044 dist
= addr
.offset
- value
;
7049 if (addr
.offset
< value
)
7057 *symname
= (best
->st_name
>= strtab_size
7058 ? _("<corrupt>") : strtab
+ best
->st_name
);
7064 *offset
= addr
.offset
;
7068 symcmp (const void *p
, const void *q
)
7070 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7071 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7073 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7076 /* Process the unwind section. */
7078 #include "unwind-ia64.h"
7080 struct ia64_unw_table_entry
7082 struct absaddr start
;
7084 struct absaddr info
;
7087 struct ia64_unw_aux_info
7089 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7090 unsigned long table_len
; /* Length of unwind table. */
7091 unsigned char * info
; /* Unwind info. */
7092 unsigned long info_size
; /* Size of unwind info. */
7093 bfd_vma info_addr
; /* Starting address of unwind info. */
7094 bfd_vma seg_base
; /* Starting address of segment. */
7095 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7096 unsigned long nsyms
; /* Number of symbols. */
7097 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7098 unsigned long nfuns
; /* Number of entries in funtab. */
7099 char * strtab
; /* The string table. */
7100 unsigned long strtab_size
; /* Size of string table. */
7104 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7106 struct ia64_unw_table_entry
* tp
;
7107 unsigned long j
, nfuns
;
7110 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7111 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7112 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7113 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7115 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7117 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7121 const unsigned char * dp
;
7122 const unsigned char * head
;
7123 const unsigned char * end
;
7124 const char * procname
;
7126 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7127 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7129 fputs ("\n<", stdout
);
7133 fputs (procname
, stdout
);
7136 printf ("+%lx", (unsigned long) offset
);
7139 fputs (">: [", stdout
);
7140 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7141 fputc ('-', stdout
);
7142 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7143 printf ("], info at +0x%lx\n",
7144 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7146 /* PR 17531: file: 86232b32. */
7147 if (aux
->info
== NULL
)
7150 /* PR 17531: file: 0997b4d1. */
7151 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7153 warn (_("Invalid offset %lx in table entry %ld\n"),
7154 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7158 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7159 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7161 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7162 (unsigned) UNW_VER (stamp
),
7163 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7164 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7165 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7166 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7168 if (UNW_VER (stamp
) != 1)
7170 printf (_("\tUnknown version.\n"));
7175 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7176 /* PR 17531: file: 16ceda89. */
7177 if (end
> aux
->info
+ aux
->info_size
)
7178 end
= aux
->info
+ aux
->info_size
;
7179 for (dp
= head
+ 8; dp
< end
;)
7180 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7187 slurp_ia64_unwind_table (FILE * file
,
7188 struct ia64_unw_aux_info
* aux
,
7189 Elf_Internal_Shdr
* sec
)
7191 unsigned long size
, nrelas
, i
;
7192 Elf_Internal_Phdr
* seg
;
7193 struct ia64_unw_table_entry
* tep
;
7194 Elf_Internal_Shdr
* relsec
;
7195 Elf_Internal_Rela
* rela
;
7196 Elf_Internal_Rela
* rp
;
7197 unsigned char * table
;
7199 Elf_Internal_Sym
* sym
;
7200 const char * relname
;
7204 /* First, find the starting address of the segment that includes
7207 if (elf_header
.e_phnum
)
7209 if (! get_program_headers (file
))
7212 for (seg
= program_headers
;
7213 seg
< program_headers
+ elf_header
.e_phnum
;
7216 if (seg
->p_type
!= PT_LOAD
)
7219 if (sec
->sh_addr
>= seg
->p_vaddr
7220 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7222 aux
->seg_base
= seg
->p_vaddr
;
7228 /* Second, build the unwind table from the contents of the unwind section: */
7229 size
= sec
->sh_size
;
7230 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7235 aux
->table_len
= size
/ (3 * eh_addr_size
);
7236 aux
->table
= (struct ia64_unw_table_entry
*)
7237 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7240 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7242 tep
->start
.section
= SHN_UNDEF
;
7243 tep
->end
.section
= SHN_UNDEF
;
7244 tep
->info
.section
= SHN_UNDEF
;
7245 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7246 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7247 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7248 tep
->start
.offset
+= aux
->seg_base
;
7249 tep
->end
.offset
+= aux
->seg_base
;
7250 tep
->info
.offset
+= aux
->seg_base
;
7254 /* Third, apply any relocations to the unwind table: */
7255 for (relsec
= section_headers
;
7256 relsec
< section_headers
+ elf_header
.e_shnum
;
7259 if (relsec
->sh_type
!= SHT_RELA
7260 || relsec
->sh_info
>= elf_header
.e_shnum
7261 || section_headers
+ relsec
->sh_info
!= sec
)
7264 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7273 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7275 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7276 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7278 /* PR 17531: file: 9fa67536. */
7279 if (relname
== NULL
)
7281 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7285 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7287 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7291 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7293 /* PR 17531: file: 5bc8d9bf. */
7294 if (i
>= aux
->table_len
)
7296 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7300 switch (rp
->r_offset
/ eh_addr_size
% 3)
7303 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7304 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7307 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7308 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7311 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7312 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7326 ia64_process_unwind (FILE * file
)
7328 Elf_Internal_Shdr
* sec
;
7329 Elf_Internal_Shdr
* unwsec
= NULL
;
7330 Elf_Internal_Shdr
* strsec
;
7331 unsigned long i
, unwcount
= 0, unwstart
= 0;
7332 struct ia64_unw_aux_info aux
;
7334 memset (& aux
, 0, sizeof (aux
));
7336 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7338 if (sec
->sh_type
== SHT_SYMTAB
7339 && sec
->sh_link
< elf_header
.e_shnum
)
7341 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7343 strsec
= section_headers
+ sec
->sh_link
;
7344 if (aux
.strtab
!= NULL
)
7346 error (_("Multiple auxillary string tables encountered\n"));
7349 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7352 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7354 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7359 printf (_("\nThere are no unwind sections in this file.\n"));
7361 while (unwcount
-- > 0)
7366 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7367 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7368 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7373 /* We have already counted the number of SHT_IA64_UNWIND
7374 sections so the loop above should never fail. */
7375 assert (unwsec
!= NULL
);
7378 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7380 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7382 /* We need to find which section group it is in. */
7383 struct group_list
* g
;
7385 if (section_headers_groups
== NULL
7386 || section_headers_groups
[i
] == NULL
)
7387 i
= elf_header
.e_shnum
;
7390 g
= section_headers_groups
[i
]->root
;
7392 for (; g
!= NULL
; g
= g
->next
)
7394 sec
= section_headers
+ g
->section_index
;
7396 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7401 i
= elf_header
.e_shnum
;
7404 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7406 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7407 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7408 suffix
= SECTION_NAME (unwsec
) + len
;
7409 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7411 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7412 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7417 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7418 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7419 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7420 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7422 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7423 suffix
= SECTION_NAME (unwsec
) + len
;
7424 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7426 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7427 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7431 if (i
== elf_header
.e_shnum
)
7433 printf (_("\nCould not find unwind info section for "));
7435 if (string_table
== NULL
)
7436 printf ("%d", unwsec
->sh_name
);
7438 printf ("'%s'", printable_section_name (unwsec
));
7442 aux
.info_addr
= sec
->sh_addr
;
7443 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7446 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7448 printf (_("\nUnwind section "));
7450 if (string_table
== NULL
)
7451 printf ("%d", unwsec
->sh_name
);
7453 printf ("'%s'", printable_section_name (unwsec
));
7455 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7456 (unsigned long) unwsec
->sh_offset
,
7457 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7459 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7460 && aux
.table_len
> 0)
7461 dump_ia64_unwind (& aux
);
7464 free ((char *) aux
.table
);
7466 free ((char *) aux
.info
);
7475 free ((char *) aux
.strtab
);
7478 struct hppa_unw_table_entry
7480 struct absaddr start
;
7482 unsigned int Cannot_unwind
:1; /* 0 */
7483 unsigned int Millicode
:1; /* 1 */
7484 unsigned int Millicode_save_sr0
:1; /* 2 */
7485 unsigned int Region_description
:2; /* 3..4 */
7486 unsigned int reserved1
:1; /* 5 */
7487 unsigned int Entry_SR
:1; /* 6 */
7488 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7489 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7490 unsigned int Args_stored
:1; /* 16 */
7491 unsigned int Variable_Frame
:1; /* 17 */
7492 unsigned int Separate_Package_Body
:1; /* 18 */
7493 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7494 unsigned int Stack_Overflow_Check
:1; /* 20 */
7495 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7496 unsigned int Ada_Region
:1; /* 22 */
7497 unsigned int cxx_info
:1; /* 23 */
7498 unsigned int cxx_try_catch
:1; /* 24 */
7499 unsigned int sched_entry_seq
:1; /* 25 */
7500 unsigned int reserved2
:1; /* 26 */
7501 unsigned int Save_SP
:1; /* 27 */
7502 unsigned int Save_RP
:1; /* 28 */
7503 unsigned int Save_MRP_in_frame
:1; /* 29 */
7504 unsigned int extn_ptr_defined
:1; /* 30 */
7505 unsigned int Cleanup_defined
:1; /* 31 */
7507 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7508 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7509 unsigned int Large_frame
:1; /* 2 */
7510 unsigned int Pseudo_SP_Set
:1; /* 3 */
7511 unsigned int reserved4
:1; /* 4 */
7512 unsigned int Total_frame_size
:27; /* 5..31 */
7515 struct hppa_unw_aux_info
7517 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7518 unsigned long table_len
; /* Length of unwind table. */
7519 bfd_vma seg_base
; /* Starting address of segment. */
7520 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7521 unsigned long nsyms
; /* Number of symbols. */
7522 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7523 unsigned long nfuns
; /* Number of entries in funtab. */
7524 char * strtab
; /* The string table. */
7525 unsigned long strtab_size
; /* Size of string table. */
7529 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7531 struct hppa_unw_table_entry
* tp
;
7532 unsigned long j
, nfuns
;
7534 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7535 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7536 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7537 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7539 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7541 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7544 const char * procname
;
7546 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7547 aux
->strtab_size
, tp
->start
, &procname
,
7550 fputs ("\n<", stdout
);
7554 fputs (procname
, stdout
);
7557 printf ("+%lx", (unsigned long) offset
);
7560 fputs (">: [", stdout
);
7561 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7562 fputc ('-', stdout
);
7563 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7566 #define PF(_m) if (tp->_m) printf (#_m " ");
7567 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7570 PF(Millicode_save_sr0
);
7571 /* PV(Region_description); */
7577 PF(Separate_Package_Body
);
7578 PF(Frame_Extension_Millicode
);
7579 PF(Stack_Overflow_Check
);
7580 PF(Two_Instruction_SP_Increment
);
7584 PF(sched_entry_seq
);
7587 PF(Save_MRP_in_frame
);
7588 PF(extn_ptr_defined
);
7589 PF(Cleanup_defined
);
7590 PF(MPE_XL_interrupt_marker
);
7591 PF(HP_UX_interrupt_marker
);
7594 PV(Total_frame_size
);
7605 slurp_hppa_unwind_table (FILE * file
,
7606 struct hppa_unw_aux_info
* aux
,
7607 Elf_Internal_Shdr
* sec
)
7609 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7610 Elf_Internal_Phdr
* seg
;
7611 struct hppa_unw_table_entry
* tep
;
7612 Elf_Internal_Shdr
* relsec
;
7613 Elf_Internal_Rela
* rela
;
7614 Elf_Internal_Rela
* rp
;
7615 unsigned char * table
;
7617 Elf_Internal_Sym
* sym
;
7618 const char * relname
;
7620 /* First, find the starting address of the segment that includes
7623 if (elf_header
.e_phnum
)
7625 if (! get_program_headers (file
))
7628 for (seg
= program_headers
;
7629 seg
< program_headers
+ elf_header
.e_phnum
;
7632 if (seg
->p_type
!= PT_LOAD
)
7635 if (sec
->sh_addr
>= seg
->p_vaddr
7636 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7638 aux
->seg_base
= seg
->p_vaddr
;
7644 /* Second, build the unwind table from the contents of the unwind
7646 size
= sec
->sh_size
;
7647 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7653 nentries
= size
/ unw_ent_size
;
7654 size
= unw_ent_size
* nentries
;
7656 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7657 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7659 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7661 unsigned int tmp1
, tmp2
;
7663 tep
->start
.section
= SHN_UNDEF
;
7664 tep
->end
.section
= SHN_UNDEF
;
7666 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7667 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7668 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7669 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7671 tep
->start
.offset
+= aux
->seg_base
;
7672 tep
->end
.offset
+= aux
->seg_base
;
7674 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7675 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7676 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7677 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7678 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7679 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7680 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7681 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7682 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7683 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7684 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7685 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7686 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7687 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7688 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7689 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7690 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7691 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7692 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7693 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7694 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7695 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7696 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7697 tep
->Cleanup_defined
= tmp1
& 0x1;
7699 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7700 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7701 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7702 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7703 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7704 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7708 /* Third, apply any relocations to the unwind table. */
7709 for (relsec
= section_headers
;
7710 relsec
< section_headers
+ elf_header
.e_shnum
;
7713 if (relsec
->sh_type
!= SHT_RELA
7714 || relsec
->sh_info
>= elf_header
.e_shnum
7715 || section_headers
+ relsec
->sh_info
!= sec
)
7718 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7722 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7724 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7725 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7727 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7728 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7730 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7734 i
= rp
->r_offset
/ unw_ent_size
;
7736 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7739 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7740 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7743 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7744 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7754 aux
->table_len
= nentries
;
7760 hppa_process_unwind (FILE * file
)
7762 struct hppa_unw_aux_info aux
;
7763 Elf_Internal_Shdr
* unwsec
= NULL
;
7764 Elf_Internal_Shdr
* strsec
;
7765 Elf_Internal_Shdr
* sec
;
7768 if (string_table
== NULL
)
7771 memset (& aux
, 0, sizeof (aux
));
7773 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7775 if (sec
->sh_type
== SHT_SYMTAB
7776 && sec
->sh_link
< elf_header
.e_shnum
)
7778 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7780 strsec
= section_headers
+ sec
->sh_link
;
7781 if (aux
.strtab
!= NULL
)
7783 error (_("Multiple auxillary string tables encountered\n"));
7786 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7789 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7791 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7796 printf (_("\nThere are no unwind sections in this file.\n"));
7798 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7800 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7802 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7803 printable_section_name (sec
),
7804 (unsigned long) sec
->sh_offset
,
7805 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7807 slurp_hppa_unwind_table (file
, &aux
, sec
);
7808 if (aux
.table_len
> 0)
7809 dump_hppa_unwind (&aux
);
7812 free ((char *) aux
.table
);
7820 free ((char *) aux
.strtab
);
7825 unsigned char * data
; /* The unwind data. */
7826 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7827 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7828 unsigned long nrelas
; /* The number of relocations. */
7829 unsigned int rel_type
; /* REL or RELA ? */
7830 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7833 struct arm_unw_aux_info
7835 FILE * file
; /* The file containing the unwind sections. */
7836 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7837 unsigned long nsyms
; /* Number of symbols. */
7838 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7839 unsigned long nfuns
; /* Number of these symbols. */
7840 char * strtab
; /* The file's string table. */
7841 unsigned long strtab_size
; /* Size of string table. */
7845 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7846 bfd_vma fn
, struct absaddr addr
)
7848 const char *procname
;
7851 if (addr
.section
== SHN_UNDEF
)
7854 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7855 aux
->strtab_size
, addr
, &procname
,
7858 print_vma (fn
, PREFIX_HEX
);
7862 fputs (" <", stdout
);
7863 fputs (procname
, stdout
);
7866 printf ("+0x%lx", (unsigned long) sym_offset
);
7867 fputc ('>', stdout
);
7874 arm_free_section (struct arm_section
*arm_sec
)
7876 if (arm_sec
->data
!= NULL
)
7877 free (arm_sec
->data
);
7879 if (arm_sec
->rela
!= NULL
)
7880 free (arm_sec
->rela
);
7883 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7884 cached section and install SEC instead.
7885 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7886 and return its valued in * WORDP, relocating if necessary.
7887 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7888 relocation's offset in ADDR.
7889 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7890 into the string table of the symbol associated with the reloc. If no
7891 reloc was applied store -1 there.
7892 5) Return TRUE upon success, FALSE otherwise. */
7895 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7896 struct arm_section
* arm_sec
,
7897 Elf_Internal_Shdr
* sec
,
7898 bfd_vma word_offset
,
7899 unsigned int * wordp
,
7900 struct absaddr
* addr
,
7903 Elf_Internal_Rela
*rp
;
7904 Elf_Internal_Sym
*sym
;
7905 const char * relname
;
7907 bfd_boolean wrapped
;
7909 if (sec
== NULL
|| arm_sec
== NULL
)
7912 addr
->section
= SHN_UNDEF
;
7915 if (sym_name
!= NULL
)
7916 *sym_name
= (bfd_vma
) -1;
7918 /* If necessary, update the section cache. */
7919 if (sec
!= arm_sec
->sec
)
7921 Elf_Internal_Shdr
*relsec
;
7923 arm_free_section (arm_sec
);
7926 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7927 sec
->sh_size
, _("unwind data"));
7928 arm_sec
->rela
= NULL
;
7929 arm_sec
->nrelas
= 0;
7931 for (relsec
= section_headers
;
7932 relsec
< section_headers
+ elf_header
.e_shnum
;
7935 if (relsec
->sh_info
>= elf_header
.e_shnum
7936 || section_headers
+ relsec
->sh_info
!= sec
7937 /* PR 15745: Check the section type as well. */
7938 || (relsec
->sh_type
!= SHT_REL
7939 && relsec
->sh_type
!= SHT_RELA
))
7942 arm_sec
->rel_type
= relsec
->sh_type
;
7943 if (relsec
->sh_type
== SHT_REL
)
7945 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7947 & arm_sec
->rela
, & arm_sec
->nrelas
))
7950 else /* relsec->sh_type == SHT_RELA */
7952 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7954 & arm_sec
->rela
, & arm_sec
->nrelas
))
7960 arm_sec
->next_rela
= arm_sec
->rela
;
7963 /* If there is no unwind data we can do nothing. */
7964 if (arm_sec
->data
== NULL
)
7967 /* If the offset is invalid then fail. */
7968 if (word_offset
> (sec
->sh_size
- 4)
7970 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7971 || ((bfd_signed_vma
) word_offset
) < 0)
7974 /* Get the word at the required offset. */
7975 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7977 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7978 if (arm_sec
->rela
== NULL
)
7984 /* Look through the relocs to find the one that applies to the provided offset. */
7986 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7988 bfd_vma prelval
, offset
;
7990 if (rp
->r_offset
> word_offset
&& !wrapped
)
7995 if (rp
->r_offset
> word_offset
)
7998 if (rp
->r_offset
& 3)
8000 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8001 (unsigned long) rp
->r_offset
);
8005 if (rp
->r_offset
< word_offset
)
8008 /* PR 17531: file: 027-161405-0.004 */
8009 if (aux
->symtab
== NULL
)
8012 if (arm_sec
->rel_type
== SHT_REL
)
8014 offset
= word
& 0x7fffffff;
8015 if (offset
& 0x40000000)
8016 offset
|= ~ (bfd_vma
) 0x7fffffff;
8018 else if (arm_sec
->rel_type
== SHT_RELA
)
8019 offset
= rp
->r_addend
;
8022 error (_("Unknown section relocation type %d encountered\n"),
8027 /* PR 17531 file: 027-1241568-0.004. */
8028 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8030 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8031 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8035 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8036 offset
+= sym
->st_value
;
8037 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8039 /* Check that we are processing the expected reloc type. */
8040 if (elf_header
.e_machine
== EM_ARM
)
8042 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8043 if (relname
== NULL
)
8045 warn (_("Skipping unknown ARM relocation type: %d\n"),
8046 (int) ELF32_R_TYPE (rp
->r_info
));
8050 if (streq (relname
, "R_ARM_NONE"))
8053 if (! streq (relname
, "R_ARM_PREL31"))
8055 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8059 else if (elf_header
.e_machine
== EM_TI_C6000
)
8061 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8062 if (relname
== NULL
)
8064 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8065 (int) ELF32_R_TYPE (rp
->r_info
));
8069 if (streq (relname
, "R_C6000_NONE"))
8072 if (! streq (relname
, "R_C6000_PREL31"))
8074 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8082 /* This function currently only supports ARM and TI unwinders. */
8083 warn (_("Only TI and ARM unwinders are currently supported\n"));
8087 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8088 addr
->section
= sym
->st_shndx
;
8089 addr
->offset
= offset
;
8092 * sym_name
= sym
->st_name
;
8097 arm_sec
->next_rela
= rp
;
8102 static const char *tic6x_unwind_regnames
[16] =
8104 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8105 "A14", "A13", "A12", "A11", "A10",
8106 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8110 decode_tic6x_unwind_regmask (unsigned int mask
)
8114 for (i
= 12; mask
; mask
>>= 1, i
--)
8118 fputs (tic6x_unwind_regnames
[i
], stdout
);
8120 fputs (", ", stdout
);
8126 if (remaining == 0 && more_words) \
8129 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8130 data_offset, & word, & addr, NULL)) \
8136 #define GET_OP(OP) \
8141 (OP) = word >> 24; \
8146 printf (_("[Truncated opcode]\n")); \
8149 printf ("0x%02x ", OP)
8152 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8154 unsigned int remaining
,
8155 unsigned int more_words
,
8156 bfd_vma data_offset
,
8157 Elf_Internal_Shdr
* data_sec
,
8158 struct arm_section
* data_arm_sec
)
8160 struct absaddr addr
;
8162 /* Decode the unwinding instructions. */
8165 unsigned int op
, op2
;
8174 printf (" 0x%02x ", op
);
8176 if ((op
& 0xc0) == 0x00)
8178 int offset
= ((op
& 0x3f) << 2) + 4;
8180 printf (" vsp = vsp + %d", offset
);
8182 else if ((op
& 0xc0) == 0x40)
8184 int offset
= ((op
& 0x3f) << 2) + 4;
8186 printf (" vsp = vsp - %d", offset
);
8188 else if ((op
& 0xf0) == 0x80)
8191 if (op
== 0x80 && op2
== 0)
8192 printf (_("Refuse to unwind"));
8195 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8200 for (i
= 0; i
< 12; i
++)
8201 if (mask
& (1 << i
))
8207 printf ("r%d", 4 + i
);
8212 else if ((op
& 0xf0) == 0x90)
8214 if (op
== 0x9d || op
== 0x9f)
8215 printf (_(" [Reserved]"));
8217 printf (" vsp = r%d", op
& 0x0f);
8219 else if ((op
& 0xf0) == 0xa0)
8221 int end
= 4 + (op
& 0x07);
8226 for (i
= 4; i
<= end
; i
++)
8242 else if (op
== 0xb0)
8243 printf (_(" finish"));
8244 else if (op
== 0xb1)
8247 if (op2
== 0 || (op2
& 0xf0) != 0)
8248 printf (_("[Spare]"));
8251 unsigned int mask
= op2
& 0x0f;
8256 for (i
= 0; i
< 12; i
++)
8257 if (mask
& (1 << i
))
8268 else if (op
== 0xb2)
8270 unsigned char buf
[9];
8271 unsigned int i
, len
;
8272 unsigned long offset
;
8274 for (i
= 0; i
< sizeof (buf
); i
++)
8277 if ((buf
[i
] & 0x80) == 0)
8280 if (i
== sizeof (buf
))
8281 printf (_("corrupt change to vsp"));
8284 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8285 assert (len
== i
+ 1);
8286 offset
= offset
* 4 + 0x204;
8287 printf ("vsp = vsp + %ld", offset
);
8290 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8292 unsigned int first
, last
;
8299 printf ("pop {D%d", first
);
8301 printf ("-D%d", first
+ last
);
8304 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8306 unsigned int count
= op
& 0x07;
8310 printf ("-D%d", 8 + count
);
8313 else if (op
>= 0xc0 && op
<= 0xc5)
8315 unsigned int count
= op
& 0x07;
8317 printf (" pop {wR10");
8319 printf ("-wR%d", 10 + count
);
8322 else if (op
== 0xc6)
8324 unsigned int first
, last
;
8329 printf ("pop {wR%d", first
);
8331 printf ("-wR%d", first
+ last
);
8334 else if (op
== 0xc7)
8337 if (op2
== 0 || (op2
& 0xf0) != 0)
8338 printf (_("[Spare]"));
8341 unsigned int mask
= op2
& 0x0f;
8346 for (i
= 0; i
< 4; i
++)
8347 if (mask
& (1 << i
))
8353 printf ("wCGR%d", i
);
8359 printf (_(" [unsupported opcode]"));
8365 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8367 unsigned int remaining
,
8368 unsigned int more_words
,
8369 bfd_vma data_offset
,
8370 Elf_Internal_Shdr
* data_sec
,
8371 struct arm_section
* data_arm_sec
)
8373 struct absaddr addr
;
8375 /* Decode the unwinding instructions. */
8378 unsigned int op
, op2
;
8387 printf (" 0x%02x ", op
);
8389 if ((op
& 0xc0) == 0x00)
8391 int offset
= ((op
& 0x3f) << 3) + 8;
8392 printf (" sp = sp + %d", offset
);
8394 else if ((op
& 0xc0) == 0x80)
8397 if (op
== 0x80 && op2
== 0)
8398 printf (_("Refuse to unwind"));
8401 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8403 printf ("pop compact {");
8407 decode_tic6x_unwind_regmask (mask
);
8411 else if ((op
& 0xf0) == 0xc0)
8419 unsigned int offset
;
8423 /* Scan entire instruction first so that GET_OP output is not
8424 interleaved with disassembly. */
8426 for (i
= 0; nregs
< (op
& 0xf); i
++)
8432 regpos
[nregs
].offset
= i
* 2;
8433 regpos
[nregs
].reg
= reg
;
8440 regpos
[nregs
].offset
= i
* 2 + 1;
8441 regpos
[nregs
].reg
= reg
;
8446 printf (_("pop frame {"));
8448 for (i
= i
* 2; i
> 0; i
--)
8450 if (regpos
[reg
].offset
== i
- 1)
8452 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8459 fputs (name
, stdout
);
8466 else if (op
== 0xd0)
8467 printf (" MOV FP, SP");
8468 else if (op
== 0xd1)
8469 printf (" __c6xabi_pop_rts");
8470 else if (op
== 0xd2)
8472 unsigned char buf
[9];
8473 unsigned int i
, len
;
8474 unsigned long offset
;
8476 for (i
= 0; i
< sizeof (buf
); i
++)
8479 if ((buf
[i
] & 0x80) == 0)
8482 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8483 if (i
== sizeof (buf
))
8485 printf ("<corrupt sp adjust>\n");
8486 warn (_("Corrupt stack pointer adjustment detected\n"));
8490 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8491 assert (len
== i
+ 1);
8492 offset
= offset
* 8 + 0x408;
8493 printf (_("sp = sp + %ld"), offset
);
8495 else if ((op
& 0xf0) == 0xe0)
8497 if ((op
& 0x0f) == 7)
8500 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8504 printf (_(" [unsupported opcode]"));
8511 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8515 offset
= word
& 0x7fffffff;
8516 if (offset
& 0x40000000)
8517 offset
|= ~ (bfd_vma
) 0x7fffffff;
8519 if (elf_header
.e_machine
== EM_TI_C6000
)
8522 return offset
+ where
;
8526 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8528 unsigned int remaining
,
8529 bfd_vma data_offset
,
8530 Elf_Internal_Shdr
* data_sec
,
8531 struct arm_section
* data_arm_sec
)
8534 unsigned int more_words
= 0;
8535 struct absaddr addr
;
8536 bfd_vma sym_name
= (bfd_vma
) -1;
8540 /* Fetch the first word.
8541 Note - when decoding an object file the address extracted
8542 here will always be 0. So we also pass in the sym_name
8543 parameter so that we can find the symbol associated with
8544 the personality routine. */
8545 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8546 & word
, & addr
, & sym_name
))
8552 if ((word
& 0x80000000) == 0)
8554 /* Expand prel31 for personality routine. */
8556 const char *procname
;
8558 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8559 printf (_(" Personality routine: "));
8561 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8562 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8564 procname
= aux
->strtab
+ sym_name
;
8565 print_vma (fn
, PREFIX_HEX
);
8568 fputs (" <", stdout
);
8569 fputs (procname
, stdout
);
8570 fputc ('>', stdout
);
8574 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8575 fputc ('\n', stdout
);
8577 /* The GCC personality routines use the standard compact
8578 encoding, starting with one byte giving the number of
8580 if (procname
!= NULL
8581 && (const_strneq (procname
, "__gcc_personality_v0")
8582 || const_strneq (procname
, "__gxx_personality_v0")
8583 || const_strneq (procname
, "__gcj_personality_v0")
8584 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8591 printf (_(" [Truncated data]\n"));
8594 more_words
= word
>> 24;
8604 /* ARM EHABI Section 6.3:
8606 An exception-handling table entry for the compact model looks like:
8610 1 0 index Data for personalityRoutine[index] */
8612 if (elf_header
.e_machine
== EM_ARM
8613 && (word
& 0x70000000))
8614 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8616 per_index
= (word
>> 24) & 0x7f;
8617 printf (_(" Compact model index: %d\n"), per_index
);
8624 else if (per_index
< 3)
8626 more_words
= (word
>> 16) & 0xff;
8632 switch (elf_header
.e_machine
)
8637 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8638 data_offset
, data_sec
, data_arm_sec
);
8642 warn (_("Unknown ARM compact model index encountered\n"));
8643 printf (_(" [reserved]\n"));
8650 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8651 data_offset
, data_sec
, data_arm_sec
);
8653 else if (per_index
< 5)
8655 if (((word
>> 17) & 0x7f) == 0x7f)
8656 printf (_(" Restore stack from frame pointer\n"));
8658 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8659 printf (_(" Registers restored: "));
8661 printf (" (compact) ");
8662 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8664 printf (_(" Return register: %s\n"),
8665 tic6x_unwind_regnames
[word
& 0xf]);
8668 printf (_(" [reserved (%d)]\n"), per_index
);
8672 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8673 elf_header
.e_machine
);
8676 /* Decode the descriptors. Not implemented. */
8680 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8682 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8683 unsigned int i
, exidx_len
;
8684 unsigned long j
, nfuns
;
8686 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8687 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8688 exidx_len
= exidx_sec
->sh_size
/ 8;
8690 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8691 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8692 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8693 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8695 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8697 for (i
= 0; i
< exidx_len
; i
++)
8699 unsigned int exidx_fn
, exidx_entry
;
8700 struct absaddr fn_addr
, entry_addr
;
8703 fputc ('\n', stdout
);
8705 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8706 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8707 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8708 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8711 arm_free_section (& exidx_arm_sec
);
8712 arm_free_section (& extab_arm_sec
);
8716 /* ARM EHABI, Section 5:
8717 An index table entry consists of 2 words.
8718 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8719 if (exidx_fn
& 0x80000000)
8720 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8722 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8724 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8725 fputs (": ", stdout
);
8727 if (exidx_entry
== 1)
8729 print_vma (exidx_entry
, PREFIX_HEX
);
8730 fputs (" [cantunwind]\n", stdout
);
8732 else if (exidx_entry
& 0x80000000)
8734 print_vma (exidx_entry
, PREFIX_HEX
);
8735 fputc ('\n', stdout
);
8736 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8740 bfd_vma table
, table_offset
= 0;
8741 Elf_Internal_Shdr
*table_sec
;
8743 fputs ("@", stdout
);
8744 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8745 print_vma (table
, PREFIX_HEX
);
8748 /* Locate the matching .ARM.extab. */
8749 if (entry_addr
.section
!= SHN_UNDEF
8750 && entry_addr
.section
< elf_header
.e_shnum
)
8752 table_sec
= section_headers
+ entry_addr
.section
;
8753 table_offset
= entry_addr
.offset
;
8755 if (table_offset
> table_sec
->sh_size
8756 || ((bfd_signed_vma
) table_offset
) < 0)
8758 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8759 (unsigned long) table_offset
,
8760 printable_section_name (table_sec
));
8766 table_sec
= find_section_by_address (table
);
8767 if (table_sec
!= NULL
)
8768 table_offset
= table
- table_sec
->sh_addr
;
8770 if (table_sec
== NULL
)
8772 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8773 (unsigned long) table
);
8776 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8784 arm_free_section (&exidx_arm_sec
);
8785 arm_free_section (&extab_arm_sec
);
8788 /* Used for both ARM and C6X unwinding tables. */
8791 arm_process_unwind (FILE *file
)
8793 struct arm_unw_aux_info aux
;
8794 Elf_Internal_Shdr
*unwsec
= NULL
;
8795 Elf_Internal_Shdr
*strsec
;
8796 Elf_Internal_Shdr
*sec
;
8798 unsigned int sec_type
;
8800 switch (elf_header
.e_machine
)
8803 sec_type
= SHT_ARM_EXIDX
;
8807 sec_type
= SHT_C6000_UNWIND
;
8811 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8812 elf_header
.e_machine
);
8816 if (string_table
== NULL
)
8819 memset (& aux
, 0, sizeof (aux
));
8822 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8824 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8826 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8828 strsec
= section_headers
+ sec
->sh_link
;
8830 /* PR binutils/17531 file: 011-12666-0.004. */
8831 if (aux
.strtab
!= NULL
)
8833 error (_("Multiple string tables found in file.\n"));
8836 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8837 1, strsec
->sh_size
, _("string table"));
8838 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8840 else if (sec
->sh_type
== sec_type
)
8845 printf (_("\nThere are no unwind sections in this file.\n"));
8847 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8849 if (sec
->sh_type
== sec_type
)
8851 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8852 printable_section_name (sec
),
8853 (unsigned long) sec
->sh_offset
,
8854 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8856 dump_arm_unwind (&aux
, sec
);
8863 free ((char *) aux
.strtab
);
8867 process_unwind (FILE * file
)
8869 struct unwind_handler
8872 void (* handler
)(FILE *);
8875 { EM_ARM
, arm_process_unwind
},
8876 { EM_IA_64
, ia64_process_unwind
},
8877 { EM_PARISC
, hppa_process_unwind
},
8878 { EM_TI_C6000
, arm_process_unwind
},
8886 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8887 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8889 handlers
[i
].handler (file
);
8893 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8894 get_machine_name (elf_header
.e_machine
));
8898 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8900 switch (entry
->d_tag
)
8903 if (entry
->d_un
.d_val
== 0)
8907 static const char * opts
[] =
8909 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8910 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8911 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8912 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8918 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8919 if (entry
->d_un
.d_val
& (1 << cnt
))
8921 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8927 case DT_MIPS_IVERSION
:
8928 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8929 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8933 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8934 /* Note: coded this way so that there is a single string for translation. */
8935 printf (_("<corrupt: %s>"), buf
);
8939 case DT_MIPS_TIME_STAMP
:
8943 time_t atime
= entry
->d_un
.d_val
;
8945 tmp
= gmtime (&atime
);
8946 /* PR 17531: file: 6accc532. */
8948 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8950 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8951 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8952 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8953 printf (_("Time Stamp: %s"), timebuf
);
8957 case DT_MIPS_RLD_VERSION
:
8958 case DT_MIPS_LOCAL_GOTNO
:
8959 case DT_MIPS_CONFLICTNO
:
8960 case DT_MIPS_LIBLISTNO
:
8961 case DT_MIPS_SYMTABNO
:
8962 case DT_MIPS_UNREFEXTNO
:
8963 case DT_MIPS_HIPAGENO
:
8964 case DT_MIPS_DELTA_CLASS_NO
:
8965 case DT_MIPS_DELTA_INSTANCE_NO
:
8966 case DT_MIPS_DELTA_RELOC_NO
:
8967 case DT_MIPS_DELTA_SYM_NO
:
8968 case DT_MIPS_DELTA_CLASSSYM_NO
:
8969 case DT_MIPS_COMPACT_SIZE
:
8970 print_vma (entry
->d_un
.d_val
, DEC
);
8974 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8980 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8982 switch (entry
->d_tag
)
8984 case DT_HP_DLD_FLAGS
:
8993 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8994 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8995 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8996 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8997 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8998 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8999 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9000 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9001 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9002 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9003 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9004 { DT_HP_GST
, "HP_GST" },
9005 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9006 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9007 { DT_HP_NODELETE
, "HP_NODELETE" },
9008 { DT_HP_GROUP
, "HP_GROUP" },
9009 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9013 bfd_vma val
= entry
->d_un
.d_val
;
9015 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9016 if (val
& flags
[cnt
].bit
)
9020 fputs (flags
[cnt
].str
, stdout
);
9022 val
^= flags
[cnt
].bit
;
9025 if (val
!= 0 || first
)
9029 print_vma (val
, HEX
);
9035 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9043 /* VMS vs Unix time offset and factor. */
9045 #define VMS_EPOCH_OFFSET 35067168000000000LL
9046 #define VMS_GRANULARITY_FACTOR 10000000
9048 /* Display a VMS time in a human readable format. */
9051 print_vms_time (bfd_int64_t vmstime
)
9056 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9057 tm
= gmtime (&unxtime
);
9058 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9059 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9060 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9065 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9067 switch (entry
->d_tag
)
9069 case DT_IA_64_PLT_RESERVE
:
9070 /* First 3 slots reserved. */
9071 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9073 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9076 case DT_IA_64_VMS_LINKTIME
:
9078 print_vms_time (entry
->d_un
.d_val
);
9082 case DT_IA_64_VMS_LNKFLAGS
:
9083 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9084 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9085 printf (" CALL_DEBUG");
9086 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9087 printf (" NOP0BUFS");
9088 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9089 printf (" P0IMAGE");
9090 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9091 printf (" MKTHREADS");
9092 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9093 printf (" UPCALLS");
9094 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9096 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9097 printf (" INITIALIZE");
9098 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9100 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9101 printf (" EXE_INIT");
9102 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9103 printf (" TBK_IN_IMG");
9104 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9105 printf (" DBG_IN_IMG");
9106 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9107 printf (" TBK_IN_DSF");
9108 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9109 printf (" DBG_IN_DSF");
9110 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9111 printf (" SIGNATURES");
9112 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9113 printf (" REL_SEG_OFF");
9117 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9124 get_32bit_dynamic_section (FILE * file
)
9126 Elf32_External_Dyn
* edyn
;
9127 Elf32_External_Dyn
* ext
;
9128 Elf_Internal_Dyn
* entry
;
9130 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9131 dynamic_size
, _("dynamic section"));
9135 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9136 might not have the luxury of section headers. Look for the DT_NULL
9137 terminator to determine the number of entries. */
9138 for (ext
= edyn
, dynamic_nent
= 0;
9139 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9143 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9147 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9149 if (dynamic_section
== NULL
)
9151 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9152 (unsigned long) dynamic_nent
);
9157 for (ext
= edyn
, entry
= dynamic_section
;
9158 entry
< dynamic_section
+ dynamic_nent
;
9161 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9162 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9171 get_64bit_dynamic_section (FILE * file
)
9173 Elf64_External_Dyn
* edyn
;
9174 Elf64_External_Dyn
* ext
;
9175 Elf_Internal_Dyn
* entry
;
9177 /* Read in the data. */
9178 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9179 dynamic_size
, _("dynamic section"));
9183 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9184 might not have the luxury of section headers. Look for the DT_NULL
9185 terminator to determine the number of entries. */
9186 for (ext
= edyn
, dynamic_nent
= 0;
9187 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9188 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9192 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9196 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9198 if (dynamic_section
== NULL
)
9200 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9201 (unsigned long) dynamic_nent
);
9206 /* Convert from external to internal formats. */
9207 for (ext
= edyn
, entry
= dynamic_section
;
9208 entry
< dynamic_section
+ dynamic_nent
;
9211 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9212 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9221 print_dynamic_flags (bfd_vma flags
)
9229 flag
= flags
& - flags
;
9239 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9240 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9241 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9242 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9243 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9244 default: fputs (_("unknown"), stdout
); break;
9250 /* Parse and display the contents of the dynamic section. */
9253 process_dynamic_section (FILE * file
)
9255 Elf_Internal_Dyn
* entry
;
9257 if (dynamic_size
== 0)
9260 printf (_("\nThere is no dynamic section in this file.\n"));
9267 if (! get_32bit_dynamic_section (file
))
9270 else if (! get_64bit_dynamic_section (file
))
9273 /* Find the appropriate symbol table. */
9274 if (dynamic_symbols
== NULL
)
9276 for (entry
= dynamic_section
;
9277 entry
< dynamic_section
+ dynamic_nent
;
9280 Elf_Internal_Shdr section
;
9282 if (entry
->d_tag
!= DT_SYMTAB
)
9285 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9287 /* Since we do not know how big the symbol table is,
9288 we default to reading in the entire file (!) and
9289 processing that. This is overkill, I know, but it
9291 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9293 if (archive_file_offset
!= 0)
9294 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9297 if (fseek (file
, 0, SEEK_END
))
9298 error (_("Unable to seek to end of file!\n"));
9300 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9304 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9306 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9307 section
.sh_name
= string_table_length
;
9309 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9310 if (num_dynamic_syms
< 1)
9312 error (_("Unable to determine the number of symbols to load\n"));
9318 /* Similarly find a string table. */
9319 if (dynamic_strings
== NULL
)
9321 for (entry
= dynamic_section
;
9322 entry
< dynamic_section
+ dynamic_nent
;
9325 unsigned long offset
;
9328 if (entry
->d_tag
!= DT_STRTAB
)
9331 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9333 /* Since we do not know how big the string table is,
9334 we default to reading in the entire file (!) and
9335 processing that. This is overkill, I know, but it
9338 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9340 if (archive_file_offset
!= 0)
9341 str_tab_len
= archive_file_size
- offset
;
9344 if (fseek (file
, 0, SEEK_END
))
9345 error (_("Unable to seek to end of file\n"));
9346 str_tab_len
= ftell (file
) - offset
;
9349 if (str_tab_len
< 1)
9352 (_("Unable to determine the length of the dynamic string table\n"));
9356 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9358 _("dynamic string table"));
9359 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9364 /* And find the syminfo section if available. */
9365 if (dynamic_syminfo
== NULL
)
9367 unsigned long syminsz
= 0;
9369 for (entry
= dynamic_section
;
9370 entry
< dynamic_section
+ dynamic_nent
;
9373 if (entry
->d_tag
== DT_SYMINENT
)
9375 /* Note: these braces are necessary to avoid a syntax
9376 error from the SunOS4 C compiler. */
9377 /* PR binutils/17531: A corrupt file can trigger this test.
9378 So do not use an assert, instead generate an error message. */
9379 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9380 error (_("Bad value (%d) for SYMINENT entry\n"),
9381 (int) entry
->d_un
.d_val
);
9383 else if (entry
->d_tag
== DT_SYMINSZ
)
9384 syminsz
= entry
->d_un
.d_val
;
9385 else if (entry
->d_tag
== DT_SYMINFO
)
9386 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9390 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9392 Elf_External_Syminfo
* extsyminfo
;
9393 Elf_External_Syminfo
* extsym
;
9394 Elf_Internal_Syminfo
* syminfo
;
9396 /* There is a syminfo section. Read the data. */
9397 extsyminfo
= (Elf_External_Syminfo
*)
9398 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9399 _("symbol information"));
9403 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9404 if (dynamic_syminfo
== NULL
)
9406 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9407 (unsigned long) syminsz
);
9411 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9412 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9413 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9414 ++syminfo
, ++extsym
)
9416 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9417 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9424 if (do_dynamic
&& dynamic_addr
)
9425 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9426 dynamic_addr
, (unsigned long) dynamic_nent
);
9428 printf (_(" Tag Type Name/Value\n"));
9430 for (entry
= dynamic_section
;
9431 entry
< dynamic_section
+ dynamic_nent
;
9439 print_vma (entry
->d_tag
, FULL_HEX
);
9440 dtype
= get_dynamic_type (entry
->d_tag
);
9441 printf (" (%s)%*s", dtype
,
9442 ((is_32bit_elf
? 27 : 19)
9443 - (int) strlen (dtype
)),
9447 switch (entry
->d_tag
)
9451 print_dynamic_flags (entry
->d_un
.d_val
);
9461 switch (entry
->d_tag
)
9464 printf (_("Auxiliary library"));
9468 printf (_("Filter library"));
9472 printf (_("Configuration file"));
9476 printf (_("Dependency audit library"));
9480 printf (_("Audit library"));
9484 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9485 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9489 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9498 printf (_("Flags:"));
9500 if (entry
->d_un
.d_val
== 0)
9501 printf (_(" None\n"));
9504 unsigned long int val
= entry
->d_un
.d_val
;
9506 if (val
& DTF_1_PARINIT
)
9508 printf (" PARINIT");
9509 val
^= DTF_1_PARINIT
;
9511 if (val
& DTF_1_CONFEXP
)
9513 printf (" CONFEXP");
9514 val
^= DTF_1_CONFEXP
;
9517 printf (" %lx", val
);
9526 printf (_("Flags:"));
9528 if (entry
->d_un
.d_val
== 0)
9529 printf (_(" None\n"));
9532 unsigned long int val
= entry
->d_un
.d_val
;
9534 if (val
& DF_P1_LAZYLOAD
)
9536 printf (" LAZYLOAD");
9537 val
^= DF_P1_LAZYLOAD
;
9539 if (val
& DF_P1_GROUPPERM
)
9541 printf (" GROUPPERM");
9542 val
^= DF_P1_GROUPPERM
;
9545 printf (" %lx", val
);
9554 printf (_("Flags:"));
9555 if (entry
->d_un
.d_val
== 0)
9556 printf (_(" None\n"));
9559 unsigned long int val
= entry
->d_un
.d_val
;
9566 if (val
& DF_1_GLOBAL
)
9571 if (val
& DF_1_GROUP
)
9576 if (val
& DF_1_NODELETE
)
9578 printf (" NODELETE");
9579 val
^= DF_1_NODELETE
;
9581 if (val
& DF_1_LOADFLTR
)
9583 printf (" LOADFLTR");
9584 val
^= DF_1_LOADFLTR
;
9586 if (val
& DF_1_INITFIRST
)
9588 printf (" INITFIRST");
9589 val
^= DF_1_INITFIRST
;
9591 if (val
& DF_1_NOOPEN
)
9596 if (val
& DF_1_ORIGIN
)
9601 if (val
& DF_1_DIRECT
)
9606 if (val
& DF_1_TRANS
)
9611 if (val
& DF_1_INTERPOSE
)
9613 printf (" INTERPOSE");
9614 val
^= DF_1_INTERPOSE
;
9616 if (val
& DF_1_NODEFLIB
)
9618 printf (" NODEFLIB");
9619 val
^= DF_1_NODEFLIB
;
9621 if (val
& DF_1_NODUMP
)
9626 if (val
& DF_1_CONFALT
)
9628 printf (" CONFALT");
9629 val
^= DF_1_CONFALT
;
9631 if (val
& DF_1_ENDFILTEE
)
9633 printf (" ENDFILTEE");
9634 val
^= DF_1_ENDFILTEE
;
9636 if (val
& DF_1_DISPRELDNE
)
9638 printf (" DISPRELDNE");
9639 val
^= DF_1_DISPRELDNE
;
9641 if (val
& DF_1_DISPRELPND
)
9643 printf (" DISPRELPND");
9644 val
^= DF_1_DISPRELPND
;
9646 if (val
& DF_1_NODIRECT
)
9648 printf (" NODIRECT");
9649 val
^= DF_1_NODIRECT
;
9651 if (val
& DF_1_IGNMULDEF
)
9653 printf (" IGNMULDEF");
9654 val
^= DF_1_IGNMULDEF
;
9656 if (val
& DF_1_NOKSYMS
)
9658 printf (" NOKSYMS");
9659 val
^= DF_1_NOKSYMS
;
9661 if (val
& DF_1_NOHDR
)
9666 if (val
& DF_1_EDITED
)
9671 if (val
& DF_1_NORELOC
)
9673 printf (" NORELOC");
9674 val
^= DF_1_NORELOC
;
9676 if (val
& DF_1_SYMINTPOSE
)
9678 printf (" SYMINTPOSE");
9679 val
^= DF_1_SYMINTPOSE
;
9681 if (val
& DF_1_GLOBAUDIT
)
9683 printf (" GLOBAUDIT");
9684 val
^= DF_1_GLOBAUDIT
;
9686 if (val
& DF_1_SINGLETON
)
9688 printf (" SINGLETON");
9689 val
^= DF_1_SINGLETON
;
9691 if (val
& DF_1_STUB
)
9702 printf (" %lx", val
);
9709 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9711 puts (get_dynamic_type (entry
->d_un
.d_val
));
9731 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9737 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9738 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9744 switch (entry
->d_tag
)
9747 printf (_("Shared library: [%s]"), name
);
9749 if (streq (name
, program_interpreter
))
9750 printf (_(" program interpreter"));
9754 printf (_("Library soname: [%s]"), name
);
9758 printf (_("Library rpath: [%s]"), name
);
9762 printf (_("Library runpath: [%s]"), name
);
9766 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9771 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9784 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9789 case DT_INIT_ARRAYSZ
:
9790 case DT_FINI_ARRAYSZ
:
9791 case DT_GNU_CONFLICTSZ
:
9792 case DT_GNU_LIBLISTSZ
:
9795 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9796 printf (_(" (bytes)\n"));
9806 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9819 if (entry
->d_tag
== DT_USED
9820 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9822 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9826 printf (_("Not needed object: [%s]\n"), name
);
9831 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9837 /* The value of this entry is ignored. */
9842 case DT_GNU_PRELINKED
:
9846 time_t atime
= entry
->d_un
.d_val
;
9848 tmp
= gmtime (&atime
);
9849 /* PR 17533 file: 041-1244816-0.004. */
9851 printf (_("<corrupt time val: %lx"),
9852 (unsigned long) atime
);
9854 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9855 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9856 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9862 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9865 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9871 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9872 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9877 switch (elf_header
.e_machine
)
9880 case EM_MIPS_RS3_LE
:
9881 dynamic_section_mips_val (entry
);
9884 dynamic_section_parisc_val (entry
);
9887 dynamic_section_ia64_val (entry
);
9890 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9902 get_ver_flags (unsigned int flags
)
9904 static char buff
[32];
9911 if (flags
& VER_FLG_BASE
)
9912 strcat (buff
, "BASE ");
9914 if (flags
& VER_FLG_WEAK
)
9916 if (flags
& VER_FLG_BASE
)
9917 strcat (buff
, "| ");
9919 strcat (buff
, "WEAK ");
9922 if (flags
& VER_FLG_INFO
)
9924 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9925 strcat (buff
, "| ");
9927 strcat (buff
, "INFO ");
9930 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9931 strcat (buff
, _("| <unknown>"));
9936 /* Display the contents of the version sections. */
9939 process_version_sections (FILE * file
)
9941 Elf_Internal_Shdr
* section
;
9948 for (i
= 0, section
= section_headers
;
9949 i
< elf_header
.e_shnum
;
9952 switch (section
->sh_type
)
9954 case SHT_GNU_verdef
:
9956 Elf_External_Verdef
* edefs
;
9963 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9964 printable_section_name (section
),
9967 printf (_(" Addr: 0x"));
9968 printf_vma (section
->sh_addr
);
9969 printf (_(" Offset: %#08lx Link: %u (%s)"),
9970 (unsigned long) section
->sh_offset
, section
->sh_link
,
9971 printable_section_name_from_index (section
->sh_link
));
9973 edefs
= (Elf_External_Verdef
*)
9974 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9975 _("version definition section"));
9978 endbuf
= (char *) edefs
+ section
->sh_size
;
9980 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9983 Elf_External_Verdef
* edef
;
9984 Elf_Internal_Verdef ent
;
9985 Elf_External_Verdaux
* eaux
;
9986 Elf_Internal_Verdaux aux
;
9990 /* Check for very large indices. */
9991 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9994 vstart
= ((char *) edefs
) + idx
;
9995 if (vstart
+ sizeof (*edef
) > endbuf
)
9998 edef
= (Elf_External_Verdef
*) vstart
;
10000 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10001 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10002 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10003 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10004 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10005 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10006 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10008 printf (_(" %#06x: Rev: %d Flags: %s"),
10009 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10011 printf (_(" Index: %d Cnt: %d "),
10012 ent
.vd_ndx
, ent
.vd_cnt
);
10014 /* Check for overflow. */
10015 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10018 vstart
+= ent
.vd_aux
;
10020 eaux
= (Elf_External_Verdaux
*) vstart
;
10022 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10023 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10025 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10026 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10028 printf (_("Name index: %ld\n"), aux
.vda_name
);
10030 isum
= idx
+ ent
.vd_aux
;
10032 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10034 /* Check for overflow. */
10035 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10038 isum
+= aux
.vda_next
;
10039 vstart
+= aux
.vda_next
;
10041 eaux
= (Elf_External_Verdaux
*) vstart
;
10042 if (vstart
+ sizeof (*eaux
) > endbuf
)
10045 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10046 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10048 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10049 printf (_(" %#06x: Parent %d: %s\n"),
10050 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10052 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10053 isum
, j
, aux
.vda_name
);
10056 if (j
< ent
.vd_cnt
)
10057 printf (_(" Version def aux past end of section\n"));
10059 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10060 if (idx
+ ent
.vd_next
<= idx
)
10063 idx
+= ent
.vd_next
;
10066 if (cnt
< section
->sh_info
)
10067 printf (_(" Version definition past end of section\n"));
10073 case SHT_GNU_verneed
:
10075 Elf_External_Verneed
* eneed
;
10082 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10083 printable_section_name (section
), section
->sh_info
);
10085 printf (_(" Addr: 0x"));
10086 printf_vma (section
->sh_addr
);
10087 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10088 (unsigned long) section
->sh_offset
, section
->sh_link
,
10089 printable_section_name_from_index (section
->sh_link
));
10091 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10092 section
->sh_offset
, 1,
10094 _("Version Needs section"));
10097 endbuf
= (char *) eneed
+ section
->sh_size
;
10099 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10101 Elf_External_Verneed
* entry
;
10102 Elf_Internal_Verneed ent
;
10107 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10110 vstart
= ((char *) eneed
) + idx
;
10111 if (vstart
+ sizeof (*entry
) > endbuf
)
10114 entry
= (Elf_External_Verneed
*) vstart
;
10116 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10117 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10118 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10119 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10120 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10122 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10124 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10125 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10127 printf (_(" File: %lx"), ent
.vn_file
);
10129 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10131 /* Check for overflow. */
10132 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10134 vstart
+= ent
.vn_aux
;
10136 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10138 Elf_External_Vernaux
* eaux
;
10139 Elf_Internal_Vernaux aux
;
10141 if (vstart
+ sizeof (*eaux
) > endbuf
)
10143 eaux
= (Elf_External_Vernaux
*) vstart
;
10145 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10146 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10147 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10148 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10149 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10151 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10152 printf (_(" %#06x: Name: %s"),
10153 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10155 printf (_(" %#06x: Name index: %lx"),
10156 isum
, aux
.vna_name
);
10158 printf (_(" Flags: %s Version: %d\n"),
10159 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10161 /* Check for overflow. */
10162 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10163 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10165 warn (_("Invalid vna_next field of %lx\n"),
10170 isum
+= aux
.vna_next
;
10171 vstart
+= aux
.vna_next
;
10174 if (j
< ent
.vn_cnt
)
10175 warn (_("Missing Version Needs auxillary information\n"));
10177 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10179 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10180 cnt
= section
->sh_info
;
10183 idx
+= ent
.vn_next
;
10186 if (cnt
< section
->sh_info
)
10187 warn (_("Missing Version Needs information\n"));
10193 case SHT_GNU_versym
:
10195 Elf_Internal_Shdr
* link_section
;
10198 unsigned char * edata
;
10199 unsigned short * data
;
10201 Elf_Internal_Sym
* symbols
;
10202 Elf_Internal_Shdr
* string_sec
;
10203 unsigned long num_syms
;
10206 if (section
->sh_link
>= elf_header
.e_shnum
)
10209 link_section
= section_headers
+ section
->sh_link
;
10210 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10212 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10217 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10218 if (symbols
== NULL
)
10221 string_sec
= section_headers
+ link_section
->sh_link
;
10223 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10224 string_sec
->sh_size
,
10225 _("version string table"));
10232 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10233 printable_section_name (section
), (unsigned long) total
);
10235 printf (_(" Addr: "));
10236 printf_vma (section
->sh_addr
);
10237 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10238 (unsigned long) section
->sh_offset
, section
->sh_link
,
10239 printable_section_name (link_section
));
10241 off
= offset_from_vma (file
,
10242 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10243 total
* sizeof (short));
10244 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10246 _("version symbol data"));
10254 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10256 for (cnt
= total
; cnt
--;)
10257 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10262 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10266 char *invalid
= _("*invalid*");
10268 printf (" %03x:", cnt
);
10270 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10271 switch (data
[cnt
+ j
])
10274 fputs (_(" 0 (*local*) "), stdout
);
10278 fputs (_(" 1 (*global*) "), stdout
);
10282 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10283 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10285 /* If this index value is greater than the size of the symbols
10286 array, break to avoid an out-of-bounds read. */
10287 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10289 warn (_("invalid index into symbol array\n"));
10294 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10296 Elf_Internal_Verneed ivn
;
10297 unsigned long offset
;
10299 offset
= offset_from_vma
10300 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10301 sizeof (Elf_External_Verneed
));
10305 Elf_Internal_Vernaux ivna
;
10306 Elf_External_Verneed evn
;
10307 Elf_External_Vernaux evna
;
10308 unsigned long a_off
;
10310 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10311 _("version need")) == NULL
)
10314 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10315 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10317 a_off
= offset
+ ivn
.vn_aux
;
10321 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10322 1, _("version need aux (2)")) == NULL
)
10325 ivna
.vna_other
= 0;
10329 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10330 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10333 a_off
+= ivna
.vna_next
;
10335 while (ivna
.vna_other
!= data
[cnt
+ j
]
10336 && ivna
.vna_next
!= 0);
10338 if (ivna
.vna_other
== data
[cnt
+ j
])
10340 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10342 if (ivna
.vna_name
>= string_sec
->sh_size
)
10345 name
= strtab
+ ivna
.vna_name
;
10349 offset
+= ivn
.vn_next
;
10351 while (ivn
.vn_next
);
10354 if (data
[cnt
+ j
] != 0x8001
10355 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10357 Elf_Internal_Verdef ivd
;
10358 Elf_External_Verdef evd
;
10359 unsigned long offset
;
10361 offset
= offset_from_vma
10362 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10367 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10368 _("version def")) == NULL
)
10371 /* PR 17531: file: 046-1082287-0.004. */
10372 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10377 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10378 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10381 offset
+= ivd
.vd_next
;
10383 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10384 && ivd
.vd_next
!= 0);
10386 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10388 Elf_External_Verdaux evda
;
10389 Elf_Internal_Verdaux ivda
;
10391 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10393 if (get_data (&evda
, file
,
10394 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10396 _("version def aux")) == NULL
)
10399 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10401 if (ivda
.vda_name
>= string_sec
->sh_size
)
10403 else if (name
!= NULL
&& name
!= invalid
)
10404 name
= _("*both*");
10406 name
= strtab
+ ivda
.vda_name
;
10410 nn
+= printf ("(%s%-*s",
10412 12 - (int) strlen (name
),
10416 printf ("%*c", 18 - nn
, ' ');
10434 printf (_("\nNo version information found in this file.\n"));
10439 static const char *
10440 get_symbol_binding (unsigned int binding
)
10442 static char buff
[32];
10446 case STB_LOCAL
: return "LOCAL";
10447 case STB_GLOBAL
: return "GLOBAL";
10448 case STB_WEAK
: return "WEAK";
10450 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10451 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10453 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10455 if (binding
== STB_GNU_UNIQUE
10456 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10457 /* GNU is still using the default value 0. */
10458 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10460 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10463 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10468 static const char *
10469 get_symbol_type (unsigned int type
)
10471 static char buff
[32];
10475 case STT_NOTYPE
: return "NOTYPE";
10476 case STT_OBJECT
: return "OBJECT";
10477 case STT_FUNC
: return "FUNC";
10478 case STT_SECTION
: return "SECTION";
10479 case STT_FILE
: return "FILE";
10480 case STT_COMMON
: return "COMMON";
10481 case STT_TLS
: return "TLS";
10482 case STT_RELC
: return "RELC";
10483 case STT_SRELC
: return "SRELC";
10485 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10487 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10488 return "THUMB_FUNC";
10490 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10493 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10494 return "PARISC_MILLI";
10496 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10498 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10500 if (elf_header
.e_machine
== EM_PARISC
)
10502 if (type
== STT_HP_OPAQUE
)
10503 return "HP_OPAQUE";
10504 if (type
== STT_HP_STUB
)
10508 if (type
== STT_GNU_IFUNC
10509 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10510 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10511 /* GNU is still using the default value 0. */
10512 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10515 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10518 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10523 static const char *
10524 get_symbol_visibility (unsigned int visibility
)
10526 switch (visibility
)
10528 case STV_DEFAULT
: return "DEFAULT";
10529 case STV_INTERNAL
: return "INTERNAL";
10530 case STV_HIDDEN
: return "HIDDEN";
10531 case STV_PROTECTED
: return "PROTECTED";
10533 error (_("Unrecognized visibility value: %u"), visibility
);
10534 return _("<unknown>");
10538 static const char *
10539 get_solaris_symbol_visibility (unsigned int visibility
)
10541 switch (visibility
)
10543 case 4: return "EXPORTED";
10544 case 5: return "SINGLETON";
10545 case 6: return "ELIMINATE";
10546 default: return get_symbol_visibility (visibility
);
10550 static const char *
10551 get_mips_symbol_other (unsigned int other
)
10561 case STO_MICROMIPS
:
10562 return "MICROMIPS";
10563 case STO_MICROMIPS
| STO_MIPS_PIC
:
10564 return "MICROMIPS, MIPS PIC";
10572 static const char *
10573 get_ia64_symbol_other (unsigned int other
)
10575 if (is_ia64_vms ())
10577 static char res
[32];
10581 /* Function types is for images and .STB files only. */
10582 switch (elf_header
.e_type
)
10586 switch (VMS_ST_FUNC_TYPE (other
))
10588 case VMS_SFT_CODE_ADDR
:
10589 strcat (res
, " CA");
10591 case VMS_SFT_SYMV_IDX
:
10592 strcat (res
, " VEC");
10595 strcat (res
, " FD");
10597 case VMS_SFT_RESERVE
:
10598 strcat (res
, " RSV");
10601 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10602 VMS_ST_FUNC_TYPE (other
));
10603 strcat (res
, " <unknown>");
10610 switch (VMS_ST_LINKAGE (other
))
10612 case VMS_STL_IGNORE
:
10613 strcat (res
, " IGN");
10615 case VMS_STL_RESERVE
:
10616 strcat (res
, " RSV");
10619 strcat (res
, " STD");
10622 strcat (res
, " LNK");
10625 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10626 VMS_ST_LINKAGE (other
));
10627 strcat (res
, " <unknown>");
10639 static const char *
10640 get_ppc64_symbol_other (unsigned int other
)
10642 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10644 static char buf
[32];
10645 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10646 PPC64_LOCAL_ENTRY_OFFSET (other
));
10652 static const char *
10653 get_symbol_other (unsigned int other
)
10655 const char * result
= NULL
;
10656 static char buff
[32];
10661 switch (elf_header
.e_machine
)
10664 result
= get_mips_symbol_other (other
);
10667 result
= get_ia64_symbol_other (other
);
10670 result
= get_ppc64_symbol_other (other
);
10680 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10684 static const char *
10685 get_symbol_index_type (unsigned int type
)
10687 static char buff
[32];
10691 case SHN_UNDEF
: return "UND";
10692 case SHN_ABS
: return "ABS";
10693 case SHN_COMMON
: return "COM";
10695 if (type
== SHN_IA_64_ANSI_COMMON
10696 && elf_header
.e_machine
== EM_IA_64
10697 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10699 else if ((elf_header
.e_machine
== EM_X86_64
10700 || elf_header
.e_machine
== EM_L1OM
10701 || elf_header
.e_machine
== EM_K1OM
)
10702 && type
== SHN_X86_64_LCOMMON
)
10703 return "LARGE_COM";
10704 else if ((type
== SHN_MIPS_SCOMMON
10705 && elf_header
.e_machine
== EM_MIPS
)
10706 || (type
== SHN_TIC6X_SCOMMON
10707 && elf_header
.e_machine
== EM_TI_C6000
))
10709 else if (type
== SHN_MIPS_SUNDEFINED
10710 && elf_header
.e_machine
== EM_MIPS
)
10712 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10713 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10714 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10715 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10716 else if (type
>= SHN_LORESERVE
)
10717 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10718 else if (type
>= elf_header
.e_shnum
)
10719 sprintf (buff
, _("bad section index[%3d]"), type
);
10721 sprintf (buff
, "%3d", type
);
10729 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10731 unsigned char * e_data
;
10734 /* If the size_t type is smaller than the bfd_size_type, eg because
10735 you are building a 32-bit tool on a 64-bit host, then make sure
10736 that when (number) is cast to (size_t) no information is lost. */
10737 if (sizeof (size_t) < sizeof (bfd_size_type
)
10738 && (bfd_size_type
) ((size_t) number
) != number
)
10740 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10741 " elements of size %u\n"),
10746 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10747 attempting to allocate memory when the read is bound to fail. */
10748 if (ent_size
* number
> current_file_size
)
10750 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10755 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10756 if (e_data
== NULL
)
10758 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10763 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10765 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10766 number
* ent_size
);
10771 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10772 if (i_data
== NULL
)
10774 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10775 " dynamic entries\n"),
10782 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10790 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10792 Elf_Internal_Sym
* psym
;
10795 n
= print_vma (si
, DEC_5
);
10797 fputs (&" "[n
], stdout
);
10798 printf (" %3lu: ", hn
);
10800 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10802 printf (_("<No info available for dynamic symbol number %lu>\n"),
10803 (unsigned long) si
);
10807 psym
= dynamic_symbols
+ si
;
10808 print_vma (psym
->st_value
, LONG_HEX
);
10810 print_vma (psym
->st_size
, DEC_5
);
10812 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10813 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10815 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10816 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10819 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10821 printf (" %-7s", get_symbol_visibility (vis
));
10822 /* Check to see if any other bits in the st_other field are set.
10823 Note - displaying this information disrupts the layout of the
10824 table being generated, but for the moment this case is very
10826 if (psym
->st_other
^ vis
)
10827 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10830 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10831 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10832 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10834 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10838 static const char *
10839 get_symbol_version_string (FILE * file
,
10840 bfd_boolean is_dynsym
,
10841 const char * strtab
,
10842 unsigned long int strtab_size
,
10844 Elf_Internal_Sym
* psym
,
10845 enum versioned_symbol_info
* sym_info
,
10846 unsigned short * vna_other
)
10848 unsigned char data
[2];
10849 unsigned short vers_data
;
10850 unsigned long offset
;
10853 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10856 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10857 sizeof data
+ si
* sizeof (vers_data
));
10859 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10860 sizeof (data
), 1, _("version data")) == NULL
)
10863 vers_data
= byte_get (data
, 2);
10865 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10868 /* Usually we'd only see verdef for defined symbols, and verneed for
10869 undefined symbols. However, symbols defined by the linker in
10870 .dynbss for variables copied from a shared library in order to
10871 avoid text relocations are defined yet have verneed. We could
10872 use a heuristic to detect the special case, for example, check
10873 for verneed first on symbols defined in SHT_NOBITS sections, but
10874 it is simpler and more reliable to just look for both verdef and
10875 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10877 if (psym
->st_shndx
!= SHN_UNDEF
10878 && vers_data
!= 0x8001
10879 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10881 Elf_Internal_Verdef ivd
;
10882 Elf_Internal_Verdaux ivda
;
10883 Elf_External_Verdaux evda
;
10886 off
= offset_from_vma (file
,
10887 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10888 sizeof (Elf_External_Verdef
));
10892 Elf_External_Verdef evd
;
10894 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10895 _("version def")) == NULL
)
10903 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10904 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10905 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10908 off
+= ivd
.vd_next
;
10910 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10912 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10914 off
-= ivd
.vd_next
;
10917 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10918 _("version def aux")) != NULL
)
10920 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10922 if (psym
->st_name
!= ivda
.vda_name
)
10924 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10925 ? symbol_hidden
: symbol_public
);
10926 return (ivda
.vda_name
< strtab_size
10927 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10933 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10935 Elf_External_Verneed evn
;
10936 Elf_Internal_Verneed ivn
;
10937 Elf_Internal_Vernaux ivna
;
10939 offset
= offset_from_vma (file
,
10940 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10944 unsigned long vna_off
;
10946 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10947 _("version need")) == NULL
)
10950 ivna
.vna_other
= 0;
10955 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10956 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10958 vna_off
= offset
+ ivn
.vn_aux
;
10962 Elf_External_Vernaux evna
;
10964 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10965 _("version need aux (3)")) == NULL
)
10968 ivna
.vna_other
= 0;
10973 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10974 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10975 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10978 vna_off
+= ivna
.vna_next
;
10980 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10982 if (ivna
.vna_other
== vers_data
)
10985 offset
+= ivn
.vn_next
;
10987 while (ivn
.vn_next
!= 0);
10989 if (ivna
.vna_other
== vers_data
)
10991 *sym_info
= symbol_undefined
;
10992 *vna_other
= ivna
.vna_other
;
10993 return (ivna
.vna_name
< strtab_size
10994 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11000 /* Dump the symbol table. */
11002 process_symbol_table (FILE * file
)
11004 Elf_Internal_Shdr
* section
;
11005 bfd_size_type nbuckets
= 0;
11006 bfd_size_type nchains
= 0;
11007 bfd_vma
* buckets
= NULL
;
11008 bfd_vma
* chains
= NULL
;
11009 bfd_vma ngnubuckets
= 0;
11010 bfd_vma
* gnubuckets
= NULL
;
11011 bfd_vma
* gnuchains
= NULL
;
11012 bfd_vma gnusymidx
= 0;
11013 bfd_size_type ngnuchains
= 0;
11015 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11018 if (dynamic_info
[DT_HASH
]
11020 || (do_using_dynamic
11022 && dynamic_strings
!= NULL
)))
11024 unsigned char nb
[8];
11025 unsigned char nc
[8];
11026 unsigned int hash_ent_size
= 4;
11028 if ((elf_header
.e_machine
== EM_ALPHA
11029 || elf_header
.e_machine
== EM_S390
11030 || elf_header
.e_machine
== EM_S390_OLD
)
11031 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11035 (archive_file_offset
11036 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11037 sizeof nb
+ sizeof nc
)),
11040 error (_("Unable to seek to start of dynamic information\n"));
11044 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11046 error (_("Failed to read in number of buckets\n"));
11050 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11052 error (_("Failed to read in number of chains\n"));
11056 nbuckets
= byte_get (nb
, hash_ent_size
);
11057 nchains
= byte_get (nc
, hash_ent_size
);
11059 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11060 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11063 if (buckets
== NULL
|| chains
== NULL
)
11065 if (do_using_dynamic
)
11076 if (dynamic_info_DT_GNU_HASH
11078 || (do_using_dynamic
11080 && dynamic_strings
!= NULL
)))
11082 unsigned char nb
[16];
11083 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11084 bfd_vma buckets_vma
;
11087 (archive_file_offset
11088 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11092 error (_("Unable to seek to start of dynamic information\n"));
11096 if (fread (nb
, 16, 1, file
) != 1)
11098 error (_("Failed to read in number of buckets\n"));
11102 ngnubuckets
= byte_get (nb
, 4);
11103 gnusymidx
= byte_get (nb
+ 4, 4);
11104 bitmaskwords
= byte_get (nb
+ 8, 4);
11105 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11107 buckets_vma
+= bitmaskwords
* 4;
11109 buckets_vma
+= bitmaskwords
* 8;
11112 (archive_file_offset
11113 + offset_from_vma (file
, buckets_vma
, 4)),
11116 error (_("Unable to seek to start of dynamic information\n"));
11120 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11122 if (gnubuckets
== NULL
)
11125 for (i
= 0; i
< ngnubuckets
; i
++)
11126 if (gnubuckets
[i
] != 0)
11128 if (gnubuckets
[i
] < gnusymidx
)
11131 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11132 maxchain
= gnubuckets
[i
];
11135 if (maxchain
== 0xffffffff)
11138 maxchain
-= gnusymidx
;
11141 (archive_file_offset
11142 + offset_from_vma (file
, buckets_vma
11143 + 4 * (ngnubuckets
+ maxchain
), 4)),
11146 error (_("Unable to seek to start of dynamic information\n"));
11152 if (fread (nb
, 4, 1, file
) != 1)
11154 error (_("Failed to determine last chain length\n"));
11158 if (maxchain
+ 1 == 0)
11163 while ((byte_get (nb
, 4) & 1) == 0);
11166 (archive_file_offset
11167 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11170 error (_("Unable to seek to start of dynamic information\n"));
11174 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11175 ngnuchains
= maxchain
;
11178 if (gnuchains
== NULL
)
11183 if (do_using_dynamic
)
11188 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11190 && do_using_dynamic
11191 && dynamic_strings
!= NULL
11192 && dynamic_symbols
!= NULL
)
11196 if (dynamic_info
[DT_HASH
])
11200 printf (_("\nSymbol table for image:\n"));
11202 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11204 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11206 for (hn
= 0; hn
< nbuckets
; hn
++)
11211 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11212 print_dynamic_symbol (si
, hn
);
11216 if (dynamic_info_DT_GNU_HASH
)
11218 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11220 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11222 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11224 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11225 if (gnubuckets
[hn
] != 0)
11227 bfd_vma si
= gnubuckets
[hn
];
11228 bfd_vma off
= si
- gnusymidx
;
11232 print_dynamic_symbol (si
, hn
);
11235 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11239 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11240 && section_headers
!= NULL
)
11244 for (i
= 0, section
= section_headers
;
11245 i
< elf_header
.e_shnum
;
11249 char * strtab
= NULL
;
11250 unsigned long int strtab_size
= 0;
11251 Elf_Internal_Sym
* symtab
;
11252 Elf_Internal_Sym
* psym
;
11253 unsigned long num_syms
;
11255 if ((section
->sh_type
!= SHT_SYMTAB
11256 && section
->sh_type
!= SHT_DYNSYM
)
11258 && section
->sh_type
== SHT_SYMTAB
))
11261 if (section
->sh_entsize
== 0)
11263 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11264 printable_section_name (section
));
11268 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11269 printable_section_name (section
),
11270 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11273 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11275 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11277 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11278 if (symtab
== NULL
)
11281 if (section
->sh_link
== elf_header
.e_shstrndx
)
11283 strtab
= string_table
;
11284 strtab_size
= string_table_length
;
11286 else if (section
->sh_link
< elf_header
.e_shnum
)
11288 Elf_Internal_Shdr
* string_sec
;
11290 string_sec
= section_headers
+ section
->sh_link
;
11292 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11293 1, string_sec
->sh_size
,
11294 _("string table"));
11295 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11298 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11300 const char *version_string
;
11301 enum versioned_symbol_info sym_info
;
11302 unsigned short vna_other
;
11304 printf ("%6d: ", si
);
11305 print_vma (psym
->st_value
, LONG_HEX
);
11307 print_vma (psym
->st_size
, DEC_5
);
11308 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11309 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11310 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11311 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11314 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11316 printf (" %-7s", get_symbol_visibility (vis
));
11317 /* Check to see if any other bits in the st_other field are set.
11318 Note - displaying this information disrupts the layout of the
11319 table being generated, but for the moment this case is very rare. */
11320 if (psym
->st_other
^ vis
)
11321 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11323 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11324 print_symbol (25, psym
->st_name
< strtab_size
11325 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11328 = get_symbol_version_string (file
,
11329 section
->sh_type
== SHT_DYNSYM
,
11330 strtab
, strtab_size
, si
,
11331 psym
, &sym_info
, &vna_other
);
11332 if (version_string
)
11334 if (sym_info
== symbol_undefined
)
11335 printf ("@%s (%d)", version_string
, vna_other
);
11337 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11343 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11344 && si
>= section
->sh_info
11345 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11346 && elf_header
.e_machine
!= EM_MIPS
11347 /* Solaris binaries have been found to violate this requirement as
11348 well. Not sure if this is a bug or an ABI requirement. */
11349 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11350 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11351 si
, printable_section_name (section
), section
->sh_info
);
11355 if (strtab
!= string_table
)
11361 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11363 if (do_histogram
&& buckets
!= NULL
)
11365 unsigned long * lengths
;
11366 unsigned long * counts
;
11369 unsigned long maxlength
= 0;
11370 unsigned long nzero_counts
= 0;
11371 unsigned long nsyms
= 0;
11372 unsigned long chained
;
11374 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11375 (unsigned long) nbuckets
);
11377 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11378 if (lengths
== NULL
)
11380 error (_("Out of memory allocating space for histogram buckets\n"));
11384 printf (_(" Length Number %% of total Coverage\n"));
11385 for (hn
= 0; hn
< nbuckets
; ++hn
)
11387 for (si
= buckets
[hn
], chained
= 0;
11388 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11389 si
= chains
[si
], ++chained
)
11392 if (maxlength
< ++lengths
[hn
])
11396 /* PR binutils/17531: A corrupt binary could contain broken
11397 histogram data. Do not go into an infinite loop trying
11399 if (chained
> nchains
)
11401 error (_("histogram chain is corrupt\n"));
11406 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11407 if (counts
== NULL
)
11410 error (_("Out of memory allocating space for histogram counts\n"));
11414 for (hn
= 0; hn
< nbuckets
; ++hn
)
11415 ++counts
[lengths
[hn
]];
11420 printf (" 0 %-10lu (%5.1f%%)\n",
11421 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11422 for (i
= 1; i
<= maxlength
; ++i
)
11424 nzero_counts
+= counts
[i
] * i
;
11425 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11426 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11427 (nzero_counts
* 100.0) / nsyms
);
11435 if (buckets
!= NULL
)
11441 if (do_histogram
&& gnubuckets
!= NULL
)
11443 unsigned long * lengths
;
11444 unsigned long * counts
;
11446 unsigned long maxlength
= 0;
11447 unsigned long nzero_counts
= 0;
11448 unsigned long nsyms
= 0;
11450 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11451 (unsigned long) ngnubuckets
);
11453 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11454 if (lengths
== NULL
)
11456 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11460 printf (_(" Length Number %% of total Coverage\n"));
11462 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11463 if (gnubuckets
[hn
] != 0)
11465 bfd_vma off
, length
= 1;
11467 for (off
= gnubuckets
[hn
] - gnusymidx
;
11468 /* PR 17531 file: 010-77222-0.004. */
11469 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11472 lengths
[hn
] = length
;
11473 if (length
> maxlength
)
11474 maxlength
= length
;
11478 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11479 if (counts
== NULL
)
11482 error (_("Out of memory allocating space for gnu histogram counts\n"));
11486 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11487 ++counts
[lengths
[hn
]];
11489 if (ngnubuckets
> 0)
11492 printf (" 0 %-10lu (%5.1f%%)\n",
11493 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11494 for (j
= 1; j
<= maxlength
; ++j
)
11496 nzero_counts
+= counts
[j
] * j
;
11497 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11498 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11499 (nzero_counts
* 100.0) / nsyms
);
11513 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11517 if (dynamic_syminfo
== NULL
11519 /* No syminfo, this is ok. */
11522 /* There better should be a dynamic symbol section. */
11523 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11527 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11528 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11530 printf (_(" Num: Name BoundTo Flags\n"));
11531 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11533 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11535 printf ("%4d: ", i
);
11536 if (i
>= num_dynamic_syms
)
11537 printf (_("<corrupt index>"));
11538 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11539 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11541 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11544 switch (dynamic_syminfo
[i
].si_boundto
)
11546 case SYMINFO_BT_SELF
:
11547 fputs ("SELF ", stdout
);
11549 case SYMINFO_BT_PARENT
:
11550 fputs ("PARENT ", stdout
);
11553 if (dynamic_syminfo
[i
].si_boundto
> 0
11554 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11555 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11557 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11561 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11565 if (flags
& SYMINFO_FLG_DIRECT
)
11566 printf (" DIRECT");
11567 if (flags
& SYMINFO_FLG_PASSTHRU
)
11568 printf (" PASSTHRU");
11569 if (flags
& SYMINFO_FLG_COPY
)
11571 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11572 printf (" LAZYLOAD");
11580 /* Check to see if the given reloc needs to be handled in a target specific
11581 manner. If so then process the reloc and return TRUE otherwise return
11585 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11586 unsigned char * start
,
11587 Elf_Internal_Sym
* symtab
)
11589 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11591 switch (elf_header
.e_machine
)
11594 case EM_MSP430_OLD
:
11596 static Elf_Internal_Sym
* saved_sym
= NULL
;
11598 switch (reloc_type
)
11600 case 10: /* R_MSP430_SYM_DIFF */
11601 if (uses_msp430x_relocs ())
11603 /* Fall through. */
11604 case 21: /* R_MSP430X_SYM_DIFF */
11605 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11608 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11609 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11610 goto handle_sym_diff
;
11612 case 5: /* R_MSP430_16_BYTE */
11613 case 9: /* R_MSP430_8 */
11614 if (uses_msp430x_relocs ())
11616 goto handle_sym_diff
;
11618 case 2: /* R_MSP430_ABS16 */
11619 case 15: /* R_MSP430X_ABS16 */
11620 if (! uses_msp430x_relocs ())
11622 goto handle_sym_diff
;
11625 if (saved_sym
!= NULL
)
11629 value
= reloc
->r_addend
11630 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11631 - saved_sym
->st_value
);
11633 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11641 if (saved_sym
!= NULL
)
11642 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11649 case EM_CYGNUS_MN10300
:
11651 static Elf_Internal_Sym
* saved_sym
= NULL
;
11653 switch (reloc_type
)
11655 case 34: /* R_MN10300_ALIGN */
11657 case 33: /* R_MN10300_SYM_DIFF */
11658 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11660 case 1: /* R_MN10300_32 */
11661 case 2: /* R_MN10300_16 */
11662 if (saved_sym
!= NULL
)
11666 value
= reloc
->r_addend
11667 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11668 - saved_sym
->st_value
);
11670 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11677 if (saved_sym
!= NULL
)
11678 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11686 static bfd_vma saved_sym1
= 0;
11687 static bfd_vma saved_sym2
= 0;
11688 static bfd_vma value
;
11690 switch (reloc_type
)
11692 case 0x80: /* R_RL78_SYM. */
11693 saved_sym1
= saved_sym2
;
11694 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11695 saved_sym2
+= reloc
->r_addend
;
11698 case 0x83: /* R_RL78_OPsub. */
11699 value
= saved_sym1
- saved_sym2
;
11700 saved_sym2
= saved_sym1
= 0;
11704 case 0x41: /* R_RL78_ABS32. */
11705 byte_put (start
+ reloc
->r_offset
, value
, 4);
11709 case 0x43: /* R_RL78_ABS16. */
11710 byte_put (start
+ reloc
->r_offset
, value
, 2);
11724 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11725 DWARF debug sections. This is a target specific test. Note - we do not
11726 go through the whole including-target-headers-multiple-times route, (as
11727 we have already done with <elf/h8.h>) because this would become very
11728 messy and even then this function would have to contain target specific
11729 information (the names of the relocs instead of their numeric values).
11730 FIXME: This is not the correct way to solve this problem. The proper way
11731 is to have target specific reloc sizing and typing functions created by
11732 the reloc-macros.h header, in the same way that it already creates the
11733 reloc naming functions. */
11736 is_32bit_abs_reloc (unsigned int reloc_type
)
11738 /* Please keep this table alpha-sorted for ease of visual lookup. */
11739 switch (elf_header
.e_machine
)
11743 return reloc_type
== 1; /* R_386_32. */
11745 return reloc_type
== 1; /* R_68K_32. */
11747 return reloc_type
== 1; /* R_860_32. */
11749 return reloc_type
== 2; /* R_960_32. */
11751 return (reloc_type
== 258
11752 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11753 case EM_ADAPTEVA_EPIPHANY
:
11754 return reloc_type
== 3;
11756 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11758 return reloc_type
== 1; /* R_ARC_32. */
11759 case EM_ARC_COMPACT
:
11760 case EM_ARC_COMPACT2
:
11761 return reloc_type
== 4; /* R_ARC_32. */
11763 return reloc_type
== 2; /* R_ARM_ABS32 */
11766 return reloc_type
== 1;
11768 return reloc_type
== 0x12; /* R_byte4_data. */
11770 return reloc_type
== 3; /* R_CRIS_32. */
11772 return reloc_type
== 3; /* R_CR16_NUM32. */
11774 return reloc_type
== 15; /* R_CRX_NUM32. */
11775 case EM_CYGNUS_FRV
:
11776 return reloc_type
== 1;
11777 case EM_CYGNUS_D10V
:
11779 return reloc_type
== 6; /* R_D10V_32. */
11780 case EM_CYGNUS_D30V
:
11782 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11784 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11785 case EM_CYGNUS_FR30
:
11787 return reloc_type
== 3; /* R_FR30_32. */
11789 return reloc_type
== 1; /* R_FT32_32. */
11793 return reloc_type
== 1; /* R_H8_DIR32. */
11795 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11796 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11799 return reloc_type
== 2; /* R_IP2K_32. */
11801 return reloc_type
== 2; /* R_IQ2000_32. */
11802 case EM_LATTICEMICO32
:
11803 return reloc_type
== 3; /* R_LM32_32. */
11806 return reloc_type
== 3; /* R_M32C_32. */
11808 return reloc_type
== 34; /* R_M32R_32_RELA. */
11811 return reloc_type
== 6; /* R_M68HC11_32. */
11813 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11814 case EM_CYGNUS_MEP
:
11815 return reloc_type
== 4; /* R_MEP_32. */
11817 return reloc_type
== 2; /* R_METAG_ADDR32. */
11818 case EM_MICROBLAZE
:
11819 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11821 return reloc_type
== 2; /* R_MIPS_32. */
11823 return reloc_type
== 4; /* R_MMIX_32. */
11824 case EM_CYGNUS_MN10200
:
11826 return reloc_type
== 1; /* R_MN10200_32. */
11827 case EM_CYGNUS_MN10300
:
11829 return reloc_type
== 1; /* R_MN10300_32. */
11831 return reloc_type
== 1; /* R_MOXIE_32. */
11832 case EM_MSP430_OLD
:
11834 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11836 return reloc_type
== 2; /* R_MT_32. */
11838 return reloc_type
== 20; /* R_NDS32_RELA. */
11839 case EM_ALTERA_NIOS2
:
11840 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11842 return reloc_type
== 1; /* R_NIOS_32. */
11844 return reloc_type
== 1; /* R_OR1K_32. */
11846 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11847 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11850 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11852 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11854 return reloc_type
== 1; /* R_PPC_ADDR32. */
11856 return reloc_type
== 1; /* R_RISCV_32. */
11858 return reloc_type
== 1; /* R_RL78_DIR32. */
11860 return reloc_type
== 1; /* R_RX_DIR32. */
11862 return reloc_type
== 1; /* R_I370_ADDR31. */
11865 return reloc_type
== 4; /* R_S390_32. */
11867 return reloc_type
== 8; /* R_SCORE_ABS32. */
11869 return reloc_type
== 1; /* R_SH_DIR32. */
11870 case EM_SPARC32PLUS
:
11873 return reloc_type
== 3 /* R_SPARC_32. */
11874 || reloc_type
== 23; /* R_SPARC_UA32. */
11876 return reloc_type
== 6; /* R_SPU_ADDR32 */
11878 return reloc_type
== 1; /* R_C6000_ABS32. */
11880 return reloc_type
== 2; /* R_TILEGX_32. */
11882 return reloc_type
== 1; /* R_TILEPRO_32. */
11883 case EM_CYGNUS_V850
:
11885 return reloc_type
== 6; /* R_V850_ABS32. */
11887 return reloc_type
== 0x33; /* R_V810_WORD. */
11889 return reloc_type
== 1; /* R_VAX_32. */
11891 return reloc_type
== 3; /* R_VISIUM_32. */
11895 return reloc_type
== 10; /* R_X86_64_32. */
11898 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11900 return reloc_type
== 4; /* R_XGATE_32. */
11902 return reloc_type
== 1; /* R_XSTROMY16_32. */
11903 case EM_XTENSA_OLD
:
11905 return reloc_type
== 1; /* R_XTENSA_32. */
11908 static unsigned int prev_warn
= 0;
11910 /* Avoid repeating the same warning multiple times. */
11911 if (prev_warn
!= elf_header
.e_machine
)
11912 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11913 elf_header
.e_machine
);
11914 prev_warn
= elf_header
.e_machine
;
11920 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11921 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11924 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11926 switch (elf_header
.e_machine
)
11927 /* Please keep this table alpha-sorted for ease of visual lookup. */
11931 return reloc_type
== 2; /* R_386_PC32. */
11933 return reloc_type
== 4; /* R_68K_PC32. */
11935 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11936 case EM_ADAPTEVA_EPIPHANY
:
11937 return reloc_type
== 6;
11939 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11940 case EM_ARC_COMPACT
:
11941 case EM_ARC_COMPACT2
:
11942 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11944 return reloc_type
== 3; /* R_ARM_REL32 */
11947 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11948 case EM_MICROBLAZE
:
11949 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11951 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11953 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11955 return reloc_type
== 26; /* R_PPC_REL32. */
11957 return reloc_type
== 26; /* R_PPC64_REL32. */
11960 return reloc_type
== 5; /* R_390_PC32. */
11962 return reloc_type
== 2; /* R_SH_REL32. */
11963 case EM_SPARC32PLUS
:
11966 return reloc_type
== 6; /* R_SPARC_DISP32. */
11968 return reloc_type
== 13; /* R_SPU_REL32. */
11970 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11972 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11974 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11978 return reloc_type
== 2; /* R_X86_64_PC32. */
11979 case EM_XTENSA_OLD
:
11981 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11983 /* Do not abort or issue an error message here. Not all targets use
11984 pc-relative 32-bit relocs in their DWARF debug information and we
11985 have already tested for target coverage in is_32bit_abs_reloc. A
11986 more helpful warning message will be generated by apply_relocations
11987 anyway, so just return. */
11992 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11993 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11996 is_64bit_abs_reloc (unsigned int reloc_type
)
11998 switch (elf_header
.e_machine
)
12001 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12003 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12005 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12007 return reloc_type
== 80; /* R_PARISC_DIR64. */
12009 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12011 return reloc_type
== 2; /* R_RISCV_64. */
12012 case EM_SPARC32PLUS
:
12015 return reloc_type
== 54; /* R_SPARC_UA64. */
12019 return reloc_type
== 1; /* R_X86_64_64. */
12022 return reloc_type
== 22; /* R_S390_64. */
12024 return reloc_type
== 1; /* R_TILEGX_64. */
12026 return reloc_type
== 18; /* R_MIPS_64. */
12032 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12033 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12036 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12038 switch (elf_header
.e_machine
)
12041 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12043 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12045 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12047 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12049 return reloc_type
== 44; /* R_PPC64_REL64. */
12050 case EM_SPARC32PLUS
:
12053 return reloc_type
== 46; /* R_SPARC_DISP64. */
12057 return reloc_type
== 24; /* R_X86_64_PC64. */
12060 return reloc_type
== 23; /* R_S390_PC64. */
12062 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12068 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12069 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12072 is_24bit_abs_reloc (unsigned int reloc_type
)
12074 switch (elf_header
.e_machine
)
12076 case EM_CYGNUS_MN10200
:
12078 return reloc_type
== 4; /* R_MN10200_24. */
12080 return reloc_type
== 5; /* R_FT32_20. */
12086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12087 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12090 is_16bit_abs_reloc (unsigned int reloc_type
)
12092 /* Please keep this table alpha-sorted for ease of visual lookup. */
12093 switch (elf_header
.e_machine
)
12096 case EM_ARC_COMPACT
:
12097 case EM_ARC_COMPACT2
:
12098 return reloc_type
== 2; /* R_ARC_16. */
12099 case EM_ADAPTEVA_EPIPHANY
:
12100 return reloc_type
== 5;
12103 return reloc_type
== 4; /* R_AVR_16. */
12104 case EM_CYGNUS_D10V
:
12106 return reloc_type
== 3; /* R_D10V_16. */
12110 return reloc_type
== R_H8_DIR16
;
12113 return reloc_type
== 1; /* R_IP2K_16. */
12116 return reloc_type
== 1; /* R_M32C_16 */
12117 case EM_CYGNUS_MN10200
:
12119 return reloc_type
== 2; /* R_MN10200_16. */
12120 case EM_CYGNUS_MN10300
:
12122 return reloc_type
== 2; /* R_MN10300_16. */
12124 if (uses_msp430x_relocs ())
12125 return reloc_type
== 2; /* R_MSP430_ABS16. */
12126 /* Fall through. */
12127 case EM_MSP430_OLD
:
12128 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12130 return reloc_type
== 19; /* R_NDS32_RELA. */
12131 case EM_ALTERA_NIOS2
:
12132 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12134 return reloc_type
== 9; /* R_NIOS_16. */
12136 return reloc_type
== 2; /* R_OR1K_16. */
12138 return reloc_type
== 2; /* R_C6000_ABS16. */
12140 return reloc_type
== 2; /* R_VISIUM_16. */
12143 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12145 return reloc_type
== 3; /* R_XGATE_16. */
12151 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12152 relocation entries (possibly formerly used for SHT_GROUP sections). */
12155 is_none_reloc (unsigned int reloc_type
)
12157 switch (elf_header
.e_machine
)
12159 case EM_386
: /* R_386_NONE. */
12160 case EM_68K
: /* R_68K_NONE. */
12161 case EM_ADAPTEVA_EPIPHANY
:
12162 case EM_ALPHA
: /* R_ALPHA_NONE. */
12163 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12164 case EM_ARC
: /* R_ARC_NONE. */
12165 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12166 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12167 case EM_ARM
: /* R_ARM_NONE. */
12168 case EM_C166
: /* R_XC16X_NONE. */
12169 case EM_CRIS
: /* R_CRIS_NONE. */
12170 case EM_FT32
: /* R_FT32_NONE. */
12171 case EM_IA_64
: /* R_IA64_NONE. */
12172 case EM_K1OM
: /* R_X86_64_NONE. */
12173 case EM_L1OM
: /* R_X86_64_NONE. */
12174 case EM_M32R
: /* R_M32R_NONE. */
12175 case EM_MIPS
: /* R_MIPS_NONE. */
12176 case EM_MN10300
: /* R_MN10300_NONE. */
12177 case EM_MOXIE
: /* R_MOXIE_NONE. */
12178 case EM_NIOS32
: /* R_NIOS_NONE. */
12179 case EM_OR1K
: /* R_OR1K_NONE. */
12180 case EM_PARISC
: /* R_PARISC_NONE. */
12181 case EM_PPC64
: /* R_PPC64_NONE. */
12182 case EM_PPC
: /* R_PPC_NONE. */
12183 case EM_RISCV
: /* R_RISCV_NONE. */
12184 case EM_S390
: /* R_390_NONE. */
12186 case EM_SH
: /* R_SH_NONE. */
12187 case EM_SPARC32PLUS
:
12188 case EM_SPARC
: /* R_SPARC_NONE. */
12190 case EM_TILEGX
: /* R_TILEGX_NONE. */
12191 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12192 case EM_TI_C6000
:/* R_C6000_NONE. */
12193 case EM_X86_64
: /* R_X86_64_NONE. */
12195 return reloc_type
== 0;
12198 return reloc_type
== 0 || reloc_type
== 256;
12201 return (reloc_type
== 0 /* R_AVR_NONE. */
12202 || reloc_type
== 30 /* R_AVR_DIFF8. */
12203 || reloc_type
== 31 /* R_AVR_DIFF16. */
12204 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12206 return reloc_type
== 3; /* R_METAG_NONE. */
12208 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12209 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12210 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12211 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12212 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12213 case EM_XTENSA_OLD
:
12215 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12216 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12217 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12218 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12223 /* Returns TRUE if there is a relocation against
12224 section NAME at OFFSET bytes. */
12227 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12229 Elf_Internal_Rela
* relocs
;
12230 Elf_Internal_Rela
* rp
;
12232 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12235 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12237 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12238 if (rp
->r_offset
== offset
)
12244 /* Apply relocations to a section.
12245 Note: So far support has been added only for those relocations
12246 which can be found in debug sections.
12247 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12248 loaded relocs. It is then the caller's responsibility to free them.
12249 FIXME: Add support for more relocations ? */
12252 apply_relocations (void * file
,
12253 const Elf_Internal_Shdr
* section
,
12254 unsigned char * start
,
12255 bfd_size_type size
,
12256 void ** relocs_return
,
12257 unsigned long * num_relocs_return
)
12259 Elf_Internal_Shdr
* relsec
;
12260 unsigned char * end
= start
+ size
;
12262 if (relocs_return
!= NULL
)
12264 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12265 * num_relocs_return
= 0;
12268 if (elf_header
.e_type
!= ET_REL
)
12271 /* Find the reloc section associated with the section. */
12272 for (relsec
= section_headers
;
12273 relsec
< section_headers
+ elf_header
.e_shnum
;
12276 bfd_boolean is_rela
;
12277 unsigned long num_relocs
;
12278 Elf_Internal_Rela
* relocs
;
12279 Elf_Internal_Rela
* rp
;
12280 Elf_Internal_Shdr
* symsec
;
12281 Elf_Internal_Sym
* symtab
;
12282 unsigned long num_syms
;
12283 Elf_Internal_Sym
* sym
;
12285 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12286 || relsec
->sh_info
>= elf_header
.e_shnum
12287 || section_headers
+ relsec
->sh_info
!= section
12288 || relsec
->sh_size
== 0
12289 || relsec
->sh_link
>= elf_header
.e_shnum
)
12292 is_rela
= relsec
->sh_type
== SHT_RELA
;
12296 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12297 relsec
->sh_size
, & relocs
, & num_relocs
))
12302 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12303 relsec
->sh_size
, & relocs
, & num_relocs
))
12307 /* SH uses RELA but uses in place value instead of the addend field. */
12308 if (elf_header
.e_machine
== EM_SH
)
12311 symsec
= section_headers
+ relsec
->sh_link
;
12312 if (symsec
->sh_type
!= SHT_SYMTAB
12313 && symsec
->sh_type
!= SHT_DYNSYM
)
12315 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12317 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12320 unsigned int reloc_type
;
12321 unsigned int reloc_size
;
12322 unsigned char * rloc
;
12323 unsigned long sym_index
;
12325 reloc_type
= get_reloc_type (rp
->r_info
);
12327 if (target_specific_reloc_handling (rp
, start
, symtab
))
12329 else if (is_none_reloc (reloc_type
))
12331 else if (is_32bit_abs_reloc (reloc_type
)
12332 || is_32bit_pcrel_reloc (reloc_type
))
12334 else if (is_64bit_abs_reloc (reloc_type
)
12335 || is_64bit_pcrel_reloc (reloc_type
))
12337 else if (is_24bit_abs_reloc (reloc_type
))
12339 else if (is_16bit_abs_reloc (reloc_type
))
12343 static unsigned int prev_reloc
= 0;
12344 if (reloc_type
!= prev_reloc
)
12345 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12346 reloc_type
, printable_section_name (section
));
12347 prev_reloc
= reloc_type
;
12351 rloc
= start
+ rp
->r_offset
;
12352 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12354 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12355 (unsigned long) rp
->r_offset
,
12356 printable_section_name (section
));
12360 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12361 if (sym_index
>= num_syms
)
12363 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12364 sym_index
, printable_section_name (section
));
12367 sym
= symtab
+ sym_index
;
12369 /* If the reloc has a symbol associated with it,
12370 make sure that it is of an appropriate type.
12372 Relocations against symbols without type can happen.
12373 Gcc -feliminate-dwarf2-dups may generate symbols
12374 without type for debug info.
12376 Icc generates relocations against function symbols
12377 instead of local labels.
12379 Relocations against object symbols can happen, eg when
12380 referencing a global array. For an example of this see
12381 the _clz.o binary in libgcc.a. */
12383 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12384 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12386 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12387 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12388 (long int)(rp
- relocs
),
12389 printable_section_name (relsec
));
12395 addend
+= rp
->r_addend
;
12396 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12397 partial_inplace. */
12399 || (elf_header
.e_machine
== EM_XTENSA
12400 && reloc_type
== 1)
12401 || ((elf_header
.e_machine
== EM_PJ
12402 || elf_header
.e_machine
== EM_PJ_OLD
)
12403 && reloc_type
== 1)
12404 || ((elf_header
.e_machine
== EM_D30V
12405 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12406 && reloc_type
== 12))
12407 addend
+= byte_get (rloc
, reloc_size
);
12409 if (is_32bit_pcrel_reloc (reloc_type
)
12410 || is_64bit_pcrel_reloc (reloc_type
))
12412 /* On HPPA, all pc-relative relocations are biased by 8. */
12413 if (elf_header
.e_machine
== EM_PARISC
)
12415 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12419 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12426 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12427 * num_relocs_return
= num_relocs
;
12436 #ifdef SUPPORT_DISASSEMBLY
12438 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12440 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12442 /* FIXME: XXX -- to be done --- XXX */
12448 /* Reads in the contents of SECTION from FILE, returning a pointer
12449 to a malloc'ed buffer or NULL if something went wrong. */
12452 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12454 bfd_size_type num_bytes
;
12456 num_bytes
= section
->sh_size
;
12458 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12460 printf (_("\nSection '%s' has no data to dump.\n"),
12461 printable_section_name (section
));
12465 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12466 _("section contents"));
12469 /* Uncompresses a section that was compressed using zlib, in place. */
12472 uncompress_section_contents (unsigned char **buffer
,
12473 dwarf_size_type uncompressed_size
,
12474 dwarf_size_type
*size
)
12476 dwarf_size_type compressed_size
= *size
;
12477 unsigned char * compressed_buffer
= *buffer
;
12478 unsigned char * uncompressed_buffer
;
12482 /* It is possible the section consists of several compressed
12483 buffers concatenated together, so we uncompress in a loop. */
12484 /* PR 18313: The state field in the z_stream structure is supposed
12485 to be invisible to the user (ie us), but some compilers will
12486 still complain about it being used without initialisation. So
12487 we first zero the entire z_stream structure and then set the fields
12489 memset (& strm
, 0, sizeof strm
);
12490 strm
.avail_in
= compressed_size
;
12491 strm
.next_in
= (Bytef
*) compressed_buffer
;
12492 strm
.avail_out
= uncompressed_size
;
12493 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12495 rc
= inflateInit (& strm
);
12496 while (strm
.avail_in
> 0)
12500 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12501 + (uncompressed_size
- strm
.avail_out
));
12502 rc
= inflate (&strm
, Z_FINISH
);
12503 if (rc
!= Z_STREAM_END
)
12505 rc
= inflateReset (& strm
);
12507 rc
= inflateEnd (& strm
);
12509 || strm
.avail_out
!= 0)
12512 *buffer
= uncompressed_buffer
;
12513 *size
= uncompressed_size
;
12517 free (uncompressed_buffer
);
12518 /* Indicate decompression failure. */
12524 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12526 Elf_Internal_Shdr
* relsec
;
12527 bfd_size_type num_bytes
;
12528 unsigned char * data
;
12529 unsigned char * end
;
12530 unsigned char * real_start
;
12531 unsigned char * start
;
12532 bfd_boolean some_strings_shown
;
12534 real_start
= start
= (unsigned char *) get_section_contents (section
,
12538 num_bytes
= section
->sh_size
;
12540 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12542 if (decompress_dumps
)
12544 dwarf_size_type new_size
= num_bytes
;
12545 dwarf_size_type uncompressed_size
= 0;
12547 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12549 Elf_Internal_Chdr chdr
;
12550 unsigned int compression_header_size
12551 = get_compression_header (& chdr
, (unsigned char *) start
);
12553 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12555 warn (_("section '%s' has unsupported compress type: %d\n"),
12556 printable_section_name (section
), chdr
.ch_type
);
12559 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12561 warn (_("compressed section '%s' is corrupted\n"),
12562 printable_section_name (section
));
12565 uncompressed_size
= chdr
.ch_size
;
12566 start
+= compression_header_size
;
12567 new_size
-= compression_header_size
;
12569 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12571 /* Read the zlib header. In this case, it should be "ZLIB"
12572 followed by the uncompressed section size, 8 bytes in
12573 big-endian order. */
12574 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12575 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12576 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12577 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12578 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12579 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12580 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12581 uncompressed_size
+= start
[11];
12586 if (uncompressed_size
12587 && uncompress_section_contents (& start
,
12588 uncompressed_size
, & new_size
))
12589 num_bytes
= new_size
;
12592 /* If the section being dumped has relocations against it the user might
12593 be expecting these relocations to have been applied. Check for this
12594 case and issue a warning message in order to avoid confusion.
12595 FIXME: Maybe we ought to have an option that dumps a section with
12596 relocs applied ? */
12597 for (relsec
= section_headers
;
12598 relsec
< section_headers
+ elf_header
.e_shnum
;
12601 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12602 || relsec
->sh_info
>= elf_header
.e_shnum
12603 || section_headers
+ relsec
->sh_info
!= section
12604 || relsec
->sh_size
== 0
12605 || relsec
->sh_link
>= elf_header
.e_shnum
)
12608 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12613 end
= start
+ num_bytes
;
12614 some_strings_shown
= FALSE
;
12618 while (!ISPRINT (* data
))
12619 if (++ data
>= end
)
12624 size_t maxlen
= end
- data
;
12627 /* PR 11128: Use two separate invocations in order to work
12628 around bugs in the Solaris 8 implementation of printf. */
12629 printf (" [%6tx] ", data
- start
);
12631 printf (" [%6Ix] ", (size_t) (data
- start
));
12635 print_symbol ((int) maxlen
, (const char *) data
);
12637 data
+= strnlen ((const char *) data
, maxlen
);
12641 printf (_("<corrupt>\n"));
12644 some_strings_shown
= TRUE
;
12648 if (! some_strings_shown
)
12649 printf (_(" No strings found in this section."));
12657 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12659 bfd_boolean relocate
)
12661 Elf_Internal_Shdr
* relsec
;
12662 bfd_size_type bytes
;
12663 bfd_size_type section_size
;
12665 unsigned char * data
;
12666 unsigned char * real_start
;
12667 unsigned char * start
;
12669 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12672 section_size
= section
->sh_size
;
12674 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12676 if (decompress_dumps
)
12678 dwarf_size_type new_size
= section_size
;
12679 dwarf_size_type uncompressed_size
= 0;
12681 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12683 Elf_Internal_Chdr chdr
;
12684 unsigned int compression_header_size
12685 = get_compression_header (& chdr
, start
);
12687 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12689 warn (_("section '%s' has unsupported compress type: %d\n"),
12690 printable_section_name (section
), chdr
.ch_type
);
12693 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12695 warn (_("compressed section '%s' is corrupted\n"),
12696 printable_section_name (section
));
12699 uncompressed_size
= chdr
.ch_size
;
12700 start
+= compression_header_size
;
12701 new_size
-= compression_header_size
;
12703 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12705 /* Read the zlib header. In this case, it should be "ZLIB"
12706 followed by the uncompressed section size, 8 bytes in
12707 big-endian order. */
12708 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12709 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12710 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12711 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12712 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12713 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12714 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12715 uncompressed_size
+= start
[11];
12720 if (uncompressed_size
12721 && uncompress_section_contents (& start
, uncompressed_size
,
12723 section_size
= new_size
;
12728 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12732 /* If the section being dumped has relocations against it the user might
12733 be expecting these relocations to have been applied. Check for this
12734 case and issue a warning message in order to avoid confusion.
12735 FIXME: Maybe we ought to have an option that dumps a section with
12736 relocs applied ? */
12737 for (relsec
= section_headers
;
12738 relsec
< section_headers
+ elf_header
.e_shnum
;
12741 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12742 || relsec
->sh_info
>= elf_header
.e_shnum
12743 || section_headers
+ relsec
->sh_info
!= section
12744 || relsec
->sh_size
== 0
12745 || relsec
->sh_link
>= elf_header
.e_shnum
)
12748 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12753 addr
= section
->sh_addr
;
12754 bytes
= section_size
;
12763 lbytes
= (bytes
> 16 ? 16 : bytes
);
12765 printf (" 0x%8.8lx ", (unsigned long) addr
);
12767 for (j
= 0; j
< 16; j
++)
12770 printf ("%2.2x", data
[j
]);
12778 for (j
= 0; j
< lbytes
; j
++)
12781 if (k
>= ' ' && k
< 0x7f)
12800 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12801 const Elf_Internal_Shdr
* sec
, void * file
)
12803 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12806 /* If it is already loaded, do nothing. */
12807 if (section
->start
!= NULL
)
12810 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12811 section
->address
= sec
->sh_addr
;
12812 section
->user_data
= NULL
;
12813 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12815 sec
->sh_size
, buf
);
12816 if (section
->start
== NULL
)
12820 unsigned char *start
= section
->start
;
12821 dwarf_size_type size
= sec
->sh_size
;
12822 dwarf_size_type uncompressed_size
= 0;
12824 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12826 Elf_Internal_Chdr chdr
;
12827 unsigned int compression_header_size
;
12829 if (size
< (is_32bit_elf
12830 ? sizeof (Elf32_External_Chdr
)
12831 : sizeof (Elf64_External_Chdr
)))
12833 warn (_("compressed section %s is too small to contain a compression header"),
12838 compression_header_size
= get_compression_header (&chdr
, start
);
12840 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12842 warn (_("section '%s' has unsupported compress type: %d\n"),
12843 section
->name
, chdr
.ch_type
);
12846 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12848 warn (_("compressed section '%s' is corrupted\n"),
12852 uncompressed_size
= chdr
.ch_size
;
12853 start
+= compression_header_size
;
12854 size
-= compression_header_size
;
12856 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12858 /* Read the zlib header. In this case, it should be "ZLIB"
12859 followed by the uncompressed section size, 8 bytes in
12860 big-endian order. */
12861 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12862 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12863 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12864 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12865 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12866 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12867 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12868 uncompressed_size
+= start
[11];
12873 if (uncompressed_size
12874 && uncompress_section_contents (&start
, uncompressed_size
,
12877 /* Free the compressed buffer, update the section buffer
12878 and the section size if uncompress is successful. */
12879 free (section
->start
);
12880 section
->start
= start
;
12882 section
->size
= size
;
12885 if (section
->start
== NULL
)
12888 if (debug_displays
[debug
].relocate
)
12889 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12890 & section
->reloc_info
, & section
->num_relocs
);
12893 section
->reloc_info
= NULL
;
12894 section
->num_relocs
= 0;
12900 /* If this is not NULL, load_debug_section will only look for sections
12901 within the list of sections given here. */
12902 unsigned int *section_subset
= NULL
;
12905 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12907 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12908 Elf_Internal_Shdr
* sec
;
12910 /* Locate the debug section. */
12911 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12913 section
->name
= section
->uncompressed_name
;
12916 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12918 section
->name
= section
->compressed_name
;
12923 /* If we're loading from a subset of sections, and we've loaded
12924 a section matching this name before, it's likely that it's a
12926 if (section_subset
!= NULL
)
12927 free_debug_section (debug
);
12929 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12933 free_debug_section (enum dwarf_section_display_enum debug
)
12935 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12937 if (section
->start
== NULL
)
12940 free ((char *) section
->start
);
12941 section
->start
= NULL
;
12942 section
->address
= 0;
12947 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12949 char * name
= SECTION_NAME (section
);
12950 const char * print_name
= printable_section_name (section
);
12951 bfd_size_type length
;
12955 length
= section
->sh_size
;
12958 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12961 if (section
->sh_type
== SHT_NOBITS
)
12963 /* There is no point in dumping the contents of a debugging section
12964 which has the NOBITS type - the bits in the file will be random.
12965 This can happen when a file containing a .eh_frame section is
12966 stripped with the --only-keep-debug command line option. */
12967 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12972 if (const_strneq (name
, ".gnu.linkonce.wi."))
12973 name
= ".debug_info";
12975 /* See if we know how to display the contents of this section. */
12976 for (i
= 0; i
< max
; i
++)
12977 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12978 || (i
== line
&& const_strneq (name
, ".debug_line."))
12979 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12981 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12982 int secondary
= (section
!= find_section (name
));
12985 free_debug_section ((enum dwarf_section_display_enum
) i
);
12987 if (i
== line
&& const_strneq (name
, ".debug_line."))
12989 else if (streq (sec
->uncompressed_name
, name
))
12990 sec
->name
= sec
->uncompressed_name
;
12992 sec
->name
= sec
->compressed_name
;
12993 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12996 /* If this debug section is part of a CU/TU set in a .dwp file,
12997 restrict load_debug_section to the sections in that set. */
12998 section_subset
= find_cu_tu_set (file
, shndx
);
13000 result
&= debug_displays
[i
].display (sec
, file
);
13002 section_subset
= NULL
;
13004 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13005 free_debug_section ((enum dwarf_section_display_enum
) i
);
13013 printf (_("Unrecognized debug section: %s\n"), print_name
);
13020 /* Set DUMP_SECTS for all sections where dumps were requested
13021 based on section name. */
13024 initialise_dumps_byname (void)
13026 struct dump_list_entry
* cur
;
13028 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13033 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13034 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13036 request_dump_bynumber (i
, cur
->type
);
13041 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13047 process_section_contents (FILE * file
)
13049 Elf_Internal_Shdr
* section
;
13055 initialise_dumps_byname ();
13057 for (i
= 0, section
= section_headers
;
13058 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13061 #ifdef SUPPORT_DISASSEMBLY
13062 if (dump_sects
[i
] & DISASS_DUMP
)
13063 disassemble_section (section
, file
);
13065 if (dump_sects
[i
] & HEX_DUMP
)
13066 dump_section_as_bytes (section
, file
, FALSE
);
13068 if (dump_sects
[i
] & RELOC_DUMP
)
13069 dump_section_as_bytes (section
, file
, TRUE
);
13071 if (dump_sects
[i
] & STRING_DUMP
)
13072 dump_section_as_strings (section
, file
);
13074 if (dump_sects
[i
] & DEBUG_DUMP
)
13075 display_debug_section (i
, section
, file
);
13078 /* Check to see if the user requested a
13079 dump of a section that does not exist. */
13080 while (i
++ < num_dump_sects
)
13082 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13086 process_mips_fpe_exception (int mask
)
13091 if (mask
& OEX_FPU_INEX
)
13092 fputs ("INEX", stdout
), first
= 0;
13093 if (mask
& OEX_FPU_UFLO
)
13094 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13095 if (mask
& OEX_FPU_OFLO
)
13096 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13097 if (mask
& OEX_FPU_DIV0
)
13098 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13099 if (mask
& OEX_FPU_INVAL
)
13100 printf ("%sINVAL", first
? "" : "|");
13103 fputs ("0", stdout
);
13106 /* Display's the value of TAG at location P. If TAG is
13107 greater than 0 it is assumed to be an unknown tag, and
13108 a message is printed to this effect. Otherwise it is
13109 assumed that a message has already been printed.
13111 If the bottom bit of TAG is set it assumed to have a
13112 string value, otherwise it is assumed to have an integer
13115 Returns an updated P pointing to the first unread byte
13116 beyond the end of TAG's value.
13118 Reads at or beyond END will not be made. */
13120 static unsigned char *
13121 display_tag_value (int tag
,
13123 const unsigned char * const end
)
13128 printf (" Tag_unknown_%d: ", tag
);
13132 warn (_("<corrupt tag>\n"));
13136 /* PR 17531 file: 027-19978-0.004. */
13137 size_t maxlen
= (end
- p
) - 1;
13142 print_symbol ((int) maxlen
, (const char *) p
);
13143 p
+= strnlen ((char *) p
, maxlen
) + 1;
13147 printf (_("<corrupt string tag>"));
13148 p
= (unsigned char *) end
;
13156 val
= read_uleb128 (p
, &len
, end
);
13158 printf ("%ld (0x%lx)\n", val
, val
);
13165 /* ARM EABI attributes section. */
13170 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13172 const char ** table
;
13173 } arm_attr_public_tag
;
13175 static const char * arm_attr_tag_CPU_arch
[] =
13176 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13177 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13179 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13180 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13181 {"No", "Thumb-1", "Thumb-2", "Yes"};
13182 static const char * arm_attr_tag_FP_arch
[] =
13183 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13184 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13185 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13186 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13187 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13188 "NEON for ARMv8.1"};
13189 static const char * arm_attr_tag_PCS_config
[] =
13190 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13191 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13192 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13193 {"V6", "SB", "TLS", "Unused"};
13194 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13195 {"Absolute", "PC-relative", "SB-relative", "None"};
13196 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13197 {"Absolute", "PC-relative", "None"};
13198 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13199 {"None", "direct", "GOT-indirect"};
13200 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13201 {"None", "??? 1", "2", "??? 3", "4"};
13202 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13203 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13204 {"Unused", "Needed", "Sign only"};
13205 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13206 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13207 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13208 {"Unused", "Finite", "RTABI", "IEEE 754"};
13209 static const char * arm_attr_tag_ABI_enum_size
[] =
13210 {"Unused", "small", "int", "forced to int"};
13211 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13212 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13213 static const char * arm_attr_tag_ABI_VFP_args
[] =
13214 {"AAPCS", "VFP registers", "custom", "compatible"};
13215 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13216 {"AAPCS", "WMMX registers", "custom"};
13217 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13218 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13219 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13220 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13221 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13222 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13223 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13224 static const char * arm_attr_tag_FP_HP_extension
[] =
13225 {"Not Allowed", "Allowed"};
13226 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13227 {"None", "IEEE 754", "Alternative Format"};
13228 static const char * arm_attr_tag_DSP_extension
[] =
13229 {"Follow architecture", "Allowed"};
13230 static const char * arm_attr_tag_MPextension_use
[] =
13231 {"Not Allowed", "Allowed"};
13232 static const char * arm_attr_tag_DIV_use
[] =
13233 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13234 "Allowed in v7-A with integer division extension"};
13235 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13236 static const char * arm_attr_tag_Virtualization_use
[] =
13237 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13238 "TrustZone and Virtualization Extensions"};
13239 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13240 {"Not Allowed", "Allowed"};
13242 #define LOOKUP(id, name) \
13243 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13244 static arm_attr_public_tag arm_attr_public_tags
[] =
13246 {4, "CPU_raw_name", 1, NULL
},
13247 {5, "CPU_name", 1, NULL
},
13248 LOOKUP(6, CPU_arch
),
13249 {7, "CPU_arch_profile", 0, NULL
},
13250 LOOKUP(8, ARM_ISA_use
),
13251 LOOKUP(9, THUMB_ISA_use
),
13252 LOOKUP(10, FP_arch
),
13253 LOOKUP(11, WMMX_arch
),
13254 LOOKUP(12, Advanced_SIMD_arch
),
13255 LOOKUP(13, PCS_config
),
13256 LOOKUP(14, ABI_PCS_R9_use
),
13257 LOOKUP(15, ABI_PCS_RW_data
),
13258 LOOKUP(16, ABI_PCS_RO_data
),
13259 LOOKUP(17, ABI_PCS_GOT_use
),
13260 LOOKUP(18, ABI_PCS_wchar_t
),
13261 LOOKUP(19, ABI_FP_rounding
),
13262 LOOKUP(20, ABI_FP_denormal
),
13263 LOOKUP(21, ABI_FP_exceptions
),
13264 LOOKUP(22, ABI_FP_user_exceptions
),
13265 LOOKUP(23, ABI_FP_number_model
),
13266 {24, "ABI_align_needed", 0, NULL
},
13267 {25, "ABI_align_preserved", 0, NULL
},
13268 LOOKUP(26, ABI_enum_size
),
13269 LOOKUP(27, ABI_HardFP_use
),
13270 LOOKUP(28, ABI_VFP_args
),
13271 LOOKUP(29, ABI_WMMX_args
),
13272 LOOKUP(30, ABI_optimization_goals
),
13273 LOOKUP(31, ABI_FP_optimization_goals
),
13274 {32, "compatibility", 0, NULL
},
13275 LOOKUP(34, CPU_unaligned_access
),
13276 LOOKUP(36, FP_HP_extension
),
13277 LOOKUP(38, ABI_FP_16bit_format
),
13278 LOOKUP(42, MPextension_use
),
13279 LOOKUP(44, DIV_use
),
13280 LOOKUP(46, DSP_extension
),
13281 {64, "nodefaults", 0, NULL
},
13282 {65, "also_compatible_with", 0, NULL
},
13283 LOOKUP(66, T2EE_use
),
13284 {67, "conformance", 1, NULL
},
13285 LOOKUP(68, Virtualization_use
),
13286 LOOKUP(70, MPextension_use_legacy
)
13290 static unsigned char *
13291 display_arm_attribute (unsigned char * p
,
13292 const unsigned char * const end
)
13297 arm_attr_public_tag
* attr
;
13301 tag
= read_uleb128 (p
, &len
, end
);
13304 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13306 if (arm_attr_public_tags
[i
].tag
== tag
)
13308 attr
= &arm_attr_public_tags
[i
];
13315 printf (" Tag_%s: ", attr
->name
);
13316 switch (attr
->type
)
13321 case 7: /* Tag_CPU_arch_profile. */
13322 val
= read_uleb128 (p
, &len
, end
);
13326 case 0: printf (_("None\n")); break;
13327 case 'A': printf (_("Application\n")); break;
13328 case 'R': printf (_("Realtime\n")); break;
13329 case 'M': printf (_("Microcontroller\n")); break;
13330 case 'S': printf (_("Application or Realtime\n")); break;
13331 default: printf ("??? (%d)\n", val
); break;
13335 case 24: /* Tag_align_needed. */
13336 val
= read_uleb128 (p
, &len
, end
);
13340 case 0: printf (_("None\n")); break;
13341 case 1: printf (_("8-byte\n")); break;
13342 case 2: printf (_("4-byte\n")); break;
13343 case 3: printf ("??? 3\n"); break;
13346 printf (_("8-byte and up to %d-byte extended\n"),
13349 printf ("??? (%d)\n", val
);
13354 case 25: /* Tag_align_preserved. */
13355 val
= read_uleb128 (p
, &len
, end
);
13359 case 0: printf (_("None\n")); break;
13360 case 1: printf (_("8-byte, except leaf SP\n")); break;
13361 case 2: printf (_("8-byte\n")); break;
13362 case 3: printf ("??? 3\n"); break;
13365 printf (_("8-byte and up to %d-byte extended\n"),
13368 printf ("??? (%d)\n", val
);
13373 case 32: /* Tag_compatibility. */
13375 val
= read_uleb128 (p
, &len
, end
);
13377 printf (_("flag = %d, vendor = "), val
);
13380 size_t maxlen
= (end
- p
) - 1;
13382 print_symbol ((int) maxlen
, (const char *) p
);
13383 p
+= strnlen ((char *) p
, maxlen
) + 1;
13387 printf (_("<corrupt>"));
13388 p
= (unsigned char *) end
;
13394 case 64: /* Tag_nodefaults. */
13395 /* PR 17531: file: 001-505008-0.01. */
13398 printf (_("True\n"));
13401 case 65: /* Tag_also_compatible_with. */
13402 val
= read_uleb128 (p
, &len
, end
);
13404 if (val
== 6 /* Tag_CPU_arch. */)
13406 val
= read_uleb128 (p
, &len
, end
);
13408 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13409 printf ("??? (%d)\n", val
);
13411 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13415 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13420 printf (_("<unknown: %d>\n"), tag
);
13426 return display_tag_value (-1, p
, end
);
13428 return display_tag_value (0, p
, end
);
13431 assert (attr
->type
& 0x80);
13432 val
= read_uleb128 (p
, &len
, end
);
13434 type
= attr
->type
& 0x7f;
13436 printf ("??? (%d)\n", val
);
13438 printf ("%s\n", attr
->table
[val
]);
13443 return display_tag_value (tag
, p
, end
);
13446 static unsigned char *
13447 display_gnu_attribute (unsigned char * p
,
13448 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13449 const unsigned char * const end
)
13455 tag
= read_uleb128 (p
, &len
, end
);
13458 /* Tag_compatibility is the only generic GNU attribute defined at
13462 val
= read_uleb128 (p
, &len
, end
);
13465 printf (_("flag = %d, vendor = "), val
);
13468 printf (_("<corrupt>\n"));
13469 warn (_("corrupt vendor attribute\n"));
13475 size_t maxlen
= (end
- p
) - 1;
13477 print_symbol ((int) maxlen
, (const char *) p
);
13478 p
+= strnlen ((char *) p
, maxlen
) + 1;
13482 printf (_("<corrupt>"));
13483 p
= (unsigned char *) end
;
13490 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13491 return display_proc_gnu_attribute (p
, tag
, end
);
13493 return display_tag_value (tag
, p
, end
);
13496 static unsigned char *
13497 display_power_gnu_attribute (unsigned char * p
,
13499 const unsigned char * const end
)
13504 if (tag
== Tag_GNU_Power_ABI_FP
)
13506 val
= read_uleb128 (p
, &len
, end
);
13508 printf (" Tag_GNU_Power_ABI_FP: ");
13511 printf (_("<corrupt>\n"));
13516 printf ("(%#x), ", val
);
13521 printf (_("unspecified hard/soft float, "));
13524 printf (_("hard float, "));
13527 printf (_("soft float, "));
13530 printf (_("single-precision hard float, "));
13537 printf (_("unspecified long double\n"));
13540 printf (_("128-bit IBM long double\n"));
13543 printf (_("64-bit long double\n"));
13546 printf (_("128-bit IEEE long double\n"));
13552 if (tag
== Tag_GNU_Power_ABI_Vector
)
13554 val
= read_uleb128 (p
, &len
, end
);
13556 printf (" Tag_GNU_Power_ABI_Vector: ");
13559 printf (_("<corrupt>\n"));
13564 printf ("(%#x), ", val
);
13569 printf (_("unspecified\n"));
13572 printf (_("generic\n"));
13575 printf ("AltiVec\n");
13584 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13586 val
= read_uleb128 (p
, &len
, end
);
13588 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13591 printf (_("<corrupt>\n"));
13596 printf ("(%#x), ", val
);
13601 printf (_("unspecified\n"));
13604 printf ("r3/r4\n");
13607 printf (_("memory\n"));
13616 return display_tag_value (tag
& 1, p
, end
);
13619 static unsigned char *
13620 display_s390_gnu_attribute (unsigned char * p
,
13622 const unsigned char * const end
)
13627 if (tag
== Tag_GNU_S390_ABI_Vector
)
13629 val
= read_uleb128 (p
, &len
, end
);
13631 printf (" Tag_GNU_S390_ABI_Vector: ");
13636 printf (_("any\n"));
13639 printf (_("software\n"));
13642 printf (_("hardware\n"));
13645 printf ("??? (%d)\n", val
);
13651 return display_tag_value (tag
& 1, p
, end
);
13655 display_sparc_hwcaps (int mask
)
13661 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13662 fputs ("mul32", stdout
), first
= 0;
13663 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13664 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13665 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13666 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13667 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13668 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13669 if (mask
& ELF_SPARC_HWCAP_POPC
)
13670 printf ("%spopc", first
? "" : "|"), first
= 0;
13671 if (mask
& ELF_SPARC_HWCAP_VIS
)
13672 printf ("%svis", first
? "" : "|"), first
= 0;
13673 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13674 printf ("%svis2", first
? "" : "|"), first
= 0;
13675 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13676 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13677 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13678 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13679 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13680 printf ("%svis3", first
? "" : "|"), first
= 0;
13681 if (mask
& ELF_SPARC_HWCAP_HPC
)
13682 printf ("%shpc", first
? "" : "|"), first
= 0;
13683 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13684 printf ("%srandom", first
? "" : "|"), first
= 0;
13685 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13686 printf ("%strans", first
? "" : "|"), first
= 0;
13687 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13688 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13689 if (mask
& ELF_SPARC_HWCAP_IMA
)
13690 printf ("%sima", first
? "" : "|"), first
= 0;
13691 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13692 printf ("%scspare", first
? "" : "|"), first
= 0;
13695 fputc ('0', stdout
);
13696 fputc ('\n', stdout
);
13700 display_sparc_hwcaps2 (int mask
)
13706 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13707 fputs ("fjathplus", stdout
), first
= 0;
13708 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13709 printf ("%svis3b", first
? "" : "|"), first
= 0;
13710 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13711 printf ("%sadp", first
? "" : "|"), first
= 0;
13712 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13713 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13714 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13715 printf ("%smwait", first
? "" : "|"), first
= 0;
13716 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13717 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13718 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13719 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13720 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13721 printf ("%snsec", first
? "" : "|"), first
= 0;
13722 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13723 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13724 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13725 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13726 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13727 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13730 fputc ('0', stdout
);
13731 fputc ('\n', stdout
);
13734 static unsigned char *
13735 display_sparc_gnu_attribute (unsigned char * p
,
13737 const unsigned char * const end
)
13742 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13744 val
= read_uleb128 (p
, &len
, end
);
13746 printf (" Tag_GNU_Sparc_HWCAPS: ");
13747 display_sparc_hwcaps (val
);
13750 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13752 val
= read_uleb128 (p
, &len
, end
);
13754 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13755 display_sparc_hwcaps2 (val
);
13759 return display_tag_value (tag
, p
, end
);
13763 print_mips_fp_abi_value (int val
)
13767 case Val_GNU_MIPS_ABI_FP_ANY
:
13768 printf (_("Hard or soft float\n"));
13770 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13771 printf (_("Hard float (double precision)\n"));
13773 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13774 printf (_("Hard float (single precision)\n"));
13776 case Val_GNU_MIPS_ABI_FP_SOFT
:
13777 printf (_("Soft float\n"));
13779 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13780 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13782 case Val_GNU_MIPS_ABI_FP_XX
:
13783 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13785 case Val_GNU_MIPS_ABI_FP_64
:
13786 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13788 case Val_GNU_MIPS_ABI_FP_64A
:
13789 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13791 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13792 printf (_("NaN 2008 compatibility\n"));
13795 printf ("??? (%d)\n", val
);
13800 static unsigned char *
13801 display_mips_gnu_attribute (unsigned char * p
,
13803 const unsigned char * const end
)
13805 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13810 val
= read_uleb128 (p
, &len
, end
);
13812 printf (" Tag_GNU_MIPS_ABI_FP: ");
13814 print_mips_fp_abi_value (val
);
13819 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13824 val
= read_uleb128 (p
, &len
, end
);
13826 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13830 case Val_GNU_MIPS_ABI_MSA_ANY
:
13831 printf (_("Any MSA or not\n"));
13833 case Val_GNU_MIPS_ABI_MSA_128
:
13834 printf (_("128-bit MSA\n"));
13837 printf ("??? (%d)\n", val
);
13843 return display_tag_value (tag
& 1, p
, end
);
13846 static unsigned char *
13847 display_tic6x_attribute (unsigned char * p
,
13848 const unsigned char * const end
)
13854 tag
= read_uleb128 (p
, &len
, end
);
13860 val
= read_uleb128 (p
, &len
, end
);
13862 printf (" Tag_ISA: ");
13866 case C6XABI_Tag_ISA_none
:
13867 printf (_("None\n"));
13869 case C6XABI_Tag_ISA_C62X
:
13872 case C6XABI_Tag_ISA_C67X
:
13875 case C6XABI_Tag_ISA_C67XP
:
13876 printf ("C67x+\n");
13878 case C6XABI_Tag_ISA_C64X
:
13881 case C6XABI_Tag_ISA_C64XP
:
13882 printf ("C64x+\n");
13884 case C6XABI_Tag_ISA_C674X
:
13885 printf ("C674x\n");
13888 printf ("??? (%d)\n", val
);
13893 case Tag_ABI_wchar_t
:
13894 val
= read_uleb128 (p
, &len
, end
);
13896 printf (" Tag_ABI_wchar_t: ");
13900 printf (_("Not used\n"));
13903 printf (_("2 bytes\n"));
13906 printf (_("4 bytes\n"));
13909 printf ("??? (%d)\n", val
);
13914 case Tag_ABI_stack_align_needed
:
13915 val
= read_uleb128 (p
, &len
, end
);
13917 printf (" Tag_ABI_stack_align_needed: ");
13921 printf (_("8-byte\n"));
13924 printf (_("16-byte\n"));
13927 printf ("??? (%d)\n", val
);
13932 case Tag_ABI_stack_align_preserved
:
13933 val
= read_uleb128 (p
, &len
, end
);
13935 printf (" Tag_ABI_stack_align_preserved: ");
13939 printf (_("8-byte\n"));
13942 printf (_("16-byte\n"));
13945 printf ("??? (%d)\n", val
);
13951 val
= read_uleb128 (p
, &len
, end
);
13953 printf (" Tag_ABI_DSBT: ");
13957 printf (_("DSBT addressing not used\n"));
13960 printf (_("DSBT addressing used\n"));
13963 printf ("??? (%d)\n", val
);
13969 val
= read_uleb128 (p
, &len
, end
);
13971 printf (" Tag_ABI_PID: ");
13975 printf (_("Data addressing position-dependent\n"));
13978 printf (_("Data addressing position-independent, GOT near DP\n"));
13981 printf (_("Data addressing position-independent, GOT far from DP\n"));
13984 printf ("??? (%d)\n", val
);
13990 val
= read_uleb128 (p
, &len
, end
);
13992 printf (" Tag_ABI_PIC: ");
13996 printf (_("Code addressing position-dependent\n"));
13999 printf (_("Code addressing position-independent\n"));
14002 printf ("??? (%d)\n", val
);
14007 case Tag_ABI_array_object_alignment
:
14008 val
= read_uleb128 (p
, &len
, end
);
14010 printf (" Tag_ABI_array_object_alignment: ");
14014 printf (_("8-byte\n"));
14017 printf (_("4-byte\n"));
14020 printf (_("16-byte\n"));
14023 printf ("??? (%d)\n", val
);
14028 case Tag_ABI_array_object_align_expected
:
14029 val
= read_uleb128 (p
, &len
, end
);
14031 printf (" Tag_ABI_array_object_align_expected: ");
14035 printf (_("8-byte\n"));
14038 printf (_("4-byte\n"));
14041 printf (_("16-byte\n"));
14044 printf ("??? (%d)\n", val
);
14049 case Tag_ABI_compatibility
:
14051 val
= read_uleb128 (p
, &len
, end
);
14053 printf (" Tag_ABI_compatibility: ");
14054 printf (_("flag = %d, vendor = "), val
);
14057 size_t maxlen
= (end
- p
) - 1;
14059 print_symbol ((int) maxlen
, (const char *) p
);
14060 p
+= strnlen ((char *) p
, maxlen
) + 1;
14064 printf (_("<corrupt>"));
14065 p
= (unsigned char *) end
;
14071 case Tag_ABI_conformance
:
14073 printf (" Tag_ABI_conformance: \"");
14076 size_t maxlen
= (end
- p
) - 1;
14078 print_symbol ((int) maxlen
, (const char *) p
);
14079 p
+= strnlen ((char *) p
, maxlen
) + 1;
14083 printf (_("<corrupt>"));
14084 p
= (unsigned char *) end
;
14091 return display_tag_value (tag
, p
, end
);
14095 display_raw_attribute (unsigned char * p
, unsigned char * end
)
14097 unsigned long addr
= 0;
14098 size_t bytes
= end
- p
;
14105 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14107 printf (" 0x%8.8lx ", addr
);
14109 for (j
= 0; j
< 16; j
++)
14112 printf ("%2.2x", p
[j
]);
14120 for (j
= 0; j
< lbytes
; j
++)
14123 if (k
>= ' ' && k
< 0x7f)
14139 static unsigned char *
14140 display_msp430x_attribute (unsigned char * p
,
14141 const unsigned char * const end
)
14147 tag
= read_uleb128 (p
, & len
, end
);
14152 case OFBA_MSPABI_Tag_ISA
:
14153 val
= read_uleb128 (p
, &len
, end
);
14155 printf (" Tag_ISA: ");
14158 case 0: printf (_("None\n")); break;
14159 case 1: printf (_("MSP430\n")); break;
14160 case 2: printf (_("MSP430X\n")); break;
14161 default: printf ("??? (%d)\n", val
); break;
14165 case OFBA_MSPABI_Tag_Code_Model
:
14166 val
= read_uleb128 (p
, &len
, end
);
14168 printf (" Tag_Code_Model: ");
14171 case 0: printf (_("None\n")); break;
14172 case 1: printf (_("Small\n")); break;
14173 case 2: printf (_("Large\n")); break;
14174 default: printf ("??? (%d)\n", val
); break;
14178 case OFBA_MSPABI_Tag_Data_Model
:
14179 val
= read_uleb128 (p
, &len
, end
);
14181 printf (" Tag_Data_Model: ");
14184 case 0: printf (_("None\n")); break;
14185 case 1: printf (_("Small\n")); break;
14186 case 2: printf (_("Large\n")); break;
14187 case 3: printf (_("Restricted Large\n")); break;
14188 default: printf ("??? (%d)\n", val
); break;
14193 printf (_(" <unknown tag %d>: "), tag
);
14200 size_t maxlen
= (end
- p
) - 1;
14202 print_symbol ((int) maxlen
, (const char *) p
);
14203 p
+= strnlen ((char *) p
, maxlen
) + 1;
14207 printf (_("<corrupt>"));
14208 p
= (unsigned char *) end
;
14214 val
= read_uleb128 (p
, &len
, end
);
14216 printf ("%d (0x%x)\n", val
, val
);
14226 process_attributes (FILE * file
,
14227 const char * public_name
,
14228 unsigned int proc_type
,
14229 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14230 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14232 Elf_Internal_Shdr
* sect
;
14235 /* Find the section header so that we get the size. */
14236 for (i
= 0, sect
= section_headers
;
14237 i
< elf_header
.e_shnum
;
14240 unsigned char * contents
;
14243 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14246 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14247 sect
->sh_size
, _("attributes"));
14248 if (contents
== NULL
)
14254 bfd_vma section_len
;
14256 section_len
= sect
->sh_size
- 1;
14259 while (section_len
> 0)
14262 unsigned int namelen
;
14263 bfd_boolean public_section
;
14264 bfd_boolean gnu_section
;
14266 if (section_len
<= 4)
14268 error (_("Tag section ends prematurely\n"));
14271 attr_len
= byte_get (p
, 4);
14274 if (attr_len
> section_len
)
14276 error (_("Bad attribute length (%u > %u)\n"),
14277 (unsigned) attr_len
, (unsigned) section_len
);
14278 attr_len
= section_len
;
14280 /* PR 17531: file: 001-101425-0.004 */
14281 else if (attr_len
< 5)
14283 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14287 section_len
-= attr_len
;
14290 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14291 if (namelen
== 0 || namelen
>= attr_len
)
14293 error (_("Corrupt attribute section name\n"));
14297 printf (_("Attribute Section: "));
14298 print_symbol (INT_MAX
, (const char *) p
);
14301 if (public_name
&& streq ((char *) p
, public_name
))
14302 public_section
= TRUE
;
14304 public_section
= FALSE
;
14306 if (streq ((char *) p
, "gnu"))
14307 gnu_section
= TRUE
;
14309 gnu_section
= FALSE
;
14312 attr_len
-= namelen
;
14314 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14319 unsigned char * end
;
14321 /* PR binutils/17531: Safe handling of corrupt files. */
14324 error (_("Unused bytes at end of section\n"));
14330 size
= byte_get (p
, 4);
14331 if (size
> attr_len
)
14333 error (_("Bad subsection length (%u > %u)\n"),
14334 (unsigned) size
, (unsigned) attr_len
);
14337 /* PR binutils/17531: Safe handling of corrupt files. */
14340 error (_("Bad subsection length (%u < 6)\n"),
14347 end
= p
+ size
- 1;
14348 assert (end
<= contents
+ sect
->sh_size
);
14354 printf (_("File Attributes\n"));
14357 printf (_("Section Attributes:"));
14360 printf (_("Symbol Attributes:"));
14361 /* Fall through. */
14367 val
= read_uleb128 (p
, &j
, end
);
14371 printf (" %d", val
);
14376 printf (_("Unknown tag: %d\n"), tag
);
14377 public_section
= FALSE
;
14381 if (public_section
&& display_pub_attribute
!= NULL
)
14384 p
= display_pub_attribute (p
, end
);
14387 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14390 p
= display_gnu_attribute (p
,
14391 display_proc_gnu_attribute
,
14397 printf (_(" Unknown attribute:\n"));
14398 display_raw_attribute (p
, end
);
14407 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14415 process_arm_specific (FILE * file
)
14417 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14418 display_arm_attribute
, NULL
);
14422 process_power_specific (FILE * file
)
14424 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14425 display_power_gnu_attribute
);
14429 process_s390_specific (FILE * file
)
14431 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14432 display_s390_gnu_attribute
);
14436 process_sparc_specific (FILE * file
)
14438 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14439 display_sparc_gnu_attribute
);
14443 process_tic6x_specific (FILE * file
)
14445 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14446 display_tic6x_attribute
, NULL
);
14450 process_msp430x_specific (FILE * file
)
14452 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14453 display_msp430x_attribute
, NULL
);
14456 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14457 Print the Address, Access and Initial fields of an entry at VMA ADDR
14458 and return the VMA of the next entry, or -1 if there was a problem.
14459 Does not read from DATA_END or beyond. */
14462 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14463 unsigned char * data_end
)
14466 print_vma (addr
, LONG_HEX
);
14468 if (addr
< pltgot
+ 0xfff0)
14469 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14471 printf ("%10s", "");
14474 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14478 unsigned char * from
= data
+ addr
- pltgot
;
14480 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14482 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14483 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14484 return (bfd_vma
) -1;
14488 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14489 print_vma (entry
, LONG_HEX
);
14492 return addr
+ (is_32bit_elf
? 4 : 8);
14495 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14496 PLTGOT. Print the Address and Initial fields of an entry at VMA
14497 ADDR and return the VMA of the next entry. */
14500 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14503 print_vma (addr
, LONG_HEX
);
14506 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14511 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14512 print_vma (entry
, LONG_HEX
);
14514 return addr
+ (is_32bit_elf
? 4 : 8);
14518 print_mips_ases (unsigned int mask
)
14520 if (mask
& AFL_ASE_DSP
)
14521 fputs ("\n\tDSP ASE", stdout
);
14522 if (mask
& AFL_ASE_DSPR2
)
14523 fputs ("\n\tDSP R2 ASE", stdout
);
14524 if (mask
& AFL_ASE_DSPR3
)
14525 fputs ("\n\tDSP R3 ASE", stdout
);
14526 if (mask
& AFL_ASE_EVA
)
14527 fputs ("\n\tEnhanced VA Scheme", stdout
);
14528 if (mask
& AFL_ASE_MCU
)
14529 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14530 if (mask
& AFL_ASE_MDMX
)
14531 fputs ("\n\tMDMX ASE", stdout
);
14532 if (mask
& AFL_ASE_MIPS3D
)
14533 fputs ("\n\tMIPS-3D ASE", stdout
);
14534 if (mask
& AFL_ASE_MT
)
14535 fputs ("\n\tMT ASE", stdout
);
14536 if (mask
& AFL_ASE_SMARTMIPS
)
14537 fputs ("\n\tSmartMIPS ASE", stdout
);
14538 if (mask
& AFL_ASE_VIRT
)
14539 fputs ("\n\tVZ ASE", stdout
);
14540 if (mask
& AFL_ASE_MSA
)
14541 fputs ("\n\tMSA ASE", stdout
);
14542 if (mask
& AFL_ASE_MIPS16
)
14543 fputs ("\n\tMIPS16 ASE", stdout
);
14544 if (mask
& AFL_ASE_MICROMIPS
)
14545 fputs ("\n\tMICROMIPS ASE", stdout
);
14546 if (mask
& AFL_ASE_XPA
)
14547 fputs ("\n\tXPA ASE", stdout
);
14549 fprintf (stdout
, "\n\t%s", _("None"));
14550 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14551 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14555 print_mips_isa_ext (unsigned int isa_ext
)
14560 fputs (_("None"), stdout
);
14563 fputs ("RMI XLR", stdout
);
14565 case AFL_EXT_OCTEON3
:
14566 fputs ("Cavium Networks Octeon3", stdout
);
14568 case AFL_EXT_OCTEON2
:
14569 fputs ("Cavium Networks Octeon2", stdout
);
14571 case AFL_EXT_OCTEONP
:
14572 fputs ("Cavium Networks OcteonP", stdout
);
14574 case AFL_EXT_LOONGSON_3A
:
14575 fputs ("Loongson 3A", stdout
);
14577 case AFL_EXT_OCTEON
:
14578 fputs ("Cavium Networks Octeon", stdout
);
14581 fputs ("Toshiba R5900", stdout
);
14584 fputs ("MIPS R4650", stdout
);
14587 fputs ("LSI R4010", stdout
);
14590 fputs ("NEC VR4100", stdout
);
14593 fputs ("Toshiba R3900", stdout
);
14595 case AFL_EXT_10000
:
14596 fputs ("MIPS R10000", stdout
);
14599 fputs ("Broadcom SB-1", stdout
);
14602 fputs ("NEC VR4111/VR4181", stdout
);
14605 fputs ("NEC VR4120", stdout
);
14608 fputs ("NEC VR5400", stdout
);
14611 fputs ("NEC VR5500", stdout
);
14613 case AFL_EXT_LOONGSON_2E
:
14614 fputs ("ST Microelectronics Loongson 2E", stdout
);
14616 case AFL_EXT_LOONGSON_2F
:
14617 fputs ("ST Microelectronics Loongson 2F", stdout
);
14620 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14625 get_mips_reg_size (int reg_size
)
14627 return (reg_size
== AFL_REG_NONE
) ? 0
14628 : (reg_size
== AFL_REG_32
) ? 32
14629 : (reg_size
== AFL_REG_64
) ? 64
14630 : (reg_size
== AFL_REG_128
) ? 128
14635 process_mips_specific (FILE * file
)
14637 Elf_Internal_Dyn
* entry
;
14638 Elf_Internal_Shdr
*sect
= NULL
;
14639 size_t liblist_offset
= 0;
14640 size_t liblistno
= 0;
14641 size_t conflictsno
= 0;
14642 size_t options_offset
= 0;
14643 size_t conflicts_offset
= 0;
14644 size_t pltrelsz
= 0;
14646 bfd_vma pltgot
= 0;
14647 bfd_vma mips_pltgot
= 0;
14648 bfd_vma jmprel
= 0;
14649 bfd_vma local_gotno
= 0;
14650 bfd_vma gotsym
= 0;
14651 bfd_vma symtabno
= 0;
14653 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14654 display_mips_gnu_attribute
);
14656 sect
= find_section (".MIPS.abiflags");
14660 Elf_External_ABIFlags_v0
*abiflags_ext
;
14661 Elf_Internal_ABIFlags_v0 abiflags_in
;
14663 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14664 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14667 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14668 sect
->sh_size
, _("MIPS ABI Flags section"));
14671 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14672 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14673 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14674 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14675 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14676 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14677 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14678 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14679 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14680 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14681 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14683 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14684 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14685 if (abiflags_in
.isa_rev
> 1)
14686 printf ("r%d", abiflags_in
.isa_rev
);
14687 printf ("\nGPR size: %d",
14688 get_mips_reg_size (abiflags_in
.gpr_size
));
14689 printf ("\nCPR1 size: %d",
14690 get_mips_reg_size (abiflags_in
.cpr1_size
));
14691 printf ("\nCPR2 size: %d",
14692 get_mips_reg_size (abiflags_in
.cpr2_size
));
14693 fputs ("\nFP ABI: ", stdout
);
14694 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14695 fputs ("ISA Extension: ", stdout
);
14696 print_mips_isa_ext (abiflags_in
.isa_ext
);
14697 fputs ("\nASEs:", stdout
);
14698 print_mips_ases (abiflags_in
.ases
);
14699 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14700 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14701 fputc ('\n', stdout
);
14702 free (abiflags_ext
);
14707 /* We have a lot of special sections. Thanks SGI! */
14708 if (dynamic_section
== NULL
)
14709 /* No information available. */
14712 for (entry
= dynamic_section
;
14713 /* PR 17531 file: 012-50589-0.004. */
14714 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14716 switch (entry
->d_tag
)
14718 case DT_MIPS_LIBLIST
:
14720 = offset_from_vma (file
, entry
->d_un
.d_val
,
14721 liblistno
* sizeof (Elf32_External_Lib
));
14723 case DT_MIPS_LIBLISTNO
:
14724 liblistno
= entry
->d_un
.d_val
;
14726 case DT_MIPS_OPTIONS
:
14727 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14729 case DT_MIPS_CONFLICT
:
14731 = offset_from_vma (file
, entry
->d_un
.d_val
,
14732 conflictsno
* sizeof (Elf32_External_Conflict
));
14734 case DT_MIPS_CONFLICTNO
:
14735 conflictsno
= entry
->d_un
.d_val
;
14738 pltgot
= entry
->d_un
.d_ptr
;
14740 case DT_MIPS_LOCAL_GOTNO
:
14741 local_gotno
= entry
->d_un
.d_val
;
14743 case DT_MIPS_GOTSYM
:
14744 gotsym
= entry
->d_un
.d_val
;
14746 case DT_MIPS_SYMTABNO
:
14747 symtabno
= entry
->d_un
.d_val
;
14749 case DT_MIPS_PLTGOT
:
14750 mips_pltgot
= entry
->d_un
.d_ptr
;
14753 pltrel
= entry
->d_un
.d_val
;
14756 pltrelsz
= entry
->d_un
.d_val
;
14759 jmprel
= entry
->d_un
.d_ptr
;
14765 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14767 Elf32_External_Lib
* elib
;
14770 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14772 sizeof (Elf32_External_Lib
),
14773 _("liblist section data"));
14776 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14777 (unsigned long) liblistno
);
14778 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14781 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14788 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14789 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14790 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14791 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14792 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14794 tmp
= gmtime (&atime
);
14795 snprintf (timebuf
, sizeof (timebuf
),
14796 "%04u-%02u-%02uT%02u:%02u:%02u",
14797 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14798 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14800 printf ("%3lu: ", (unsigned long) cnt
);
14801 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14802 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14804 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14805 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14806 liblist
.l_version
);
14808 if (liblist
.l_flags
== 0)
14812 static const struct
14819 { " EXACT_MATCH", LL_EXACT_MATCH
},
14820 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14821 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14822 { " EXPORTS", LL_EXPORTS
},
14823 { " DELAY_LOAD", LL_DELAY_LOAD
},
14824 { " DELTA", LL_DELTA
}
14826 int flags
= liblist
.l_flags
;
14829 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14830 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14832 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14833 flags
^= l_flags_vals
[fcnt
].bit
;
14836 printf (" %#x", (unsigned int) flags
);
14846 if (options_offset
!= 0)
14848 Elf_External_Options
* eopt
;
14849 Elf_Internal_Options
* iopt
;
14850 Elf_Internal_Options
* option
;
14853 sect
= section_headers
;
14855 /* Find the section header so that we get the size. */
14856 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14857 /* PR 17533 file: 012-277276-0.004. */
14860 error (_("No MIPS_OPTIONS header found\n"));
14864 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14865 sect
->sh_size
, _("options"));
14868 iopt
= (Elf_Internal_Options
*)
14869 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14872 error (_("Out of memory allocating space for MIPS options\n"));
14879 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14881 Elf_External_Options
* eoption
;
14883 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14885 option
->kind
= BYTE_GET (eoption
->kind
);
14886 option
->size
= BYTE_GET (eoption
->size
);
14887 option
->section
= BYTE_GET (eoption
->section
);
14888 option
->info
= BYTE_GET (eoption
->info
);
14890 /* PR 17531: file: ffa0fa3b. */
14891 if (option
->size
< sizeof (* eopt
)
14892 || offset
+ option
->size
> sect
->sh_size
)
14894 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14897 offset
+= option
->size
;
14903 printf (_("\nSection '%s' contains %d entries:\n"),
14904 printable_section_name (sect
), cnt
);
14913 switch (option
->kind
)
14916 /* This shouldn't happen. */
14917 printf (" NULL %d %lx", option
->section
, option
->info
);
14920 printf (" REGINFO ");
14921 if (elf_header
.e_machine
== EM_MIPS
)
14924 Elf32_External_RegInfo
* ereg
;
14925 Elf32_RegInfo reginfo
;
14927 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14928 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14929 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14930 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14931 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14932 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14933 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14935 printf ("GPR %08lx GP 0x%lx\n",
14936 reginfo
.ri_gprmask
,
14937 (unsigned long) reginfo
.ri_gp_value
);
14938 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14939 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14940 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14945 Elf64_External_RegInfo
* ereg
;
14946 Elf64_Internal_RegInfo reginfo
;
14948 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14949 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14950 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14951 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14952 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14953 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14954 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14956 printf ("GPR %08lx GP 0x",
14957 reginfo
.ri_gprmask
);
14958 printf_vma (reginfo
.ri_gp_value
);
14961 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14962 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14963 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14967 case ODK_EXCEPTIONS
:
14968 fputs (" EXCEPTIONS fpe_min(", stdout
);
14969 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14970 fputs (") fpe_max(", stdout
);
14971 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14972 fputs (")", stdout
);
14974 if (option
->info
& OEX_PAGE0
)
14975 fputs (" PAGE0", stdout
);
14976 if (option
->info
& OEX_SMM
)
14977 fputs (" SMM", stdout
);
14978 if (option
->info
& OEX_FPDBUG
)
14979 fputs (" FPDBUG", stdout
);
14980 if (option
->info
& OEX_DISMISS
)
14981 fputs (" DISMISS", stdout
);
14984 fputs (" PAD ", stdout
);
14985 if (option
->info
& OPAD_PREFIX
)
14986 fputs (" PREFIX", stdout
);
14987 if (option
->info
& OPAD_POSTFIX
)
14988 fputs (" POSTFIX", stdout
);
14989 if (option
->info
& OPAD_SYMBOL
)
14990 fputs (" SYMBOL", stdout
);
14993 fputs (" HWPATCH ", stdout
);
14994 if (option
->info
& OHW_R4KEOP
)
14995 fputs (" R4KEOP", stdout
);
14996 if (option
->info
& OHW_R8KPFETCH
)
14997 fputs (" R8KPFETCH", stdout
);
14998 if (option
->info
& OHW_R5KEOP
)
14999 fputs (" R5KEOP", stdout
);
15000 if (option
->info
& OHW_R5KCVTL
)
15001 fputs (" R5KCVTL", stdout
);
15004 fputs (" FILL ", stdout
);
15005 /* XXX Print content of info word? */
15008 fputs (" TAGS ", stdout
);
15009 /* XXX Print content of info word? */
15012 fputs (" HWAND ", stdout
);
15013 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15014 fputs (" R4KEOP_CHECKED", stdout
);
15015 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15016 fputs (" R4KEOP_CLEAN", stdout
);
15019 fputs (" HWOR ", stdout
);
15020 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15021 fputs (" R4KEOP_CHECKED", stdout
);
15022 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15023 fputs (" R4KEOP_CLEAN", stdout
);
15026 printf (" GP_GROUP %#06lx self-contained %#06lx",
15027 option
->info
& OGP_GROUP
,
15028 (option
->info
& OGP_SELF
) >> 16);
15031 printf (" IDENT %#06lx self-contained %#06lx",
15032 option
->info
& OGP_GROUP
,
15033 (option
->info
& OGP_SELF
) >> 16);
15036 /* This shouldn't happen. */
15037 printf (" %3d ??? %d %lx",
15038 option
->kind
, option
->section
, option
->info
);
15042 len
= sizeof (* eopt
);
15043 while (len
< option
->size
)
15045 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15047 if (ISPRINT (datum
))
15048 printf ("%c", datum
);
15050 printf ("\\%03o", datum
);
15053 fputs ("\n", stdout
);
15055 offset
+= option
->size
;
15063 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15065 Elf32_Conflict
* iconf
;
15068 if (dynamic_symbols
== NULL
)
15070 error (_("conflict list found without a dynamic symbol table\n"));
15074 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15077 error (_("Out of memory allocating space for dynamic conflicts\n"));
15083 Elf32_External_Conflict
* econf32
;
15085 econf32
= (Elf32_External_Conflict
*)
15086 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15087 sizeof (* econf32
), _("conflict"));
15091 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15092 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15098 Elf64_External_Conflict
* econf64
;
15100 econf64
= (Elf64_External_Conflict
*)
15101 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15102 sizeof (* econf64
), _("conflict"));
15106 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15107 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15112 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15113 (unsigned long) conflictsno
);
15114 puts (_(" Num: Index Value Name"));
15116 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15118 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15120 if (iconf
[cnt
] >= num_dynamic_syms
)
15121 printf (_("<corrupt symbol index>"));
15124 Elf_Internal_Sym
* psym
;
15126 psym
= & dynamic_symbols
[iconf
[cnt
]];
15127 print_vma (psym
->st_value
, FULL_HEX
);
15129 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15130 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15132 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15140 if (pltgot
!= 0 && local_gotno
!= 0)
15142 bfd_vma ent
, local_end
, global_end
;
15144 unsigned char * data
;
15145 unsigned char * data_end
;
15149 addr_size
= (is_32bit_elf
? 4 : 8);
15150 local_end
= pltgot
+ local_gotno
* addr_size
;
15152 /* PR binutils/17533 file: 012-111227-0.004 */
15153 if (symtabno
< gotsym
)
15155 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15156 (unsigned long) gotsym
, (unsigned long) symtabno
);
15160 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15161 /* PR 17531: file: 54c91a34. */
15162 if (global_end
< local_end
)
15164 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15168 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15169 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15170 global_end
- pltgot
, 1,
15171 _("Global Offset Table data"));
15174 data_end
= data
+ (global_end
- pltgot
);
15176 printf (_("\nPrimary GOT:\n"));
15177 printf (_(" Canonical gp value: "));
15178 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15181 printf (_(" Reserved entries:\n"));
15182 printf (_(" %*s %10s %*s Purpose\n"),
15183 addr_size
* 2, _("Address"), _("Access"),
15184 addr_size
* 2, _("Initial"));
15185 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15186 printf (_(" Lazy resolver\n"));
15187 if (ent
== (bfd_vma
) -1)
15188 goto got_print_fail
;
15190 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15191 >> (addr_size
* 8 - 1)) != 0)
15193 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15194 printf (_(" Module pointer (GNU extension)\n"));
15195 if (ent
== (bfd_vma
) -1)
15196 goto got_print_fail
;
15200 if (ent
< local_end
)
15202 printf (_(" Local entries:\n"));
15203 printf (" %*s %10s %*s\n",
15204 addr_size
* 2, _("Address"), _("Access"),
15205 addr_size
* 2, _("Initial"));
15206 while (ent
< local_end
)
15208 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15210 if (ent
== (bfd_vma
) -1)
15211 goto got_print_fail
;
15216 if (gotsym
< symtabno
)
15220 printf (_(" Global entries:\n"));
15221 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15222 addr_size
* 2, _("Address"),
15224 addr_size
* 2, _("Initial"),
15225 addr_size
* 2, _("Sym.Val."),
15227 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15228 _("Ndx"), _("Name"));
15230 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15232 for (i
= gotsym
; i
< symtabno
; i
++)
15234 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15237 if (dynamic_symbols
== NULL
)
15238 printf (_("<no dynamic symbols>"));
15239 else if (i
< num_dynamic_syms
)
15241 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15243 print_vma (psym
->st_value
, LONG_HEX
);
15244 printf (" %-7s %3s ",
15245 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15246 get_symbol_index_type (psym
->st_shndx
));
15248 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15249 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15251 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15254 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15255 (unsigned long) i
);
15258 if (ent
== (bfd_vma
) -1)
15269 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15272 size_t offset
, rel_offset
;
15273 unsigned long count
, i
;
15274 unsigned char * data
;
15275 int addr_size
, sym_width
;
15276 Elf_Internal_Rela
* rels
;
15278 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15279 if (pltrel
== DT_RELA
)
15281 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15286 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15291 addr_size
= (is_32bit_elf
? 4 : 8);
15292 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15294 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15295 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15296 1, _("Procedure Linkage Table data"));
15300 printf ("\nPLT GOT:\n\n");
15301 printf (_(" Reserved entries:\n"));
15302 printf (_(" %*s %*s Purpose\n"),
15303 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15304 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15305 printf (_(" PLT lazy resolver\n"));
15306 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15307 printf (_(" Module pointer\n"));
15310 printf (_(" Entries:\n"));
15311 printf (" %*s %*s %*s %-7s %3s %s\n",
15312 addr_size
* 2, _("Address"),
15313 addr_size
* 2, _("Initial"),
15314 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15315 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15316 for (i
= 0; i
< count
; i
++)
15318 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15320 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15323 if (idx
>= num_dynamic_syms
)
15324 printf (_("<corrupt symbol index: %lu>"), idx
);
15327 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15329 print_vma (psym
->st_value
, LONG_HEX
);
15330 printf (" %-7s %3s ",
15331 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15332 get_symbol_index_type (psym
->st_shndx
));
15333 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15334 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15336 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15351 process_nds32_specific (FILE * file
)
15353 Elf_Internal_Shdr
*sect
= NULL
;
15355 sect
= find_section (".nds32_e_flags");
15358 unsigned int *flag
;
15360 printf ("\nNDS32 elf flags section:\n");
15361 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15362 sect
->sh_size
, _("NDS32 elf flags section"));
15364 switch ((*flag
) & 0x3)
15367 printf ("(VEC_SIZE):\tNo entry.\n");
15370 printf ("(VEC_SIZE):\t4 bytes\n");
15373 printf ("(VEC_SIZE):\t16 bytes\n");
15376 printf ("(VEC_SIZE):\treserved\n");
15385 process_gnu_liblist (FILE * file
)
15387 Elf_Internal_Shdr
* section
;
15388 Elf_Internal_Shdr
* string_sec
;
15389 Elf32_External_Lib
* elib
;
15391 size_t strtab_size
;
15398 for (i
= 0, section
= section_headers
;
15399 i
< elf_header
.e_shnum
;
15402 switch (section
->sh_type
)
15404 case SHT_GNU_LIBLIST
:
15405 if (section
->sh_link
>= elf_header
.e_shnum
)
15408 elib
= (Elf32_External_Lib
*)
15409 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15410 _("liblist section data"));
15414 string_sec
= section_headers
+ section
->sh_link
;
15416 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15417 string_sec
->sh_size
,
15418 _("liblist string table"));
15420 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15426 strtab_size
= string_sec
->sh_size
;
15428 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15429 printable_section_name (section
),
15430 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15432 puts (_(" Library Time Stamp Checksum Version Flags"));
15434 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15442 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15443 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15444 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15445 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15446 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15448 tmp
= gmtime (&atime
);
15449 snprintf (timebuf
, sizeof (timebuf
),
15450 "%04u-%02u-%02uT%02u:%02u:%02u",
15451 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15452 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15454 printf ("%3lu: ", (unsigned long) cnt
);
15456 printf ("%-20s", liblist
.l_name
< strtab_size
15457 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15459 printf ("%-20.20s", liblist
.l_name
< strtab_size
15460 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15461 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15462 liblist
.l_version
, liblist
.l_flags
);
15473 static const char *
15474 get_note_type (unsigned e_type
)
15476 static char buff
[64];
15478 if (elf_header
.e_type
== ET_CORE
)
15482 return _("NT_AUXV (auxiliary vector)");
15484 return _("NT_PRSTATUS (prstatus structure)");
15486 return _("NT_FPREGSET (floating point registers)");
15488 return _("NT_PRPSINFO (prpsinfo structure)");
15489 case NT_TASKSTRUCT
:
15490 return _("NT_TASKSTRUCT (task structure)");
15492 return _("NT_PRXFPREG (user_xfpregs structure)");
15494 return _("NT_PPC_VMX (ppc Altivec registers)");
15496 return _("NT_PPC_VSX (ppc VSX registers)");
15498 return _("NT_386_TLS (x86 TLS information)");
15499 case NT_386_IOPERM
:
15500 return _("NT_386_IOPERM (x86 I/O permissions)");
15501 case NT_X86_XSTATE
:
15502 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15503 case NT_S390_HIGH_GPRS
:
15504 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15505 case NT_S390_TIMER
:
15506 return _("NT_S390_TIMER (s390 timer register)");
15507 case NT_S390_TODCMP
:
15508 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15509 case NT_S390_TODPREG
:
15510 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15512 return _("NT_S390_CTRS (s390 control registers)");
15513 case NT_S390_PREFIX
:
15514 return _("NT_S390_PREFIX (s390 prefix register)");
15515 case NT_S390_LAST_BREAK
:
15516 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15517 case NT_S390_SYSTEM_CALL
:
15518 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15520 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15521 case NT_S390_VXRS_LOW
:
15522 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15523 case NT_S390_VXRS_HIGH
:
15524 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15526 return _("NT_ARM_VFP (arm VFP registers)");
15528 return _("NT_ARM_TLS (AArch TLS registers)");
15529 case NT_ARM_HW_BREAK
:
15530 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15531 case NT_ARM_HW_WATCH
:
15532 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15534 return _("NT_PSTATUS (pstatus structure)");
15536 return _("NT_FPREGS (floating point registers)");
15538 return _("NT_PSINFO (psinfo structure)");
15540 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15542 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15543 case NT_WIN32PSTATUS
:
15544 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15546 return _("NT_SIGINFO (siginfo_t data)");
15548 return _("NT_FILE (mapped files)");
15556 return _("NT_VERSION (version)");
15558 return _("NT_ARCH (architecture)");
15563 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15568 print_core_note (Elf_Internal_Note
*pnote
)
15570 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15571 bfd_vma count
, page_size
;
15572 unsigned char *descdata
, *filenames
, *descend
;
15574 if (pnote
->type
!= NT_FILE
)
15580 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15581 /* Still "successful". */
15586 if (pnote
->descsz
< 2 * addr_size
)
15588 printf (_(" Malformed note - too short for header\n"));
15592 descdata
= (unsigned char *) pnote
->descdata
;
15593 descend
= descdata
+ pnote
->descsz
;
15595 if (descdata
[pnote
->descsz
- 1] != '\0')
15597 printf (_(" Malformed note - does not end with \\0\n"));
15601 count
= byte_get (descdata
, addr_size
);
15602 descdata
+= addr_size
;
15604 page_size
= byte_get (descdata
, addr_size
);
15605 descdata
+= addr_size
;
15607 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15609 printf (_(" Malformed note - too short for supplied file count\n"));
15613 printf (_(" Page size: "));
15614 print_vma (page_size
, DEC
);
15617 printf (_(" %*s%*s%*s\n"),
15618 (int) (2 + 2 * addr_size
), _("Start"),
15619 (int) (4 + 2 * addr_size
), _("End"),
15620 (int) (4 + 2 * addr_size
), _("Page Offset"));
15621 filenames
= descdata
+ count
* 3 * addr_size
;
15622 while (count
-- > 0)
15624 bfd_vma start
, end
, file_ofs
;
15626 if (filenames
== descend
)
15628 printf (_(" Malformed note - filenames end too early\n"));
15632 start
= byte_get (descdata
, addr_size
);
15633 descdata
+= addr_size
;
15634 end
= byte_get (descdata
, addr_size
);
15635 descdata
+= addr_size
;
15636 file_ofs
= byte_get (descdata
, addr_size
);
15637 descdata
+= addr_size
;
15640 print_vma (start
, FULL_HEX
);
15642 print_vma (end
, FULL_HEX
);
15644 print_vma (file_ofs
, FULL_HEX
);
15645 printf ("\n %s\n", filenames
);
15647 filenames
+= 1 + strlen ((char *) filenames
);
15653 static const char *
15654 get_gnu_elf_note_type (unsigned e_type
)
15656 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15659 case NT_GNU_ABI_TAG
:
15660 return _("NT_GNU_ABI_TAG (ABI version tag)");
15662 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15663 case NT_GNU_BUILD_ID
:
15664 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15665 case NT_GNU_GOLD_VERSION
:
15666 return _("NT_GNU_GOLD_VERSION (gold version)");
15669 static char buff
[64];
15671 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15678 print_gnu_note (Elf_Internal_Note
*pnote
)
15680 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15681 switch (pnote
->type
)
15683 case NT_GNU_BUILD_ID
:
15687 printf (_(" Build ID: "));
15688 for (i
= 0; i
< pnote
->descsz
; ++i
)
15689 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15694 case NT_GNU_ABI_TAG
:
15696 unsigned long os
, major
, minor
, subminor
;
15697 const char *osname
;
15699 /* PR 17531: file: 030-599401-0.004. */
15700 if (pnote
->descsz
< 16)
15702 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15706 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15707 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15708 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15709 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15713 case GNU_ABI_TAG_LINUX
:
15716 case GNU_ABI_TAG_HURD
:
15719 case GNU_ABI_TAG_SOLARIS
:
15720 osname
= "Solaris";
15722 case GNU_ABI_TAG_FREEBSD
:
15723 osname
= "FreeBSD";
15725 case GNU_ABI_TAG_NETBSD
:
15728 case GNU_ABI_TAG_SYLLABLE
:
15729 osname
= "Syllable";
15731 case GNU_ABI_TAG_NACL
:
15735 osname
= "Unknown";
15739 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15740 major
, minor
, subminor
);
15744 case NT_GNU_GOLD_VERSION
:
15748 printf (_(" Version: "));
15749 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15750 printf ("%c", pnote
->descdata
[i
]);
15757 unsigned long num_entries
, mask
;
15759 /* Hardware capabilities information. Word 0 is the number of entries.
15760 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15761 is a series of entries, where each entry is a single byte followed
15762 by a nul terminated string. The byte gives the bit number to test
15763 if enabled in the bitmask. */
15764 printf (_(" Hardware Capabilities: "));
15765 if (pnote
->descsz
< 8)
15767 printf (_("<corrupt GNU_HWCAP>\n"));
15770 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15771 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15772 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15773 /* FIXME: Add code to display the entries... */
15778 /* Handle unrecognised types. An error message should have already been
15779 created by get_gnu_elf_note_type(), so all that we need to do is to
15780 display the data. */
15784 printf (_(" Description data: "));
15785 for (i
= 0; i
< pnote
->descsz
; ++i
)
15786 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15795 static const char *
15796 get_v850_elf_note_type (enum v850_notes n_type
)
15798 static char buff
[64];
15802 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15803 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15804 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15805 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15806 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15807 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15809 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15815 print_v850_note (Elf_Internal_Note
* pnote
)
15819 if (pnote
->descsz
!= 4)
15821 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15825 printf (_("not set\n"));
15829 switch (pnote
->type
)
15831 case V850_NOTE_ALIGNMENT
:
15834 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15835 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15839 case V850_NOTE_DATA_SIZE
:
15842 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15843 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15847 case V850_NOTE_FPU_INFO
:
15850 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15851 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15855 case V850_NOTE_MMU_INFO
:
15856 case V850_NOTE_CACHE_INFO
:
15857 case V850_NOTE_SIMD_INFO
:
15858 if (val
== EF_RH850_SIMD
)
15860 printf (_("yes\n"));
15866 /* An 'unknown note type' message will already have been displayed. */
15870 printf (_("unknown value: %x\n"), val
);
15875 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15877 unsigned int version
;
15879 switch (pnote
->type
)
15881 case NT_NETBSD_IDENT
:
15882 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15883 if ((version
/ 10000) % 100)
15884 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15885 version
, version
/ 100000000, (version
/ 1000000) % 100,
15886 (version
/ 10000) % 100 > 26 ? "Z" : "",
15887 'A' + (version
/ 10000) % 26);
15889 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15890 version
, version
/ 100000000, (version
/ 1000000) % 100,
15891 (version
/ 100) % 100);
15894 case NT_NETBSD_MARCH
:
15895 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15903 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15908 static const char *
15909 get_freebsd_elfcore_note_type (unsigned e_type
)
15913 case NT_FREEBSD_THRMISC
:
15914 return _("NT_THRMISC (thrmisc structure)");
15915 case NT_FREEBSD_PROCSTAT_PROC
:
15916 return _("NT_PROCSTAT_PROC (proc data)");
15917 case NT_FREEBSD_PROCSTAT_FILES
:
15918 return _("NT_PROCSTAT_FILES (files data)");
15919 case NT_FREEBSD_PROCSTAT_VMMAP
:
15920 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15921 case NT_FREEBSD_PROCSTAT_GROUPS
:
15922 return _("NT_PROCSTAT_GROUPS (groups data)");
15923 case NT_FREEBSD_PROCSTAT_UMASK
:
15924 return _("NT_PROCSTAT_UMASK (umask data)");
15925 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15926 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15927 case NT_FREEBSD_PROCSTAT_OSREL
:
15928 return _("NT_PROCSTAT_OSREL (osreldate data)");
15929 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15930 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15931 case NT_FREEBSD_PROCSTAT_AUXV
:
15932 return _("NT_PROCSTAT_AUXV (auxv data)");
15934 return get_note_type (e_type
);
15937 static const char *
15938 get_netbsd_elfcore_note_type (unsigned e_type
)
15940 static char buff
[64];
15942 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15944 /* NetBSD core "procinfo" structure. */
15945 return _("NetBSD procinfo structure");
15948 /* As of Jan 2002 there are no other machine-independent notes
15949 defined for NetBSD core files. If the note type is less
15950 than the start of the machine-dependent note types, we don't
15953 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15955 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15959 switch (elf_header
.e_machine
)
15961 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15962 and PT_GETFPREGS == mach+2. */
15967 case EM_SPARC32PLUS
:
15971 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15972 return _("PT_GETREGS (reg structure)");
15973 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15974 return _("PT_GETFPREGS (fpreg structure)");
15980 /* On all other arch's, PT_GETREGS == mach+1 and
15981 PT_GETFPREGS == mach+3. */
15985 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15986 return _("PT_GETREGS (reg structure)");
15987 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15988 return _("PT_GETFPREGS (fpreg structure)");
15994 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15995 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15999 static const char *
16000 get_stapsdt_note_type (unsigned e_type
)
16002 static char buff
[64];
16007 return _("NT_STAPSDT (SystemTap probe descriptors)");
16013 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16018 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16020 int addr_size
= is_32bit_elf
? 4 : 8;
16021 char *data
= pnote
->descdata
;
16022 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16023 bfd_vma pc
, base_addr
, semaphore
;
16024 char *provider
, *probe
, *arg_fmt
;
16026 pc
= byte_get ((unsigned char *) data
, addr_size
);
16028 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16030 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16034 data
+= strlen (data
) + 1;
16036 data
+= strlen (data
) + 1;
16038 data
+= strlen (data
) + 1;
16040 printf (_(" Provider: %s\n"), provider
);
16041 printf (_(" Name: %s\n"), probe
);
16042 printf (_(" Location: "));
16043 print_vma (pc
, FULL_HEX
);
16044 printf (_(", Base: "));
16045 print_vma (base_addr
, FULL_HEX
);
16046 printf (_(", Semaphore: "));
16047 print_vma (semaphore
, FULL_HEX
);
16049 printf (_(" Arguments: %s\n"), arg_fmt
);
16051 return data
== data_end
;
16054 static const char *
16055 get_ia64_vms_note_type (unsigned e_type
)
16057 static char buff
[64];
16062 return _("NT_VMS_MHD (module header)");
16064 return _("NT_VMS_LNM (language name)");
16066 return _("NT_VMS_SRC (source files)");
16068 return "NT_VMS_TITLE";
16070 return _("NT_VMS_EIDC (consistency check)");
16071 case NT_VMS_FPMODE
:
16072 return _("NT_VMS_FPMODE (FP mode)");
16073 case NT_VMS_LINKTIME
:
16074 return "NT_VMS_LINKTIME";
16075 case NT_VMS_IMGNAM
:
16076 return _("NT_VMS_IMGNAM (image name)");
16078 return _("NT_VMS_IMGID (image id)");
16079 case NT_VMS_LINKID
:
16080 return _("NT_VMS_LINKID (link id)");
16081 case NT_VMS_IMGBID
:
16082 return _("NT_VMS_IMGBID (build id)");
16083 case NT_VMS_GSTNAM
:
16084 return _("NT_VMS_GSTNAM (sym table name)");
16085 case NT_VMS_ORIG_DYN
:
16086 return "NT_VMS_ORIG_DYN";
16087 case NT_VMS_PATCHTIME
:
16088 return "NT_VMS_PATCHTIME";
16090 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16096 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16098 switch (pnote
->type
)
16101 if (pnote
->descsz
> 36)
16103 size_t l
= strlen (pnote
->descdata
+ 34);
16104 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16105 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16106 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16107 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16110 printf (_(" Invalid size\n"));
16113 printf (_(" Language: %s\n"), pnote
->descdata
);
16116 case NT_VMS_FPMODE
:
16117 printf (_(" Floating Point mode: "));
16118 printf ("0x%016" BFD_VMA_FMT
"x\n",
16119 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16121 case NT_VMS_LINKTIME
:
16122 printf (_(" Link time: "));
16124 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16127 case NT_VMS_PATCHTIME
:
16128 printf (_(" Patch time: "));
16130 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16133 case NT_VMS_ORIG_DYN
:
16134 printf (_(" Major id: %u, minor id: %u\n"),
16135 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16136 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16137 printf (_(" Last modified : "));
16139 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16140 printf (_("\n Link flags : "));
16141 printf ("0x%016" BFD_VMA_FMT
"x\n",
16142 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16143 printf (_(" Header flags: 0x%08x\n"),
16144 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16145 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16148 case NT_VMS_IMGNAM
:
16149 printf (_(" Image name: %s\n"), pnote
->descdata
);
16151 case NT_VMS_GSTNAM
:
16152 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16155 printf (_(" Image id: %s\n"), pnote
->descdata
);
16157 case NT_VMS_LINKID
:
16158 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16166 /* Note that by the ELF standard, the name field is already null byte
16167 terminated, and namesz includes the terminating null byte.
16168 I.E. the value of namesz for the name "FSF" is 4.
16170 If the value of namesz is zero, there is no name present. */
16172 process_note (Elf_Internal_Note
* pnote
,
16173 FILE * file ATTRIBUTE_UNUSED
,
16174 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16176 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16179 if (pnote
->namesz
== 0)
16180 /* If there is no note name, then use the default set of
16181 note type strings. */
16182 nt
= get_note_type (pnote
->type
);
16184 else if (const_strneq (pnote
->namedata
, "GNU"))
16185 /* GNU-specific object file notes. */
16186 nt
= get_gnu_elf_note_type (pnote
->type
);
16188 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16189 /* FreeBSD-specific core file notes. */
16190 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16192 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16193 /* NetBSD-specific core file notes. */
16194 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16196 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16197 /* NetBSD-specific core file notes. */
16198 return process_netbsd_elf_note (pnote
);
16200 else if (strneq (pnote
->namedata
, "SPU/", 4))
16202 /* SPU-specific core file notes. */
16203 nt
= pnote
->namedata
+ 4;
16207 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16208 /* VMS/ia64-specific file notes. */
16209 nt
= get_ia64_vms_note_type (pnote
->type
);
16211 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16212 nt
= get_stapsdt_note_type (pnote
->type
);
16215 /* Don't recognize this note name; just use the default set of
16216 note type strings. */
16217 nt
= get_note_type (pnote
->type
);
16220 print_symbol (-20, name
);
16221 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16223 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16224 return print_ia64_vms_note (pnote
);
16225 else if (const_strneq (pnote
->namedata
, "GNU"))
16226 return print_gnu_note (pnote
);
16227 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16228 return print_stapsdt_note (pnote
);
16229 else if (const_strneq (pnote
->namedata
, "CORE"))
16230 return print_core_note (pnote
);
16232 else if (pnote
->descsz
)
16236 printf (_(" description data: "));
16237 for (i
= 0; i
< pnote
->descsz
; i
++)
16238 printf ("%02x ", pnote
->descdata
[i
]);
16246 process_notes_at (FILE * file
,
16247 Elf_Internal_Shdr
* section
,
16251 Elf_External_Note
* pnotes
;
16252 Elf_External_Note
* external
;
16261 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16263 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16266 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16268 if (pnotes
== NULL
)
16274 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16276 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16277 (unsigned long) offset
, (unsigned long) length
);
16279 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16281 end
= (char *) pnotes
+ length
;
16282 while ((char *) external
< end
)
16284 Elf_Internal_Note inote
;
16287 char * temp
= NULL
;
16288 size_t data_remaining
= end
- (char *) external
;
16290 if (!is_ia64_vms ())
16292 /* PR binutils/15191
16293 Make sure that there is enough data to read. */
16294 min_notesz
= offsetof (Elf_External_Note
, name
);
16295 if (data_remaining
< min_notesz
)
16297 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16298 (int) data_remaining
);
16301 inote
.type
= BYTE_GET (external
->type
);
16302 inote
.namesz
= BYTE_GET (external
->namesz
);
16303 inote
.namedata
= external
->name
;
16304 inote
.descsz
= BYTE_GET (external
->descsz
);
16305 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16306 /* PR 17531: file: 3443835e. */
16307 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16309 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16310 inote
.descdata
= inote
.namedata
;
16314 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16315 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16319 Elf64_External_VMS_Note
*vms_external
;
16321 /* PR binutils/15191
16322 Make sure that there is enough data to read. */
16323 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16324 if (data_remaining
< min_notesz
)
16326 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16327 (int) data_remaining
);
16331 vms_external
= (Elf64_External_VMS_Note
*) external
;
16332 inote
.type
= BYTE_GET (vms_external
->type
);
16333 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16334 inote
.namedata
= vms_external
->name
;
16335 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16336 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16337 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16338 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16341 if (inote
.descdata
< (char *) external
+ min_notesz
16342 || next
< (char *) external
+ min_notesz
16343 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16344 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16345 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16346 || data_remaining
< (size_t)(next
- (char *) external
))
16348 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16349 (unsigned long) ((char *) external
- (char *) pnotes
));
16350 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16351 inote
.type
, inote
.namesz
, inote
.descsz
);
16355 external
= (Elf_External_Note
*) next
;
16357 /* Verify that name is null terminated. It appears that at least
16358 one version of Linux (RedHat 6.0) generates corefiles that don't
16359 comply with the ELF spec by failing to include the null byte in
16361 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16363 temp
= (char *) malloc (inote
.namesz
+ 1);
16366 error (_("Out of memory allocating space for inote name\n"));
16371 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16372 temp
[inote
.namesz
] = 0;
16374 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16375 inote
.namedata
= temp
;
16378 res
&= process_note (& inote
, file
, section
);
16393 process_corefile_note_segments (FILE * file
)
16395 Elf_Internal_Phdr
* segment
;
16399 if (! get_program_headers (file
))
16402 for (i
= 0, segment
= program_headers
;
16403 i
< elf_header
.e_phnum
;
16406 if (segment
->p_type
== PT_NOTE
)
16407 res
&= process_notes_at (file
, NULL
,
16408 (bfd_vma
) segment
->p_offset
,
16409 (bfd_vma
) segment
->p_filesz
);
16416 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16418 Elf_External_Note
* pnotes
;
16419 Elf_External_Note
* external
;
16426 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16428 if (pnotes
== NULL
)
16432 end
= (char*) pnotes
+ length
;
16434 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16435 (unsigned long) offset
, (unsigned long) length
);
16437 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16439 Elf_External_Note
* next
;
16440 Elf_Internal_Note inote
;
16442 inote
.type
= BYTE_GET (external
->type
);
16443 inote
.namesz
= BYTE_GET (external
->namesz
);
16444 inote
.namedata
= external
->name
;
16445 inote
.descsz
= BYTE_GET (external
->descsz
);
16446 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16447 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16449 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16451 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16452 inote
.descdata
= inote
.namedata
;
16456 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16458 if ( ((char *) next
> end
)
16459 || ((char *) next
< (char *) pnotes
))
16461 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16462 (unsigned long) ((char *) external
- (char *) pnotes
));
16463 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16464 inote
.type
, inote
.namesz
, inote
.descsz
);
16470 /* Prevent out-of-bounds indexing. */
16471 if ( inote
.namedata
+ inote
.namesz
> end
16472 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16474 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16475 (unsigned long) ((char *) external
- (char *) pnotes
));
16476 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16477 inote
.type
, inote
.namesz
, inote
.descsz
);
16481 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16483 if (! print_v850_note (& inote
))
16486 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16487 inote
.namesz
, inote
.descsz
);
16497 process_note_sections (FILE * file
)
16499 Elf_Internal_Shdr
* section
;
16504 for (i
= 0, section
= section_headers
;
16505 i
< elf_header
.e_shnum
&& section
!= NULL
;
16508 if (section
->sh_type
== SHT_NOTE
)
16510 res
&= process_notes_at (file
, section
,
16511 (bfd_vma
) section
->sh_offset
,
16512 (bfd_vma
) section
->sh_size
);
16516 if (( elf_header
.e_machine
== EM_V800
16517 || elf_header
.e_machine
== EM_V850
16518 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16519 && section
->sh_type
== SHT_RENESAS_INFO
)
16521 res
&= process_v850_notes (file
,
16522 (bfd_vma
) section
->sh_offset
,
16523 (bfd_vma
) section
->sh_size
);
16529 /* Try processing NOTE segments instead. */
16530 return process_corefile_note_segments (file
);
16536 process_notes (FILE * file
)
16538 /* If we have not been asked to display the notes then do nothing. */
16542 if (elf_header
.e_type
!= ET_CORE
)
16543 return process_note_sections (file
);
16545 /* No program headers means no NOTE segment. */
16546 if (elf_header
.e_phnum
> 0)
16547 return process_corefile_note_segments (file
);
16549 printf (_("No note segments present in the core file.\n"));
16554 process_arch_specific (FILE * file
)
16559 switch (elf_header
.e_machine
)
16562 return process_arm_specific (file
);
16564 case EM_MIPS_RS3_LE
:
16565 return process_mips_specific (file
);
16568 return process_nds32_specific (file
);
16572 return process_power_specific (file
);
16576 return process_s390_specific (file
);
16579 case EM_SPARC32PLUS
:
16581 return process_sparc_specific (file
);
16584 return process_tic6x_specific (file
);
16587 return process_msp430x_specific (file
);
16595 get_file_header (FILE * file
)
16597 /* Read in the identity array. */
16598 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16601 /* Determine how to read the rest of the header. */
16602 switch (elf_header
.e_ident
[EI_DATA
])
16607 byte_get
= byte_get_little_endian
;
16608 byte_put
= byte_put_little_endian
;
16611 byte_get
= byte_get_big_endian
;
16612 byte_put
= byte_put_big_endian
;
16616 /* For now we only support 32 bit and 64 bit ELF files. */
16617 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16619 /* Read in the rest of the header. */
16622 Elf32_External_Ehdr ehdr32
;
16624 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16627 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16628 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16629 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16630 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16631 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16632 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16633 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16634 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16635 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16636 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16637 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16638 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16639 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16643 Elf64_External_Ehdr ehdr64
;
16645 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16646 we will not be able to cope with the 64bit data found in
16647 64 ELF files. Detect this now and abort before we start
16648 overwriting things. */
16649 if (sizeof (bfd_vma
) < 8)
16651 error (_("This instance of readelf has been built without support for a\n\
16652 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16656 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16659 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16660 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16661 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16662 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16663 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16664 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16665 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16666 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16667 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16668 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16669 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16670 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16671 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16674 if (elf_header
.e_shoff
)
16676 /* There may be some extensions in the first section header. Don't
16677 bomb if we can't read it. */
16679 get_32bit_section_headers (file
, TRUE
);
16681 get_64bit_section_headers (file
, TRUE
);
16687 /* Process one ELF object file according to the command line options.
16688 This file may actually be stored in an archive. The file is
16689 positioned at the start of the ELF object. */
16692 process_object (char * file_name
, FILE * file
)
16696 if (! get_file_header (file
))
16698 error (_("%s: Failed to read file header\n"), file_name
);
16702 /* Initialise per file variables. */
16703 for (i
= ARRAY_SIZE (version_info
); i
--;)
16704 version_info
[i
] = 0;
16706 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16707 dynamic_info
[i
] = 0;
16708 dynamic_info_DT_GNU_HASH
= 0;
16710 /* Process the file. */
16712 printf (_("\nFile: %s\n"), file_name
);
16714 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16715 Note we do this even if cmdline_dump_sects is empty because we
16716 must make sure that the dump_sets array is zeroed out before each
16717 object file is processed. */
16718 if (num_dump_sects
> num_cmdline_dump_sects
)
16719 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16721 if (num_cmdline_dump_sects
> 0)
16723 if (num_dump_sects
== 0)
16724 /* A sneaky way of allocating the dump_sects array. */
16725 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16727 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16728 memcpy (dump_sects
, cmdline_dump_sects
,
16729 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16732 if (! process_file_header ())
16735 if (! process_section_headers (file
))
16737 /* Without loaded section headers we cannot process lots of
16739 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16741 if (! do_using_dynamic
)
16742 do_syms
= do_dyn_syms
= do_reloc
= 0;
16745 if (! process_section_groups (file
))
16747 /* Without loaded section groups we cannot process unwind. */
16751 if (process_program_headers (file
))
16752 process_dynamic_section (file
);
16754 process_relocs (file
);
16756 process_unwind (file
);
16758 process_symbol_table (file
);
16760 process_syminfo (file
);
16762 process_version_sections (file
);
16764 process_section_contents (file
);
16766 process_notes (file
);
16768 process_gnu_liblist (file
);
16770 process_arch_specific (file
);
16772 if (program_headers
)
16774 free (program_headers
);
16775 program_headers
= NULL
;
16778 if (section_headers
)
16780 free (section_headers
);
16781 section_headers
= NULL
;
16786 free (string_table
);
16787 string_table
= NULL
;
16788 string_table_length
= 0;
16791 if (dynamic_strings
)
16793 free (dynamic_strings
);
16794 dynamic_strings
= NULL
;
16795 dynamic_strings_length
= 0;
16798 if (dynamic_symbols
)
16800 free (dynamic_symbols
);
16801 dynamic_symbols
= NULL
;
16802 num_dynamic_syms
= 0;
16805 if (dynamic_syminfo
)
16807 free (dynamic_syminfo
);
16808 dynamic_syminfo
= NULL
;
16811 if (dynamic_section
)
16813 free (dynamic_section
);
16814 dynamic_section
= NULL
;
16817 if (section_headers_groups
)
16819 free (section_headers_groups
);
16820 section_headers_groups
= NULL
;
16823 if (section_groups
)
16825 struct group_list
* g
;
16826 struct group_list
* next
;
16828 for (i
= 0; i
< group_count
; i
++)
16830 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16837 free (section_groups
);
16838 section_groups
= NULL
;
16841 free_debug_memory ();
16846 /* Process an ELF archive.
16847 On entry the file is positioned just after the ARMAG string. */
16850 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16852 struct archive_info arch
;
16853 struct archive_info nested_arch
;
16859 /* The ARCH structure is used to hold information about this archive. */
16860 arch
.file_name
= NULL
;
16862 arch
.index_array
= NULL
;
16863 arch
.sym_table
= NULL
;
16864 arch
.longnames
= NULL
;
16866 /* The NESTED_ARCH structure is used as a single-item cache of information
16867 about a nested archive (when members of a thin archive reside within
16868 another regular archive file). */
16869 nested_arch
.file_name
= NULL
;
16870 nested_arch
.file
= NULL
;
16871 nested_arch
.index_array
= NULL
;
16872 nested_arch
.sym_table
= NULL
;
16873 nested_arch
.longnames
= NULL
;
16875 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16881 if (do_archive_index
)
16883 if (arch
.sym_table
== NULL
)
16884 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16887 unsigned long i
, l
;
16888 unsigned long current_pos
;
16890 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16891 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16892 current_pos
= ftell (file
);
16894 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16896 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16898 char * member_name
;
16900 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16902 if (member_name
!= NULL
)
16904 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16906 if (qualified_name
!= NULL
)
16908 printf (_("Contents of binary %s at offset "), qualified_name
);
16909 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16911 free (qualified_name
);
16916 if (l
>= arch
.sym_size
)
16918 error (_("%s: end of the symbol table reached before the end of the index\n"),
16922 /* PR 17531: file: 0b6630b2. */
16923 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16924 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16927 if (arch
.uses_64bit_indicies
)
16932 if (l
< arch
.sym_size
)
16933 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16934 file_name
, arch
.sym_size
- l
);
16936 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16938 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16944 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16945 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16946 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16947 && !do_section_groups
&& !do_dyn_syms
)
16949 ret
= 0; /* Archive index only. */
16960 char * qualified_name
;
16962 /* Read the next archive header. */
16963 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16965 error (_("%s: failed to seek to next archive header\n"), file_name
);
16968 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16969 if (got
!= sizeof arch
.arhdr
)
16973 error (_("%s: failed to read archive header\n"), file_name
);
16977 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16979 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16984 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16986 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16987 if (archive_file_size
& 01)
16988 ++archive_file_size
;
16990 name
= get_archive_member_name (&arch
, &nested_arch
);
16993 error (_("%s: bad archive file name\n"), file_name
);
16997 namelen
= strlen (name
);
16999 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17000 if (qualified_name
== NULL
)
17002 error (_("%s: bad archive file name\n"), file_name
);
17007 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17009 /* This is a proxy for an external member of a thin archive. */
17010 FILE * member_file
;
17011 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17012 if (member_file_name
== NULL
)
17018 member_file
= fopen (member_file_name
, "rb");
17019 if (member_file
== NULL
)
17021 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17022 free (member_file_name
);
17027 archive_file_offset
= arch
.nested_member_origin
;
17029 ret
|= process_object (qualified_name
, member_file
);
17031 fclose (member_file
);
17032 free (member_file_name
);
17034 else if (is_thin_archive
)
17036 /* PR 15140: Allow for corrupt thin archives. */
17037 if (nested_arch
.file
== NULL
)
17039 error (_("%s: contains corrupt thin archive: %s\n"),
17045 /* This is a proxy for a member of a nested archive. */
17046 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17048 /* The nested archive file will have been opened and setup by
17049 get_archive_member_name. */
17050 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17052 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17057 ret
|= process_object (qualified_name
, nested_arch
.file
);
17061 archive_file_offset
= arch
.next_arhdr_offset
;
17062 arch
.next_arhdr_offset
+= archive_file_size
;
17064 ret
|= process_object (qualified_name
, file
);
17067 if (dump_sects
!= NULL
)
17071 num_dump_sects
= 0;
17074 free (qualified_name
);
17078 if (nested_arch
.file
!= NULL
)
17079 fclose (nested_arch
.file
);
17080 release_archive (&nested_arch
);
17081 release_archive (&arch
);
17087 process_file (char * file_name
)
17090 struct stat statbuf
;
17091 char armag
[SARMAG
];
17094 if (stat (file_name
, &statbuf
) < 0)
17096 if (errno
== ENOENT
)
17097 error (_("'%s': No such file\n"), file_name
);
17099 error (_("Could not locate '%s'. System error message: %s\n"),
17100 file_name
, strerror (errno
));
17104 if (! S_ISREG (statbuf
.st_mode
))
17106 error (_("'%s' is not an ordinary file\n"), file_name
);
17110 file
= fopen (file_name
, "rb");
17113 error (_("Input file '%s' is not readable.\n"), file_name
);
17117 if (fread (armag
, SARMAG
, 1, file
) != 1)
17119 error (_("%s: Failed to read file's magic number\n"), file_name
);
17124 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17126 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17127 ret
= process_archive (file_name
, file
, FALSE
);
17128 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17129 ret
= process_archive (file_name
, file
, TRUE
);
17132 if (do_archive_index
)
17133 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17137 archive_file_size
= archive_file_offset
= 0;
17138 ret
= process_object (file_name
, file
);
17143 current_file_size
= 0;
17147 #ifdef SUPPORT_DISASSEMBLY
17148 /* Needed by the i386 disassembler. For extra credit, someone could
17149 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17153 print_address (unsigned int addr
, FILE * outfile
)
17155 fprintf (outfile
,"0x%8.8x", addr
);
17158 /* Needed by the i386 disassembler. */
17160 db_task_printsym (unsigned int addr
)
17162 print_address (addr
, stderr
);
17167 main (int argc
, char ** argv
)
17171 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17172 setlocale (LC_MESSAGES
, "");
17174 #if defined (HAVE_SETLOCALE)
17175 setlocale (LC_CTYPE
, "");
17177 bindtextdomain (PACKAGE
, LOCALEDIR
);
17178 textdomain (PACKAGE
);
17180 expandargv (&argc
, &argv
);
17182 parse_args (argc
, argv
);
17184 if (num_dump_sects
> 0)
17186 /* Make a copy of the dump_sects array. */
17187 cmdline_dump_sects
= (dump_type
*)
17188 malloc (num_dump_sects
* sizeof (* dump_sects
));
17189 if (cmdline_dump_sects
== NULL
)
17190 error (_("Out of memory allocating dump request table.\n"));
17193 memcpy (cmdline_dump_sects
, dump_sects
,
17194 num_dump_sects
* sizeof (* dump_sects
));
17195 num_cmdline_dump_sects
= num_dump_sects
;
17199 if (optind
< (argc
- 1))
17201 else if (optind
>= argc
)
17203 warn (_("Nothing to do.\n"));
17208 while (optind
< argc
)
17209 err
|= process_file (argv
[optind
++]);
17211 if (dump_sects
!= NULL
)
17213 if (cmdline_dump_sects
!= NULL
)
17214 free (cmdline_dump_sects
);