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");
3320 if (e_flags
& EF_RISCV_SOFT_FLOAT
)
3321 strcat (buf
, ", soft-float ABI");
3325 switch ((e_flags
& EF_SH_MACH_MASK
))
3327 case EF_SH1
: strcat (buf
, ", sh1"); break;
3328 case EF_SH2
: strcat (buf
, ", sh2"); break;
3329 case EF_SH3
: strcat (buf
, ", sh3"); break;
3330 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3331 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3332 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3333 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3334 case EF_SH4
: strcat (buf
, ", sh4"); break;
3335 case EF_SH5
: strcat (buf
, ", sh5"); break;
3336 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3337 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3338 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3339 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3340 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3341 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3342 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3343 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3344 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3345 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3346 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3347 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3348 default: strcat (buf
, _(", unknown ISA")); break;
3351 if (e_flags
& EF_SH_PIC
)
3352 strcat (buf
, ", pic");
3354 if (e_flags
& EF_SH_FDPIC
)
3355 strcat (buf
, ", fdpic");
3359 if (e_flags
& EF_OR1K_NODELAY
)
3360 strcat (buf
, ", no delay");
3364 if (e_flags
& EF_SPARC_32PLUS
)
3365 strcat (buf
, ", v8+");
3367 if (e_flags
& EF_SPARC_SUN_US1
)
3368 strcat (buf
, ", ultrasparcI");
3370 if (e_flags
& EF_SPARC_SUN_US3
)
3371 strcat (buf
, ", ultrasparcIII");
3373 if (e_flags
& EF_SPARC_HAL_R1
)
3374 strcat (buf
, ", halr1");
3376 if (e_flags
& EF_SPARC_LEDATA
)
3377 strcat (buf
, ", ledata");
3379 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3380 strcat (buf
, ", tso");
3382 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3383 strcat (buf
, ", pso");
3385 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3386 strcat (buf
, ", rmo");
3390 switch (e_flags
& EF_PARISC_ARCH
)
3392 case EFA_PARISC_1_0
:
3393 strcpy (buf
, ", PA-RISC 1.0");
3395 case EFA_PARISC_1_1
:
3396 strcpy (buf
, ", PA-RISC 1.1");
3398 case EFA_PARISC_2_0
:
3399 strcpy (buf
, ", PA-RISC 2.0");
3404 if (e_flags
& EF_PARISC_TRAPNIL
)
3405 strcat (buf
, ", trapnil");
3406 if (e_flags
& EF_PARISC_EXT
)
3407 strcat (buf
, ", ext");
3408 if (e_flags
& EF_PARISC_LSB
)
3409 strcat (buf
, ", lsb");
3410 if (e_flags
& EF_PARISC_WIDE
)
3411 strcat (buf
, ", wide");
3412 if (e_flags
& EF_PARISC_NO_KABP
)
3413 strcat (buf
, ", no kabp");
3414 if (e_flags
& EF_PARISC_LAZYSWAP
)
3415 strcat (buf
, ", lazyswap");
3420 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3421 strcat (buf
, ", new calling convention");
3423 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3424 strcat (buf
, ", gnu calling convention");
3428 if ((e_flags
& EF_IA_64_ABI64
))
3429 strcat (buf
, ", 64-bit");
3431 strcat (buf
, ", 32-bit");
3432 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3433 strcat (buf
, ", reduced fp model");
3434 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3435 strcat (buf
, ", no function descriptors, constant gp");
3436 else if ((e_flags
& EF_IA_64_CONS_GP
))
3437 strcat (buf
, ", constant gp");
3438 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3439 strcat (buf
, ", absolute");
3440 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3442 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3443 strcat (buf
, ", vms_linkages");
3444 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3446 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3448 case EF_IA_64_VMS_COMCOD_WARNING
:
3449 strcat (buf
, ", warning");
3451 case EF_IA_64_VMS_COMCOD_ERROR
:
3452 strcat (buf
, ", error");
3454 case EF_IA_64_VMS_COMCOD_ABORT
:
3455 strcat (buf
, ", abort");
3458 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3459 e_flags
& EF_IA_64_VMS_COMCOD
);
3460 strcat (buf
, ", <unknown>");
3466 if ((e_flags
& EF_VAX_NONPIC
))
3467 strcat (buf
, ", non-PIC");
3468 if ((e_flags
& EF_VAX_DFLOAT
))
3469 strcat (buf
, ", D-Float");
3470 if ((e_flags
& EF_VAX_GFLOAT
))
3471 strcat (buf
, ", G-Float");
3475 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3476 strcat (buf
, ", mcm");
3477 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3478 strcat (buf
, ", mcm24");
3479 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3480 strcat (buf
, ", gr6");
3484 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3486 case E_FLAG_RL78_ANY_CPU
: break;
3487 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3488 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3489 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3491 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3492 strcat (buf
, ", 64-bit doubles");
3496 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3497 strcat (buf
, ", 64-bit doubles");
3498 if (e_flags
& E_FLAG_RX_DSP
)
3499 strcat (buf
, ", dsp");
3500 if (e_flags
& E_FLAG_RX_PID
)
3501 strcat (buf
, ", pid");
3502 if (e_flags
& E_FLAG_RX_ABI
)
3503 strcat (buf
, ", RX ABI");
3504 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3505 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3506 ? ", uses String instructions" : ", bans String instructions");
3507 if (e_flags
& E_FLAG_RX_V2
)
3508 strcat (buf
, ", V2");
3512 if (e_flags
& EF_S390_HIGH_GPRS
)
3513 strcat (buf
, ", highgprs");
3517 if ((e_flags
& EF_C6000_REL
))
3518 strcat (buf
, ", relocatable module");
3522 strcat (buf
, _(": architecture variant: "));
3523 switch (e_flags
& EF_MSP430_MACH
)
3525 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3526 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3527 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3528 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3529 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3530 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3531 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3532 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3533 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3534 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3535 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3536 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3537 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3538 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3539 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3541 strcat (buf
, _(": unknown")); break;
3544 if (e_flags
& ~ EF_MSP430_MACH
)
3545 strcat (buf
, _(": unknown extra flag bits also present"));
3553 get_osabi_name (unsigned int osabi
)
3555 static char buff
[32];
3559 case ELFOSABI_NONE
: return "UNIX - System V";
3560 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3561 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3562 case ELFOSABI_GNU
: return "UNIX - GNU";
3563 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3564 case ELFOSABI_AIX
: return "UNIX - AIX";
3565 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3566 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3567 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3568 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3569 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3570 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3571 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3572 case ELFOSABI_AROS
: return "AROS";
3573 case ELFOSABI_FENIXOS
: return "FenixOS";
3574 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3575 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3578 switch (elf_header
.e_machine
)
3583 case ELFOSABI_ARM
: return "ARM";
3594 case ELFOSABI_STANDALONE
: return _("Standalone App");
3603 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3604 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3613 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3619 get_aarch64_segment_type (unsigned long type
)
3623 case PT_AARCH64_ARCHEXT
:
3624 return "AARCH64_ARCHEXT";
3633 get_arm_segment_type (unsigned long type
)
3647 get_mips_segment_type (unsigned long type
)
3651 case PT_MIPS_REGINFO
:
3653 case PT_MIPS_RTPROC
:
3655 case PT_MIPS_OPTIONS
:
3657 case PT_MIPS_ABIFLAGS
:
3667 get_parisc_segment_type (unsigned long type
)
3671 case PT_HP_TLS
: return "HP_TLS";
3672 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3673 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3674 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3675 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3676 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3677 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3678 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3679 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3680 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3681 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3682 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3683 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3684 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3685 case PT_HP_STACK
: return "HP_STACK";
3686 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3687 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3688 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3689 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3698 get_ia64_segment_type (unsigned long type
)
3702 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3703 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3704 case PT_HP_TLS
: return "HP_TLS";
3705 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3706 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3707 case PT_IA_64_HP_STACK
: return "HP_STACK";
3716 get_tic6x_segment_type (unsigned long type
)
3720 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3729 get_solaris_segment_type (unsigned long type
)
3733 case 0x6464e550: return "PT_SUNW_UNWIND";
3734 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3735 case 0x6ffffff7: return "PT_LOSUNW";
3736 case 0x6ffffffa: return "PT_SUNWBSS";
3737 case 0x6ffffffb: return "PT_SUNWSTACK";
3738 case 0x6ffffffc: return "PT_SUNWDTRACE";
3739 case 0x6ffffffd: return "PT_SUNWCAP";
3740 case 0x6fffffff: return "PT_HISUNW";
3741 default: return NULL
;
3746 get_segment_type (unsigned long p_type
)
3748 static char buff
[32];
3752 case PT_NULL
: return "NULL";
3753 case PT_LOAD
: return "LOAD";
3754 case PT_DYNAMIC
: return "DYNAMIC";
3755 case PT_INTERP
: return "INTERP";
3756 case PT_NOTE
: return "NOTE";
3757 case PT_SHLIB
: return "SHLIB";
3758 case PT_PHDR
: return "PHDR";
3759 case PT_TLS
: return "TLS";
3761 case PT_GNU_EH_FRAME
:
3762 return "GNU_EH_FRAME";
3763 case PT_GNU_STACK
: return "GNU_STACK";
3764 case PT_GNU_RELRO
: return "GNU_RELRO";
3767 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3769 const char * result
;
3771 switch (elf_header
.e_machine
)
3774 result
= get_aarch64_segment_type (p_type
);
3777 result
= get_arm_segment_type (p_type
);
3780 case EM_MIPS_RS3_LE
:
3781 result
= get_mips_segment_type (p_type
);
3784 result
= get_parisc_segment_type (p_type
);
3787 result
= get_ia64_segment_type (p_type
);
3790 result
= get_tic6x_segment_type (p_type
);
3800 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3802 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3804 const char * result
;
3806 switch (elf_header
.e_machine
)
3809 result
= get_parisc_segment_type (p_type
);
3812 result
= get_ia64_segment_type (p_type
);
3815 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3816 result
= get_solaris_segment_type (p_type
);
3825 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3828 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3835 get_mips_section_type_name (unsigned int sh_type
)
3839 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3840 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3841 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3842 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3843 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3844 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3845 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3846 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3847 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3848 case SHT_MIPS_RELD
: return "MIPS_RELD";
3849 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3850 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3851 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3852 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3853 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3854 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3855 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3856 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3857 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3858 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3859 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3860 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3861 case SHT_MIPS_LINE
: return "MIPS_LINE";
3862 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3863 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3864 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3865 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3866 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3867 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3868 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3869 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3870 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3871 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3872 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3873 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3874 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3875 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3876 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3877 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3878 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3886 get_parisc_section_type_name (unsigned int sh_type
)
3890 case SHT_PARISC_EXT
: return "PARISC_EXT";
3891 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3892 case SHT_PARISC_DOC
: return "PARISC_DOC";
3893 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3894 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3895 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3896 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3904 get_ia64_section_type_name (unsigned int sh_type
)
3906 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3907 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3908 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3912 case SHT_IA_64_EXT
: return "IA_64_EXT";
3913 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3914 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3915 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3916 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3917 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3918 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3919 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3920 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3921 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3929 get_x86_64_section_type_name (unsigned int sh_type
)
3933 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3941 get_aarch64_section_type_name (unsigned int sh_type
)
3945 case SHT_AARCH64_ATTRIBUTES
:
3946 return "AARCH64_ATTRIBUTES";
3954 get_arm_section_type_name (unsigned int sh_type
)
3958 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3959 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3960 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3961 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3962 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3970 get_tic6x_section_type_name (unsigned int sh_type
)
3974 case SHT_C6000_UNWIND
:
3975 return "C6000_UNWIND";
3976 case SHT_C6000_PREEMPTMAP
:
3977 return "C6000_PREEMPTMAP";
3978 case SHT_C6000_ATTRIBUTES
:
3979 return "C6000_ATTRIBUTES";
3984 case SHT_TI_HANDLER
:
3985 return "TI_HANDLER";
3986 case SHT_TI_INITINFO
:
3987 return "TI_INITINFO";
3988 case SHT_TI_PHATTRS
:
3989 return "TI_PHATTRS";
3997 get_msp430x_section_type_name (unsigned int sh_type
)
4001 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4002 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4003 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4004 default: return NULL
;
4009 get_v850_section_type_name (unsigned int sh_type
)
4013 case SHT_V850_SCOMMON
: return "V850 Small Common";
4014 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4015 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4016 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4017 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4018 default: return NULL
;
4023 get_section_type_name (unsigned int sh_type
)
4025 static char buff
[32];
4026 const char * result
;
4030 case SHT_NULL
: return "NULL";
4031 case SHT_PROGBITS
: return "PROGBITS";
4032 case SHT_SYMTAB
: return "SYMTAB";
4033 case SHT_STRTAB
: return "STRTAB";
4034 case SHT_RELA
: return "RELA";
4035 case SHT_HASH
: return "HASH";
4036 case SHT_DYNAMIC
: return "DYNAMIC";
4037 case SHT_NOTE
: return "NOTE";
4038 case SHT_NOBITS
: return "NOBITS";
4039 case SHT_REL
: return "REL";
4040 case SHT_SHLIB
: return "SHLIB";
4041 case SHT_DYNSYM
: return "DYNSYM";
4042 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4043 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4044 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4045 case SHT_GNU_HASH
: return "GNU_HASH";
4046 case SHT_GROUP
: return "GROUP";
4047 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4048 case SHT_GNU_verdef
: return "VERDEF";
4049 case SHT_GNU_verneed
: return "VERNEED";
4050 case SHT_GNU_versym
: return "VERSYM";
4051 case 0x6ffffff0: return "VERSYM";
4052 case 0x6ffffffc: return "VERDEF";
4053 case 0x7ffffffd: return "AUXILIARY";
4054 case 0x7fffffff: return "FILTER";
4055 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4058 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4060 switch (elf_header
.e_machine
)
4063 case EM_MIPS_RS3_LE
:
4064 result
= get_mips_section_type_name (sh_type
);
4067 result
= get_parisc_section_type_name (sh_type
);
4070 result
= get_ia64_section_type_name (sh_type
);
4075 result
= get_x86_64_section_type_name (sh_type
);
4078 result
= get_aarch64_section_type_name (sh_type
);
4081 result
= get_arm_section_type_name (sh_type
);
4084 result
= get_tic6x_section_type_name (sh_type
);
4087 result
= get_msp430x_section_type_name (sh_type
);
4091 case EM_CYGNUS_V850
:
4092 result
= get_v850_section_type_name (sh_type
);
4102 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4104 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4106 switch (elf_header
.e_machine
)
4109 result
= get_ia64_section_type_name (sh_type
);
4112 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4113 result
= get_solaris_section_type (sh_type
);
4122 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4124 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4126 switch (elf_header
.e_machine
)
4130 case EM_CYGNUS_V850
:
4131 result
= get_v850_section_type_name (sh_type
);
4141 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4144 /* This message is probably going to be displayed in a 15
4145 character wide field, so put the hex value first. */
4146 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4152 #define OPTION_DEBUG_DUMP 512
4153 #define OPTION_DYN_SYMS 513
4154 #define OPTION_DWARF_DEPTH 514
4155 #define OPTION_DWARF_START 515
4156 #define OPTION_DWARF_CHECK 516
4158 static struct option options
[] =
4160 {"all", no_argument
, 0, 'a'},
4161 {"file-header", no_argument
, 0, 'h'},
4162 {"program-headers", no_argument
, 0, 'l'},
4163 {"headers", no_argument
, 0, 'e'},
4164 {"histogram", no_argument
, 0, 'I'},
4165 {"segments", no_argument
, 0, 'l'},
4166 {"sections", no_argument
, 0, 'S'},
4167 {"section-headers", no_argument
, 0, 'S'},
4168 {"section-groups", no_argument
, 0, 'g'},
4169 {"section-details", no_argument
, 0, 't'},
4170 {"full-section-name",no_argument
, 0, 'N'},
4171 {"symbols", no_argument
, 0, 's'},
4172 {"syms", no_argument
, 0, 's'},
4173 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4174 {"relocs", no_argument
, 0, 'r'},
4175 {"notes", no_argument
, 0, 'n'},
4176 {"dynamic", no_argument
, 0, 'd'},
4177 {"arch-specific", no_argument
, 0, 'A'},
4178 {"version-info", no_argument
, 0, 'V'},
4179 {"use-dynamic", no_argument
, 0, 'D'},
4180 {"unwind", no_argument
, 0, 'u'},
4181 {"archive-index", no_argument
, 0, 'c'},
4182 {"hex-dump", required_argument
, 0, 'x'},
4183 {"relocated-dump", required_argument
, 0, 'R'},
4184 {"string-dump", required_argument
, 0, 'p'},
4185 {"decompress", no_argument
, 0, 'z'},
4186 #ifdef SUPPORT_DISASSEMBLY
4187 {"instruction-dump", required_argument
, 0, 'i'},
4189 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4191 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4192 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4193 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4195 {"version", no_argument
, 0, 'v'},
4196 {"wide", no_argument
, 0, 'W'},
4197 {"help", no_argument
, 0, 'H'},
4198 {0, no_argument
, 0, 0}
4202 usage (FILE * stream
)
4204 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4205 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4206 fprintf (stream
, _(" Options are:\n\
4207 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4208 -h --file-header Display the ELF file header\n\
4209 -l --program-headers Display the program headers\n\
4210 --segments An alias for --program-headers\n\
4211 -S --section-headers Display the sections' header\n\
4212 --sections An alias for --section-headers\n\
4213 -g --section-groups Display the section groups\n\
4214 -t --section-details Display the section details\n\
4215 -e --headers Equivalent to: -h -l -S\n\
4216 -s --syms Display the symbol table\n\
4217 --symbols An alias for --syms\n\
4218 --dyn-syms Display the dynamic symbol table\n\
4219 -n --notes Display the core notes (if present)\n\
4220 -r --relocs Display the relocations (if present)\n\
4221 -u --unwind Display the unwind info (if present)\n\
4222 -d --dynamic Display the dynamic section (if present)\n\
4223 -V --version-info Display the version sections (if present)\n\
4224 -A --arch-specific Display architecture specific information (if any)\n\
4225 -c --archive-index Display the symbol/file index in an archive\n\
4226 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4227 -x --hex-dump=<number|name>\n\
4228 Dump the contents of section <number|name> as bytes\n\
4229 -p --string-dump=<number|name>\n\
4230 Dump the contents of section <number|name> as strings\n\
4231 -R --relocated-dump=<number|name>\n\
4232 Dump the contents of section <number|name> as relocated bytes\n\
4233 -z --decompress Decompress section before dumping it\n\
4234 -w[lLiaprmfFsoRt] or\n\
4235 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4236 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4237 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4239 Display the contents of DWARF2 debug sections\n"));
4240 fprintf (stream
, _("\
4241 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4242 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4244 #ifdef SUPPORT_DISASSEMBLY
4245 fprintf (stream
, _("\
4246 -i --instruction-dump=<number|name>\n\
4247 Disassemble the contents of section <number|name>\n"));
4249 fprintf (stream
, _("\
4250 -I --histogram Display histogram of bucket list lengths\n\
4251 -W --wide Allow output width to exceed 80 characters\n\
4252 @<file> Read options from <file>\n\
4253 -H --help Display this information\n\
4254 -v --version Display the version number of readelf\n"));
4256 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4257 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4259 exit (stream
== stdout
? 0 : 1);
4262 /* Record the fact that the user wants the contents of section number
4263 SECTION to be displayed using the method(s) encoded as flags bits
4264 in TYPE. Note, TYPE can be zero if we are creating the array for
4268 request_dump_bynumber (unsigned int section
, dump_type type
)
4270 if (section
>= num_dump_sects
)
4272 dump_type
* new_dump_sects
;
4274 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4275 sizeof (* dump_sects
));
4277 if (new_dump_sects
== NULL
)
4278 error (_("Out of memory allocating dump request table.\n"));
4283 /* Copy current flag settings. */
4284 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4289 dump_sects
= new_dump_sects
;
4290 num_dump_sects
= section
+ 1;
4295 dump_sects
[section
] |= type
;
4300 /* Request a dump by section name. */
4303 request_dump_byname (const char * section
, dump_type type
)
4305 struct dump_list_entry
* new_request
;
4307 new_request
= (struct dump_list_entry
*)
4308 malloc (sizeof (struct dump_list_entry
));
4310 error (_("Out of memory allocating dump request table.\n"));
4312 new_request
->name
= strdup (section
);
4313 if (!new_request
->name
)
4314 error (_("Out of memory allocating dump request table.\n"));
4316 new_request
->type
= type
;
4318 new_request
->next
= dump_sects_byname
;
4319 dump_sects_byname
= new_request
;
4323 request_dump (dump_type type
)
4329 section
= strtoul (optarg
, & cp
, 0);
4331 if (! *cp
&& section
>= 0)
4332 request_dump_bynumber (section
, type
);
4334 request_dump_byname (optarg
, type
);
4339 parse_args (int argc
, char ** argv
)
4346 while ((c
= getopt_long
4347 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4365 do_section_groups
++;
4373 do_section_groups
++;
4378 do_section_details
++;
4422 request_dump (HEX_DUMP
);
4425 request_dump (STRING_DUMP
);
4428 request_dump (RELOC_DUMP
);
4438 dwarf_select_sections_all ();
4443 dwarf_select_sections_by_letters (optarg
);
4446 case OPTION_DEBUG_DUMP
:
4453 dwarf_select_sections_by_names (optarg
);
4456 case OPTION_DWARF_DEPTH
:
4460 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4463 case OPTION_DWARF_START
:
4467 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4470 case OPTION_DWARF_CHECK
:
4473 case OPTION_DYN_SYMS
:
4476 #ifdef SUPPORT_DISASSEMBLY
4478 request_dump (DISASS_DUMP
);
4482 print_version (program_name
);
4491 /* xgettext:c-format */
4492 error (_("Invalid option '-%c'\n"), c
);
4499 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4500 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4501 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4502 && !do_section_groups
&& !do_archive_index
4508 get_elf_class (unsigned int elf_class
)
4510 static char buff
[32];
4514 case ELFCLASSNONE
: return _("none");
4515 case ELFCLASS32
: return "ELF32";
4516 case ELFCLASS64
: return "ELF64";
4518 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4524 get_data_encoding (unsigned int encoding
)
4526 static char buff
[32];
4530 case ELFDATANONE
: return _("none");
4531 case ELFDATA2LSB
: return _("2's complement, little endian");
4532 case ELFDATA2MSB
: return _("2's complement, big endian");
4534 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4539 /* Decode the data held in 'elf_header'. */
4542 process_file_header (void)
4544 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4545 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4546 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4547 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4550 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4554 init_dwarf_regnames (elf_header
.e_machine
);
4560 printf (_("ELF Header:\n"));
4561 printf (_(" Magic: "));
4562 for (i
= 0; i
< EI_NIDENT
; i
++)
4563 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4565 printf (_(" Class: %s\n"),
4566 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4567 printf (_(" Data: %s\n"),
4568 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4569 printf (_(" Version: %d %s\n"),
4570 elf_header
.e_ident
[EI_VERSION
],
4571 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4573 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4574 ? _("<unknown: %lx>")
4576 printf (_(" OS/ABI: %s\n"),
4577 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4578 printf (_(" ABI Version: %d\n"),
4579 elf_header
.e_ident
[EI_ABIVERSION
]);
4580 printf (_(" Type: %s\n"),
4581 get_file_type (elf_header
.e_type
));
4582 printf (_(" Machine: %s\n"),
4583 get_machine_name (elf_header
.e_machine
));
4584 printf (_(" Version: 0x%lx\n"),
4585 (unsigned long) elf_header
.e_version
);
4587 printf (_(" Entry point address: "));
4588 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4589 printf (_("\n Start of program headers: "));
4590 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4591 printf (_(" (bytes into file)\n Start of section headers: "));
4592 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4593 printf (_(" (bytes into file)\n"));
4595 printf (_(" Flags: 0x%lx%s\n"),
4596 (unsigned long) elf_header
.e_flags
,
4597 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4598 printf (_(" Size of this header: %ld (bytes)\n"),
4599 (long) elf_header
.e_ehsize
);
4600 printf (_(" Size of program headers: %ld (bytes)\n"),
4601 (long) elf_header
.e_phentsize
);
4602 printf (_(" Number of program headers: %ld"),
4603 (long) elf_header
.e_phnum
);
4604 if (section_headers
!= NULL
4605 && elf_header
.e_phnum
== PN_XNUM
4606 && section_headers
[0].sh_info
!= 0)
4607 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4608 putc ('\n', stdout
);
4609 printf (_(" Size of section headers: %ld (bytes)\n"),
4610 (long) elf_header
.e_shentsize
);
4611 printf (_(" Number of section headers: %ld"),
4612 (long) elf_header
.e_shnum
);
4613 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4614 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4615 putc ('\n', stdout
);
4616 printf (_(" Section header string table index: %ld"),
4617 (long) elf_header
.e_shstrndx
);
4618 if (section_headers
!= NULL
4619 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4620 printf (" (%u)", section_headers
[0].sh_link
);
4621 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4622 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4623 printf (_(" <corrupt: out of range>"));
4624 putc ('\n', stdout
);
4627 if (section_headers
!= NULL
)
4629 if (elf_header
.e_phnum
== PN_XNUM
4630 && section_headers
[0].sh_info
!= 0)
4631 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4632 if (elf_header
.e_shnum
== SHN_UNDEF
)
4633 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4634 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4635 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4636 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4637 elf_header
.e_shstrndx
= SHN_UNDEF
;
4638 free (section_headers
);
4639 section_headers
= NULL
;
4646 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4648 Elf32_External_Phdr
* phdrs
;
4649 Elf32_External_Phdr
* external
;
4650 Elf_Internal_Phdr
* internal
;
4652 unsigned int size
= elf_header
.e_phentsize
;
4653 unsigned int num
= elf_header
.e_phnum
;
4655 /* PR binutils/17531: Cope with unexpected section header sizes. */
4656 if (size
== 0 || num
== 0)
4658 if (size
< sizeof * phdrs
)
4660 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4663 if (size
> sizeof * phdrs
)
4664 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4666 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4667 size
, num
, _("program headers"));
4671 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4672 i
< elf_header
.e_phnum
;
4673 i
++, internal
++, external
++)
4675 internal
->p_type
= BYTE_GET (external
->p_type
);
4676 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4677 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4678 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4679 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4680 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4681 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4682 internal
->p_align
= BYTE_GET (external
->p_align
);
4690 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4692 Elf64_External_Phdr
* phdrs
;
4693 Elf64_External_Phdr
* external
;
4694 Elf_Internal_Phdr
* internal
;
4696 unsigned int size
= elf_header
.e_phentsize
;
4697 unsigned int num
= elf_header
.e_phnum
;
4699 /* PR binutils/17531: Cope with unexpected section header sizes. */
4700 if (size
== 0 || num
== 0)
4702 if (size
< sizeof * phdrs
)
4704 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4707 if (size
> sizeof * phdrs
)
4708 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4710 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4711 size
, num
, _("program headers"));
4715 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4716 i
< elf_header
.e_phnum
;
4717 i
++, internal
++, external
++)
4719 internal
->p_type
= BYTE_GET (external
->p_type
);
4720 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4721 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4722 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4723 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4724 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4725 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4726 internal
->p_align
= BYTE_GET (external
->p_align
);
4733 /* Returns 1 if the program headers were read into `program_headers'. */
4736 get_program_headers (FILE * file
)
4738 Elf_Internal_Phdr
* phdrs
;
4740 /* Check cache of prior read. */
4741 if (program_headers
!= NULL
)
4744 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4745 sizeof (Elf_Internal_Phdr
));
4749 error (_("Out of memory reading %u program headers\n"),
4750 elf_header
.e_phnum
);
4755 ? get_32bit_program_headers (file
, phdrs
)
4756 : get_64bit_program_headers (file
, phdrs
))
4758 program_headers
= phdrs
;
4766 /* Returns 1 if the program headers were loaded. */
4769 process_program_headers (FILE * file
)
4771 Elf_Internal_Phdr
* segment
;
4774 if (elf_header
.e_phnum
== 0)
4776 /* PR binutils/12467. */
4777 if (elf_header
.e_phoff
!= 0)
4778 warn (_("possibly corrupt ELF header - it has a non-zero program"
4779 " header offset, but no program headers\n"));
4780 else if (do_segments
)
4781 printf (_("\nThere are no program headers in this file.\n"));
4785 if (do_segments
&& !do_header
)
4787 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4788 printf (_("Entry point "));
4789 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4790 printf (_("\nThere are %d program headers, starting at offset "),
4791 elf_header
.e_phnum
);
4792 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4796 if (! get_program_headers (file
))
4801 if (elf_header
.e_phnum
> 1)
4802 printf (_("\nProgram Headers:\n"));
4804 printf (_("\nProgram Headers:\n"));
4808 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4811 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4815 (_(" Type Offset VirtAddr PhysAddr\n"));
4817 (_(" FileSiz MemSiz Flags Align\n"));
4824 for (i
= 0, segment
= program_headers
;
4825 i
< elf_header
.e_phnum
;
4830 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4834 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4835 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4836 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4837 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4838 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4840 (segment
->p_flags
& PF_R
? 'R' : ' '),
4841 (segment
->p_flags
& PF_W
? 'W' : ' '),
4842 (segment
->p_flags
& PF_X
? 'E' : ' '));
4843 printf ("%#lx", (unsigned long) segment
->p_align
);
4847 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4848 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4851 print_vma (segment
->p_offset
, FULL_HEX
);
4855 print_vma (segment
->p_vaddr
, FULL_HEX
);
4857 print_vma (segment
->p_paddr
, FULL_HEX
);
4860 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4861 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4864 print_vma (segment
->p_filesz
, FULL_HEX
);
4868 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4869 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4872 print_vma (segment
->p_memsz
, FULL_HEX
);
4876 (segment
->p_flags
& PF_R
? 'R' : ' '),
4877 (segment
->p_flags
& PF_W
? 'W' : ' '),
4878 (segment
->p_flags
& PF_X
? 'E' : ' '));
4880 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4881 printf ("%#lx", (unsigned long) segment
->p_align
);
4884 print_vma (segment
->p_align
, PREFIX_HEX
);
4889 print_vma (segment
->p_offset
, FULL_HEX
);
4891 print_vma (segment
->p_vaddr
, FULL_HEX
);
4893 print_vma (segment
->p_paddr
, FULL_HEX
);
4895 print_vma (segment
->p_filesz
, FULL_HEX
);
4897 print_vma (segment
->p_memsz
, FULL_HEX
);
4899 (segment
->p_flags
& PF_R
? 'R' : ' '),
4900 (segment
->p_flags
& PF_W
? 'W' : ' '),
4901 (segment
->p_flags
& PF_X
? 'E' : ' '));
4902 print_vma (segment
->p_align
, HEX
);
4907 putc ('\n', stdout
);
4909 switch (segment
->p_type
)
4913 error (_("more than one dynamic segment\n"));
4915 /* By default, assume that the .dynamic section is the first
4916 section in the DYNAMIC segment. */
4917 dynamic_addr
= segment
->p_offset
;
4918 dynamic_size
= segment
->p_filesz
;
4919 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4920 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4922 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4923 dynamic_addr
= dynamic_size
= 0;
4926 /* Try to locate the .dynamic section. If there is
4927 a section header table, we can easily locate it. */
4928 if (section_headers
!= NULL
)
4930 Elf_Internal_Shdr
* sec
;
4932 sec
= find_section (".dynamic");
4933 if (sec
== NULL
|| sec
->sh_size
== 0)
4935 /* A corresponding .dynamic section is expected, but on
4936 IA-64/OpenVMS it is OK for it to be missing. */
4937 if (!is_ia64_vms ())
4938 error (_("no .dynamic section in the dynamic segment\n"));
4942 if (sec
->sh_type
== SHT_NOBITS
)
4948 dynamic_addr
= sec
->sh_offset
;
4949 dynamic_size
= sec
->sh_size
;
4951 if (dynamic_addr
< segment
->p_offset
4952 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4953 warn (_("the .dynamic section is not contained"
4954 " within the dynamic segment\n"));
4955 else if (dynamic_addr
> segment
->p_offset
)
4956 warn (_("the .dynamic section is not the first section"
4957 " in the dynamic segment.\n"));
4962 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4964 error (_("Unable to find program interpreter name\n"));
4968 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4970 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4971 error (_("Internal error: failed to create format string to display program interpreter\n"));
4973 program_interpreter
[0] = 0;
4974 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4975 error (_("Unable to read program interpreter name\n"));
4978 printf (_(" [Requesting program interpreter: %s]\n"),
4979 program_interpreter
);
4985 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4987 printf (_("\n Section to Segment mapping:\n"));
4988 printf (_(" Segment Sections...\n"));
4990 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4993 Elf_Internal_Shdr
* section
;
4995 segment
= program_headers
+ i
;
4996 section
= section_headers
+ 1;
4998 printf (" %2.2d ", i
);
5000 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5002 if (!ELF_TBSS_SPECIAL (section
, segment
)
5003 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5004 printf ("%s ", printable_section_name (section
));
5015 /* Find the file offset corresponding to VMA by using the program headers. */
5018 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5020 Elf_Internal_Phdr
* seg
;
5022 if (! get_program_headers (file
))
5024 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5028 for (seg
= program_headers
;
5029 seg
< program_headers
+ elf_header
.e_phnum
;
5032 if (seg
->p_type
!= PT_LOAD
)
5035 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5036 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5037 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5040 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5041 (unsigned long) vma
);
5046 /* Allocate memory and load the sections headers into the global pointer
5047 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5048 generate any error messages if the load fails. */
5051 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5053 Elf32_External_Shdr
* shdrs
;
5054 Elf_Internal_Shdr
* internal
;
5056 unsigned int size
= elf_header
.e_shentsize
;
5057 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5059 /* PR binutils/17531: Cope with unexpected section header sizes. */
5060 if (size
== 0 || num
== 0)
5062 if (size
< sizeof * shdrs
)
5065 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5068 if (!probe
&& size
> sizeof * shdrs
)
5069 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5071 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5073 probe
? NULL
: _("section headers"));
5077 if (section_headers
!= NULL
)
5078 free (section_headers
);
5079 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5080 sizeof (Elf_Internal_Shdr
));
5081 if (section_headers
== NULL
)
5084 error (_("Out of memory reading %u section headers\n"), num
);
5088 for (i
= 0, internal
= section_headers
;
5092 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5093 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5094 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5095 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5096 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5097 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5098 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5099 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5100 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5101 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5102 if (!probe
&& internal
->sh_link
> num
)
5103 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5104 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5105 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5113 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5115 Elf64_External_Shdr
* shdrs
;
5116 Elf_Internal_Shdr
* internal
;
5118 unsigned int size
= elf_header
.e_shentsize
;
5119 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5121 /* PR binutils/17531: Cope with unexpected section header sizes. */
5122 if (size
== 0 || num
== 0)
5124 if (size
< sizeof * shdrs
)
5127 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5130 if (! probe
&& size
> sizeof * shdrs
)
5131 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5133 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5135 probe
? NULL
: _("section headers"));
5139 if (section_headers
!= NULL
)
5140 free (section_headers
);
5141 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5142 sizeof (Elf_Internal_Shdr
));
5143 if (section_headers
== NULL
)
5146 error (_("Out of memory reading %u section headers\n"), num
);
5150 for (i
= 0, internal
= section_headers
;
5154 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5155 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5156 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5157 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5158 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5159 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5160 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5161 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5162 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5163 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5164 if (!probe
&& internal
->sh_link
> num
)
5165 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5166 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5167 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5174 static Elf_Internal_Sym
*
5175 get_32bit_elf_symbols (FILE * file
,
5176 Elf_Internal_Shdr
* section
,
5177 unsigned long * num_syms_return
)
5179 unsigned long number
= 0;
5180 Elf32_External_Sym
* esyms
= NULL
;
5181 Elf_External_Sym_Shndx
* shndx
= NULL
;
5182 Elf_Internal_Sym
* isyms
= NULL
;
5183 Elf_Internal_Sym
* psym
;
5186 if (section
->sh_size
== 0)
5188 if (num_syms_return
!= NULL
)
5189 * num_syms_return
= 0;
5193 /* Run some sanity checks first. */
5194 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5196 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5197 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5201 if (section
->sh_size
> current_file_size
)
5203 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5204 printable_section_name (section
), (unsigned long) section
->sh_size
);
5208 number
= section
->sh_size
/ section
->sh_entsize
;
5210 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5212 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5213 (unsigned long) section
->sh_size
,
5214 printable_section_name (section
),
5215 (unsigned long) section
->sh_entsize
);
5219 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5220 section
->sh_size
, _("symbols"));
5225 elf_section_list
* entry
;
5228 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5229 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5231 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5232 entry
->hdr
->sh_offset
,
5233 1, entry
->hdr
->sh_size
,
5234 _("symbol table section indicies"));
5237 /* PR17531: file: heap-buffer-overflow */
5238 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5240 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5241 printable_section_name (entry
->hdr
),
5242 (unsigned long) entry
->hdr
->sh_size
,
5243 (unsigned long) section
->sh_size
);
5249 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5253 error (_("Out of memory reading %lu symbols\n"),
5254 (unsigned long) number
);
5258 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5260 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5261 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5262 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5263 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5264 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5266 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5267 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5268 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5269 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5270 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5279 if (num_syms_return
!= NULL
)
5280 * num_syms_return
= isyms
== NULL
? 0 : number
;
5285 static Elf_Internal_Sym
*
5286 get_64bit_elf_symbols (FILE * file
,
5287 Elf_Internal_Shdr
* section
,
5288 unsigned long * num_syms_return
)
5290 unsigned long number
= 0;
5291 Elf64_External_Sym
* esyms
= NULL
;
5292 Elf_External_Sym_Shndx
* shndx
= NULL
;
5293 Elf_Internal_Sym
* isyms
= NULL
;
5294 Elf_Internal_Sym
* psym
;
5297 if (section
->sh_size
== 0)
5299 if (num_syms_return
!= NULL
)
5300 * num_syms_return
= 0;
5304 /* Run some sanity checks first. */
5305 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5307 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5308 printable_section_name (section
),
5309 (unsigned long) section
->sh_entsize
);
5313 if (section
->sh_size
> current_file_size
)
5315 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5316 printable_section_name (section
),
5317 (unsigned long) section
->sh_size
);
5321 number
= section
->sh_size
/ section
->sh_entsize
;
5323 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5325 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5326 (unsigned long) section
->sh_size
,
5327 printable_section_name (section
),
5328 (unsigned long) section
->sh_entsize
);
5332 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5333 section
->sh_size
, _("symbols"));
5338 elf_section_list
* entry
;
5341 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5342 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5344 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5345 entry
->hdr
->sh_offset
,
5346 1, entry
->hdr
->sh_size
,
5347 _("symbol table section indicies"));
5350 /* PR17531: file: heap-buffer-overflow */
5351 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5353 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5354 printable_section_name (entry
->hdr
),
5355 (unsigned long) entry
->hdr
->sh_size
,
5356 (unsigned long) section
->sh_size
);
5362 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5366 error (_("Out of memory reading %lu symbols\n"),
5367 (unsigned long) number
);
5371 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5373 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5374 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5375 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5376 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5378 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5380 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5381 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5382 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5384 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5385 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5394 if (num_syms_return
!= NULL
)
5395 * num_syms_return
= isyms
== NULL
? 0 : number
;
5401 get_elf_section_flags (bfd_vma sh_flags
)
5403 static char buff
[1024];
5405 int field_size
= is_32bit_elf
? 8 : 16;
5407 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5408 bfd_vma os_flags
= 0;
5409 bfd_vma proc_flags
= 0;
5410 bfd_vma unknown_flags
= 0;
5418 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5419 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5420 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5421 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5422 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5423 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5424 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5425 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5426 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5427 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5428 /* IA-64 specific. */
5429 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5430 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5431 /* IA-64 OpenVMS specific. */
5432 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5433 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5434 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5435 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5436 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5437 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5439 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5440 /* SPARC specific. */
5441 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5442 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5444 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5445 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5446 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5449 if (do_section_details
)
5451 sprintf (buff
, "[%*.*lx]: ",
5452 field_size
, field_size
, (unsigned long) sh_flags
);
5453 p
+= field_size
+ 4;
5460 flag
= sh_flags
& - sh_flags
;
5463 if (do_section_details
)
5467 case SHF_WRITE
: sindex
= 0; break;
5468 case SHF_ALLOC
: sindex
= 1; break;
5469 case SHF_EXECINSTR
: sindex
= 2; break;
5470 case SHF_MERGE
: sindex
= 3; break;
5471 case SHF_STRINGS
: sindex
= 4; break;
5472 case SHF_INFO_LINK
: sindex
= 5; break;
5473 case SHF_LINK_ORDER
: sindex
= 6; break;
5474 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5475 case SHF_GROUP
: sindex
= 8; break;
5476 case SHF_TLS
: sindex
= 9; break;
5477 case SHF_EXCLUDE
: sindex
= 18; break;
5478 case SHF_COMPRESSED
: sindex
= 20; break;
5482 switch (elf_header
.e_machine
)
5485 if (flag
== SHF_IA_64_SHORT
)
5487 else if (flag
== SHF_IA_64_NORECOV
)
5490 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5493 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5494 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5495 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5496 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5497 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5498 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5509 case EM_OLD_SPARCV9
:
5510 case EM_SPARC32PLUS
:
5513 if (flag
== SHF_ORDERED
)
5520 case SHF_ENTRYSECT
: sindex
= 21; break;
5521 case SHF_ARM_PURECODE
: sindex
= 22; break;
5522 case SHF_COMDEF
: sindex
= 23; break;
5534 if (p
!= buff
+ field_size
+ 4)
5536 if (size
< (10 + 2))
5538 warn (_("Internal error: not enough buffer room for section flag info"));
5539 return _("<unknown>");
5546 size
-= flags
[sindex
].len
;
5547 p
= stpcpy (p
, flags
[sindex
].str
);
5549 else if (flag
& SHF_MASKOS
)
5551 else if (flag
& SHF_MASKPROC
)
5554 unknown_flags
|= flag
;
5560 case SHF_WRITE
: *p
= 'W'; break;
5561 case SHF_ALLOC
: *p
= 'A'; break;
5562 case SHF_EXECINSTR
: *p
= 'X'; break;
5563 case SHF_MERGE
: *p
= 'M'; break;
5564 case SHF_STRINGS
: *p
= 'S'; break;
5565 case SHF_INFO_LINK
: *p
= 'I'; break;
5566 case SHF_LINK_ORDER
: *p
= 'L'; break;
5567 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5568 case SHF_GROUP
: *p
= 'G'; break;
5569 case SHF_TLS
: *p
= 'T'; break;
5570 case SHF_EXCLUDE
: *p
= 'E'; break;
5571 case SHF_COMPRESSED
: *p
= 'C'; break;
5574 if ((elf_header
.e_machine
== EM_X86_64
5575 || elf_header
.e_machine
== EM_L1OM
5576 || elf_header
.e_machine
== EM_K1OM
)
5577 && flag
== SHF_X86_64_LARGE
)
5579 else if (elf_header
.e_machine
== EM_ARM
5580 && flag
== SHF_ARM_PURECODE
)
5582 else if (flag
& SHF_MASKOS
)
5585 sh_flags
&= ~ SHF_MASKOS
;
5587 else if (flag
& SHF_MASKPROC
)
5590 sh_flags
&= ~ SHF_MASKPROC
;
5600 if (do_section_details
)
5604 size
-= 5 + field_size
;
5605 if (p
!= buff
+ field_size
+ 4)
5609 warn (_("Internal error: not enough buffer room for section flag info"));
5610 return _("<unknown>");
5616 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5617 (unsigned long) os_flags
);
5618 p
+= 5 + field_size
;
5622 size
-= 7 + field_size
;
5623 if (p
!= buff
+ field_size
+ 4)
5627 warn (_("Internal error: not enough buffer room for section flag info"));
5628 return _("<unknown>");
5634 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5635 (unsigned long) proc_flags
);
5636 p
+= 7 + field_size
;
5640 size
-= 10 + field_size
;
5641 if (p
!= buff
+ field_size
+ 4)
5645 warn (_("Internal error: not enough buffer room for section flag info"));
5646 return _("<unknown>");
5652 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5653 (unsigned long) unknown_flags
);
5654 p
+= 10 + field_size
;
5663 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5667 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5669 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5670 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5671 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5672 return sizeof (*echdr
);
5676 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5678 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5679 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5680 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5681 return sizeof (*echdr
);
5686 process_section_headers (FILE * file
)
5688 Elf_Internal_Shdr
* section
;
5691 section_headers
= NULL
;
5693 if (elf_header
.e_shnum
== 0)
5695 /* PR binutils/12467. */
5696 if (elf_header
.e_shoff
!= 0)
5697 warn (_("possibly corrupt ELF file header - it has a non-zero"
5698 " section header offset, but no section headers\n"));
5699 else if (do_sections
)
5700 printf (_("\nThere are no sections in this file.\n"));
5705 if (do_sections
&& !do_header
)
5706 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5707 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5711 if (! get_32bit_section_headers (file
, FALSE
))
5714 else if (! get_64bit_section_headers (file
, FALSE
))
5717 /* Read in the string table, so that we have names to display. */
5718 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5719 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5721 section
= section_headers
+ elf_header
.e_shstrndx
;
5723 if (section
->sh_size
!= 0)
5725 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5726 1, section
->sh_size
,
5729 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5733 /* Scan the sections for the dynamic symbol table
5734 and dynamic string table and debug sections. */
5735 dynamic_symbols
= NULL
;
5736 dynamic_strings
= NULL
;
5737 dynamic_syminfo
= NULL
;
5738 symtab_shndx_list
= NULL
;
5740 eh_addr_size
= is_32bit_elf
? 4 : 8;
5741 switch (elf_header
.e_machine
)
5744 case EM_MIPS_RS3_LE
:
5745 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5746 FDE addresses. However, the ABI also has a semi-official ILP32
5747 variant for which the normal FDE address size rules apply.
5749 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5750 section, where XX is the size of longs in bits. Unfortunately,
5751 earlier compilers provided no way of distinguishing ILP32 objects
5752 from LP64 objects, so if there's any doubt, we should assume that
5753 the official LP64 form is being used. */
5754 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5755 && find_section (".gcc_compiled_long32") == NULL
)
5761 switch (elf_header
.e_flags
& EF_H8_MACH
)
5763 case E_H8_MACH_H8300
:
5764 case E_H8_MACH_H8300HN
:
5765 case E_H8_MACH_H8300SN
:
5766 case E_H8_MACH_H8300SXN
:
5769 case E_H8_MACH_H8300H
:
5770 case E_H8_MACH_H8300S
:
5771 case E_H8_MACH_H8300SX
:
5779 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5781 case EF_M32C_CPU_M16C
:
5788 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5791 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5792 if (section->sh_entsize != expected_entsize) \
5795 sprintf_vma (buf, section->sh_entsize); \
5796 /* Note: coded this way so that there is a single string for \
5798 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5799 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5800 (unsigned) expected_entsize); \
5801 section->sh_entsize = expected_entsize; \
5806 #define CHECK_ENTSIZE(section, i, type) \
5807 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5808 sizeof (Elf64_External_##type))
5810 for (i
= 0, section
= section_headers
;
5811 i
< elf_header
.e_shnum
;
5814 char * name
= SECTION_NAME (section
);
5816 if (section
->sh_type
== SHT_DYNSYM
)
5818 if (dynamic_symbols
!= NULL
)
5820 error (_("File contains multiple dynamic symbol tables\n"));
5824 CHECK_ENTSIZE (section
, i
, Sym
);
5825 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5827 else if (section
->sh_type
== SHT_STRTAB
5828 && streq (name
, ".dynstr"))
5830 if (dynamic_strings
!= NULL
)
5832 error (_("File contains multiple dynamic string tables\n"));
5836 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5837 1, section
->sh_size
,
5838 _("dynamic strings"));
5839 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5841 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5843 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5844 entry
->hdr
= section
;
5845 entry
->next
= symtab_shndx_list
;
5846 symtab_shndx_list
= entry
;
5848 else if (section
->sh_type
== SHT_SYMTAB
)
5849 CHECK_ENTSIZE (section
, i
, Sym
);
5850 else if (section
->sh_type
== SHT_GROUP
)
5851 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5852 else if (section
->sh_type
== SHT_REL
)
5853 CHECK_ENTSIZE (section
, i
, Rel
);
5854 else if (section
->sh_type
== SHT_RELA
)
5855 CHECK_ENTSIZE (section
, i
, Rela
);
5856 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5857 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5858 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5859 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5860 || do_debug_addr
|| do_debug_cu_index
)
5861 && (const_strneq (name
, ".debug_")
5862 || const_strneq (name
, ".zdebug_")))
5865 name
+= sizeof (".zdebug_") - 1;
5867 name
+= sizeof (".debug_") - 1;
5870 || (do_debug_info
&& const_strneq (name
, "info"))
5871 || (do_debug_info
&& const_strneq (name
, "types"))
5872 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5873 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5874 || (do_debug_lines
&& const_strneq (name
, "line."))
5875 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5876 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5877 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5878 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5879 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5880 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5881 || (do_debug_frames
&& const_strneq (name
, "frame"))
5882 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5883 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5884 || (do_debug_str
&& const_strneq (name
, "str"))
5885 || (do_debug_loc
&& const_strneq (name
, "loc"))
5886 || (do_debug_addr
&& const_strneq (name
, "addr"))
5887 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5888 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5890 request_dump_bynumber (i
, DEBUG_DUMP
);
5892 /* Linkonce section to be combined with .debug_info at link time. */
5893 else if ((do_debugging
|| do_debug_info
)
5894 && const_strneq (name
, ".gnu.linkonce.wi."))
5895 request_dump_bynumber (i
, DEBUG_DUMP
);
5896 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5897 request_dump_bynumber (i
, DEBUG_DUMP
);
5898 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5899 request_dump_bynumber (i
, DEBUG_DUMP
);
5900 /* Trace sections for Itanium VMS. */
5901 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5902 || do_trace_aranges
)
5903 && const_strneq (name
, ".trace_"))
5905 name
+= sizeof (".trace_") - 1;
5908 || (do_trace_info
&& streq (name
, "info"))
5909 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5910 || (do_trace_aranges
&& streq (name
, "aranges"))
5912 request_dump_bynumber (i
, DEBUG_DUMP
);
5919 if (elf_header
.e_shnum
> 1)
5920 printf (_("\nSection Headers:\n"));
5922 printf (_("\nSection Header:\n"));
5926 if (do_section_details
)
5928 printf (_(" [Nr] Name\n"));
5929 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5933 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5937 if (do_section_details
)
5939 printf (_(" [Nr] Name\n"));
5940 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5944 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5948 if (do_section_details
)
5950 printf (_(" [Nr] Name\n"));
5951 printf (_(" Type Address Offset Link\n"));
5952 printf (_(" Size EntSize Info Align\n"));
5956 printf (_(" [Nr] Name Type Address Offset\n"));
5957 printf (_(" Size EntSize Flags Link Info Align\n"));
5961 if (do_section_details
)
5962 printf (_(" Flags\n"));
5964 for (i
= 0, section
= section_headers
;
5965 i
< elf_header
.e_shnum
;
5968 /* Run some sanity checks on the section header. */
5970 /* Check the sh_link field. */
5971 switch (section
->sh_type
)
5973 case SHT_SYMTAB_SHNDX
:
5977 case SHT_GNU_versym
:
5980 if (section
->sh_link
< 1
5981 || section
->sh_link
>= elf_header
.e_shnum
5982 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
5983 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
5984 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
5985 i
, section
->sh_link
);
5991 case SHT_GNU_verneed
:
5992 case SHT_GNU_verdef
:
5993 case SHT_GNU_LIBLIST
:
5994 if (section
->sh_link
< 1
5995 || section
->sh_link
>= elf_header
.e_shnum
5996 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
5997 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
5998 i
, section
->sh_link
);
6001 case SHT_INIT_ARRAY
:
6002 case SHT_FINI_ARRAY
:
6003 case SHT_PREINIT_ARRAY
:
6004 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6005 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6006 i
, section
->sh_link
);
6010 /* FIXME: Add support for target specific section types. */
6011 #if 0 /* Currently we do not check other section types as there are too
6012 many special cases. Stab sections for example have a type
6013 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6015 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6016 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6017 i
, section
->sh_link
);
6022 /* Check the sh_info field. */
6023 switch (section
->sh_type
)
6027 if (section
->sh_info
< 1
6028 || section
->sh_info
>= elf_header
.e_shnum
6029 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6030 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6031 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6032 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6033 /* FIXME: Are other section types valid ? */
6034 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6036 if (section
->sh_info
== 0
6037 && (streq (SECTION_NAME (section
), ".rel.dyn")
6038 || streq (SECTION_NAME (section
), ".rela.dyn")))
6039 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6040 of zero. No idea why. I would have expected the index
6041 of the .plt section. */
6044 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6045 i
, section
->sh_info
);
6051 case SHT_SYMTAB_SHNDX
:
6052 case SHT_INIT_ARRAY
:
6053 case SHT_FINI_ARRAY
:
6054 case SHT_PREINIT_ARRAY
:
6055 if (section
->sh_info
!= 0)
6056 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6057 i
, section
->sh_info
);
6063 /* A symbol index - we assume that it is valid. */
6067 /* FIXME: Add support for target specific section types. */
6068 if (section
->sh_type
== SHT_NOBITS
)
6069 /* NOBITS section headers with non-zero sh_info fields can be
6070 created when a binary is stripped of everything but its debug
6071 information. The stripped sections have their headers preserved but their types set to SHT_NOBITS. so do not check this type of section. */
6073 else if (section
->sh_flags
& SHF_INFO_LINK
)
6075 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6076 warn (_("[%2u]: Expected link to another section in info field"), i
);
6078 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6079 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6080 i
, section
->sh_info
);
6084 printf (" [%2u] ", i
);
6085 if (do_section_details
)
6086 printf ("%s\n ", printable_section_name (section
));
6088 print_symbol (-17, SECTION_NAME (section
));
6090 printf (do_wide
? " %-15s " : " %-15.15s ",
6091 get_section_type_name (section
->sh_type
));
6095 const char * link_too_big
= NULL
;
6097 print_vma (section
->sh_addr
, LONG_HEX
);
6099 printf ( " %6.6lx %6.6lx %2.2lx",
6100 (unsigned long) section
->sh_offset
,
6101 (unsigned long) section
->sh_size
,
6102 (unsigned long) section
->sh_entsize
);
6104 if (do_section_details
)
6105 fputs (" ", stdout
);
6107 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6109 if (section
->sh_link
>= elf_header
.e_shnum
)
6112 /* The sh_link value is out of range. Normally this indicates
6113 an error but it can have special values in Solaris binaries. */
6114 switch (elf_header
.e_machine
)
6121 case EM_OLD_SPARCV9
:
6122 case EM_SPARC32PLUS
:
6125 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6126 link_too_big
= "BEFORE";
6127 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6128 link_too_big
= "AFTER";
6135 if (do_section_details
)
6137 if (link_too_big
!= NULL
&& * link_too_big
)
6138 printf ("<%s> ", link_too_big
);
6140 printf ("%2u ", section
->sh_link
);
6141 printf ("%3u %2lu\n", section
->sh_info
,
6142 (unsigned long) section
->sh_addralign
);
6145 printf ("%2u %3u %2lu\n",
6148 (unsigned long) section
->sh_addralign
);
6150 if (link_too_big
&& ! * link_too_big
)
6151 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6152 i
, section
->sh_link
);
6156 print_vma (section
->sh_addr
, LONG_HEX
);
6158 if ((long) section
->sh_offset
== section
->sh_offset
)
6159 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6163 print_vma (section
->sh_offset
, LONG_HEX
);
6166 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6167 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6171 print_vma (section
->sh_size
, LONG_HEX
);
6174 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6175 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6179 print_vma (section
->sh_entsize
, LONG_HEX
);
6182 if (do_section_details
)
6183 fputs (" ", stdout
);
6185 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6187 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6189 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6190 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6193 print_vma (section
->sh_addralign
, DEC
);
6197 else if (do_section_details
)
6199 printf (" %-15.15s ",
6200 get_section_type_name (section
->sh_type
));
6201 print_vma (section
->sh_addr
, LONG_HEX
);
6202 if ((long) section
->sh_offset
== section
->sh_offset
)
6203 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6207 print_vma (section
->sh_offset
, LONG_HEX
);
6209 printf (" %u\n ", section
->sh_link
);
6210 print_vma (section
->sh_size
, LONG_HEX
);
6212 print_vma (section
->sh_entsize
, LONG_HEX
);
6214 printf (" %-16u %lu\n",
6216 (unsigned long) section
->sh_addralign
);
6221 print_vma (section
->sh_addr
, LONG_HEX
);
6222 if ((long) section
->sh_offset
== section
->sh_offset
)
6223 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6227 print_vma (section
->sh_offset
, LONG_HEX
);
6230 print_vma (section
->sh_size
, LONG_HEX
);
6232 print_vma (section
->sh_entsize
, LONG_HEX
);
6234 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6236 printf (" %2u %3u %lu\n",
6239 (unsigned long) section
->sh_addralign
);
6242 if (do_section_details
)
6244 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6245 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6247 /* Minimum section size is 12 bytes for 32-bit compression
6248 header + 12 bytes for compressed data header. */
6249 unsigned char buf
[24];
6251 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6252 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6253 sizeof (buf
), _("compression header")))
6255 Elf_Internal_Chdr chdr
;
6257 (void) get_compression_header (&chdr
, buf
);
6259 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6262 printf (_(" [<unknown>: 0x%x], "),
6264 print_vma (chdr
.ch_size
, LONG_HEX
);
6265 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6271 if (!do_section_details
)
6273 /* The ordering of the letters shown here matches the ordering of the
6274 corresponding SHF_xxx values, and hence the order in which these
6275 letters will be displayed to the user. */
6276 printf (_("Key to Flags:\n\
6277 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6278 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6279 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6280 if (elf_header
.e_machine
== EM_X86_64
6281 || elf_header
.e_machine
== EM_L1OM
6282 || elf_header
.e_machine
== EM_K1OM
)
6283 printf (_("l (large), "));
6284 else if (elf_header
.e_machine
== EM_ARM
)
6285 printf (_("y (purecode), "));
6286 printf ("p (processor specific)\n");
6293 get_group_flags (unsigned int flags
)
6295 static char buff
[128];
6299 else if (flags
== GRP_COMDAT
)
6302 snprintf (buff
, 14, _("[0x%x: "), flags
);
6304 flags
&= ~ GRP_COMDAT
;
6305 if (flags
& GRP_MASKOS
)
6307 strcat (buff
, "<OS specific>");
6308 flags
&= ~ GRP_MASKOS
;
6311 if (flags
& GRP_MASKPROC
)
6313 strcat (buff
, "<PROC specific>");
6314 flags
&= ~ GRP_MASKPROC
;
6318 strcat (buff
, "<unknown>");
6325 process_section_groups (FILE * file
)
6327 Elf_Internal_Shdr
* section
;
6329 struct group
* group
;
6330 Elf_Internal_Shdr
* symtab_sec
;
6331 Elf_Internal_Shdr
* strtab_sec
;
6332 Elf_Internal_Sym
* symtab
;
6333 unsigned long num_syms
;
6337 /* Don't process section groups unless needed. */
6338 if (!do_unwind
&& !do_section_groups
)
6341 if (elf_header
.e_shnum
== 0)
6343 if (do_section_groups
)
6344 printf (_("\nThere are no sections to group in this file.\n"));
6349 if (section_headers
== NULL
)
6351 error (_("Section headers are not available!\n"));
6352 /* PR 13622: This can happen with a corrupt ELF header. */
6356 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6357 sizeof (struct group
*));
6359 if (section_headers_groups
== NULL
)
6361 error (_("Out of memory reading %u section group headers\n"),
6362 elf_header
.e_shnum
);
6366 /* Scan the sections for the group section. */
6368 for (i
= 0, section
= section_headers
;
6369 i
< elf_header
.e_shnum
;
6371 if (section
->sh_type
== SHT_GROUP
)
6374 if (group_count
== 0)
6376 if (do_section_groups
)
6377 printf (_("\nThere are no section groups in this file.\n"));
6382 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6384 if (section_groups
== NULL
)
6386 error (_("Out of memory reading %lu groups\n"),
6387 (unsigned long) group_count
);
6397 for (i
= 0, section
= section_headers
, group
= section_groups
;
6398 i
< elf_header
.e_shnum
;
6401 if (section
->sh_type
== SHT_GROUP
)
6403 const char * name
= printable_section_name (section
);
6404 const char * group_name
;
6405 unsigned char * start
;
6406 unsigned char * indices
;
6407 unsigned int entry
, j
, size
;
6408 Elf_Internal_Shdr
* sec
;
6409 Elf_Internal_Sym
* sym
;
6411 /* Get the symbol table. */
6412 if (section
->sh_link
>= elf_header
.e_shnum
6413 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6416 error (_("Bad sh_link in group section `%s'\n"), name
);
6420 if (symtab_sec
!= sec
)
6425 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6430 error (_("Corrupt header in group section `%s'\n"), name
);
6434 if (section
->sh_info
>= num_syms
)
6436 error (_("Bad sh_info in group section `%s'\n"), name
);
6440 sym
= symtab
+ section
->sh_info
;
6442 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6444 if (sym
->st_shndx
== 0
6445 || sym
->st_shndx
>= elf_header
.e_shnum
)
6447 error (_("Bad sh_info in group section `%s'\n"), name
);
6451 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6460 /* Get the string table. */
6461 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6470 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6476 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6477 1, strtab_sec
->sh_size
,
6479 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6481 group_name
= sym
->st_name
< strtab_size
6482 ? strtab
+ sym
->st_name
: _("<corrupt>");
6485 /* PR 17531: file: loop. */
6486 if (section
->sh_entsize
> section
->sh_size
)
6488 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6489 printable_section_name (section
),
6490 (unsigned long) section
->sh_entsize
,
6491 (unsigned long) section
->sh_size
);
6495 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6496 1, section
->sh_size
,
6502 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6503 entry
= byte_get (indices
, 4);
6506 if (do_section_groups
)
6508 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6509 get_group_flags (entry
), i
, name
, group_name
, size
);
6511 printf (_(" [Index] Name\n"));
6514 group
->group_index
= i
;
6516 for (j
= 0; j
< size
; j
++)
6518 struct group_list
* g
;
6520 entry
= byte_get (indices
, 4);
6523 if (entry
>= elf_header
.e_shnum
)
6525 static unsigned num_group_errors
= 0;
6527 if (num_group_errors
++ < 10)
6529 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6530 entry
, i
, elf_header
.e_shnum
- 1);
6531 if (num_group_errors
== 10)
6532 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6537 if (section_headers_groups
[entry
] != NULL
)
6541 static unsigned num_errs
= 0;
6543 if (num_errs
++ < 10)
6545 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6547 section_headers_groups
[entry
]->group_index
);
6549 warn (_("Further error messages about already contained group sections suppressed\n"));
6555 /* Intel C/C++ compiler may put section 0 in a
6556 section group. We just warn it the first time
6557 and ignore it afterwards. */
6558 static int warned
= 0;
6561 error (_("section 0 in group section [%5u]\n"),
6562 section_headers_groups
[entry
]->group_index
);
6568 section_headers_groups
[entry
] = group
;
6570 if (do_section_groups
)
6572 sec
= section_headers
+ entry
;
6573 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6576 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6577 g
->section_index
= entry
;
6578 g
->next
= group
->root
;
6596 /* Data used to display dynamic fixups. */
6598 struct ia64_vms_dynfixup
6600 bfd_vma needed_ident
; /* Library ident number. */
6601 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6602 bfd_vma fixup_needed
; /* Index of the library. */
6603 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6604 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6607 /* Data used to display dynamic relocations. */
6609 struct ia64_vms_dynimgrela
6611 bfd_vma img_rela_cnt
; /* Number of relocations. */
6612 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6615 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6619 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6620 const char *strtab
, unsigned int strtab_sz
)
6622 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6624 const char *lib_name
;
6626 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6627 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6628 _("dynamic section image fixups"));
6632 if (fixup
->needed
< strtab_sz
)
6633 lib_name
= strtab
+ fixup
->needed
;
6636 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6637 (unsigned long) fixup
->needed
);
6640 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6641 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6643 (_("Seg Offset Type SymVec DataType\n"));
6645 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6650 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6651 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6652 type
= BYTE_GET (imfs
[i
].type
);
6653 rtype
= elf_ia64_reloc_type (type
);
6655 printf (" 0x%08x ", type
);
6657 printf (" %-32s ", rtype
);
6658 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6659 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6665 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6668 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6670 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6673 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6674 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6675 _("dynamic section image relocations"));
6679 printf (_("\nImage relocs\n"));
6681 (_("Seg Offset Type Addend Seg Sym Off\n"));
6683 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6688 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6689 printf ("%08" BFD_VMA_FMT
"x ",
6690 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6691 type
= BYTE_GET (imrs
[i
].type
);
6692 rtype
= elf_ia64_reloc_type (type
);
6694 printf ("0x%08x ", type
);
6696 printf ("%-31s ", rtype
);
6697 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6698 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6699 printf ("%08" BFD_VMA_FMT
"x\n",
6700 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6706 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6709 process_ia64_vms_dynamic_relocs (FILE *file
)
6711 struct ia64_vms_dynfixup fixup
;
6712 struct ia64_vms_dynimgrela imgrela
;
6713 Elf_Internal_Dyn
*entry
;
6715 bfd_vma strtab_off
= 0;
6716 bfd_vma strtab_sz
= 0;
6717 char *strtab
= NULL
;
6719 memset (&fixup
, 0, sizeof (fixup
));
6720 memset (&imgrela
, 0, sizeof (imgrela
));
6722 /* Note: the order of the entries is specified by the OpenVMS specs. */
6723 for (entry
= dynamic_section
;
6724 entry
< dynamic_section
+ dynamic_nent
;
6727 switch (entry
->d_tag
)
6729 case DT_IA_64_VMS_STRTAB_OFFSET
:
6730 strtab_off
= entry
->d_un
.d_val
;
6733 strtab_sz
= entry
->d_un
.d_val
;
6735 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6736 1, strtab_sz
, _("dynamic string section"));
6739 case DT_IA_64_VMS_NEEDED_IDENT
:
6740 fixup
.needed_ident
= entry
->d_un
.d_val
;
6743 fixup
.needed
= entry
->d_un
.d_val
;
6745 case DT_IA_64_VMS_FIXUP_NEEDED
:
6746 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6748 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6749 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6751 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6752 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6754 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6757 case DT_IA_64_VMS_IMG_RELA_CNT
:
6758 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6760 case DT_IA_64_VMS_IMG_RELA_OFF
:
6761 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6763 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6783 } dynamic_relocations
[] =
6785 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6786 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6787 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6790 /* Process the reloc section. */
6793 process_relocs (FILE * file
)
6795 unsigned long rel_size
;
6796 unsigned long rel_offset
;
6802 if (do_using_dynamic
)
6806 int has_dynamic_reloc
;
6809 has_dynamic_reloc
= 0;
6811 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6813 is_rela
= dynamic_relocations
[i
].rela
;
6814 name
= dynamic_relocations
[i
].name
;
6815 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6816 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6818 has_dynamic_reloc
|= rel_size
;
6820 if (is_rela
== UNKNOWN
)
6822 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6823 switch (dynamic_info
[DT_PLTREL
])
6837 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6838 name
, rel_offset
, rel_size
);
6840 dump_relocations (file
,
6841 offset_from_vma (file
, rel_offset
, rel_size
),
6843 dynamic_symbols
, num_dynamic_syms
,
6844 dynamic_strings
, dynamic_strings_length
,
6850 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6852 if (! has_dynamic_reloc
)
6853 printf (_("\nThere are no dynamic relocations in this file.\n"));
6857 Elf_Internal_Shdr
* section
;
6861 for (i
= 0, section
= section_headers
;
6862 i
< elf_header
.e_shnum
;
6865 if ( section
->sh_type
!= SHT_RELA
6866 && section
->sh_type
!= SHT_REL
)
6869 rel_offset
= section
->sh_offset
;
6870 rel_size
= section
->sh_size
;
6874 Elf_Internal_Shdr
* strsec
;
6877 printf (_("\nRelocation section "));
6879 if (string_table
== NULL
)
6880 printf ("%d", section
->sh_name
);
6882 printf ("'%s'", printable_section_name (section
));
6884 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6885 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6887 is_rela
= section
->sh_type
== SHT_RELA
;
6889 if (section
->sh_link
!= 0
6890 && section
->sh_link
< elf_header
.e_shnum
)
6892 Elf_Internal_Shdr
* symsec
;
6893 Elf_Internal_Sym
* symtab
;
6894 unsigned long nsyms
;
6895 unsigned long strtablen
= 0;
6896 char * strtab
= NULL
;
6898 symsec
= section_headers
+ section
->sh_link
;
6899 if (symsec
->sh_type
!= SHT_SYMTAB
6900 && symsec
->sh_type
!= SHT_DYNSYM
)
6903 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6908 if (symsec
->sh_link
!= 0
6909 && symsec
->sh_link
< elf_header
.e_shnum
)
6911 strsec
= section_headers
+ symsec
->sh_link
;
6913 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6916 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6919 dump_relocations (file
, rel_offset
, rel_size
,
6920 symtab
, nsyms
, strtab
, strtablen
,
6922 symsec
->sh_type
== SHT_DYNSYM
);
6928 dump_relocations (file
, rel_offset
, rel_size
,
6929 NULL
, 0, NULL
, 0, is_rela
, 0);
6936 printf (_("\nThere are no relocations in this file.\n"));
6942 /* An absolute address consists of a section and an offset. If the
6943 section is NULL, the offset itself is the address, otherwise, the
6944 address equals to LOAD_ADDRESS(section) + offset. */
6948 unsigned short section
;
6952 #define ABSADDR(a) \
6954 ? section_headers [(a).section].sh_addr + (a).offset \
6957 /* Find the nearest symbol at or below ADDR. Returns the symbol
6958 name, if found, and the offset from the symbol to ADDR. */
6961 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6962 unsigned long nsyms
,
6963 const char * strtab
,
6964 unsigned long strtab_size
,
6965 struct absaddr addr
,
6966 const char ** symname
,
6969 bfd_vma dist
= 0x100000;
6970 Elf_Internal_Sym
* sym
;
6971 Elf_Internal_Sym
* beg
;
6972 Elf_Internal_Sym
* end
;
6973 Elf_Internal_Sym
* best
= NULL
;
6975 REMOVE_ARCH_BITS (addr
.offset
);
6977 end
= symtab
+ nsyms
;
6983 sym
= beg
+ (end
- beg
) / 2;
6985 value
= sym
->st_value
;
6986 REMOVE_ARCH_BITS (value
);
6988 if (sym
->st_name
!= 0
6989 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6990 && addr
.offset
>= value
6991 && addr
.offset
- value
< dist
)
6994 dist
= addr
.offset
- value
;
6999 if (addr
.offset
< value
)
7007 *symname
= (best
->st_name
>= strtab_size
7008 ? _("<corrupt>") : strtab
+ best
->st_name
);
7014 *offset
= addr
.offset
;
7018 symcmp (const void *p
, const void *q
)
7020 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7021 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7023 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7026 /* Process the unwind section. */
7028 #include "unwind-ia64.h"
7030 struct ia64_unw_table_entry
7032 struct absaddr start
;
7034 struct absaddr info
;
7037 struct ia64_unw_aux_info
7039 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7040 unsigned long table_len
; /* Length of unwind table. */
7041 unsigned char * info
; /* Unwind info. */
7042 unsigned long info_size
; /* Size of unwind info. */
7043 bfd_vma info_addr
; /* Starting address of unwind info. */
7044 bfd_vma seg_base
; /* Starting address of segment. */
7045 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7046 unsigned long nsyms
; /* Number of symbols. */
7047 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7048 unsigned long nfuns
; /* Number of entries in funtab. */
7049 char * strtab
; /* The string table. */
7050 unsigned long strtab_size
; /* Size of string table. */
7054 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7056 struct ia64_unw_table_entry
* tp
;
7057 unsigned long j
, nfuns
;
7060 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7061 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7062 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7063 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7065 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7067 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7071 const unsigned char * dp
;
7072 const unsigned char * head
;
7073 const unsigned char * end
;
7074 const char * procname
;
7076 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7077 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7079 fputs ("\n<", stdout
);
7083 fputs (procname
, stdout
);
7086 printf ("+%lx", (unsigned long) offset
);
7089 fputs (">: [", stdout
);
7090 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7091 fputc ('-', stdout
);
7092 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7093 printf ("], info at +0x%lx\n",
7094 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7096 /* PR 17531: file: 86232b32. */
7097 if (aux
->info
== NULL
)
7100 /* PR 17531: file: 0997b4d1. */
7101 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7103 warn (_("Invalid offset %lx in table entry %ld\n"),
7104 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7108 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7109 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7111 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7112 (unsigned) UNW_VER (stamp
),
7113 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7114 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7115 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7116 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7118 if (UNW_VER (stamp
) != 1)
7120 printf (_("\tUnknown version.\n"));
7125 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7126 /* PR 17531: file: 16ceda89. */
7127 if (end
> aux
->info
+ aux
->info_size
)
7128 end
= aux
->info
+ aux
->info_size
;
7129 for (dp
= head
+ 8; dp
< end
;)
7130 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7137 slurp_ia64_unwind_table (FILE * file
,
7138 struct ia64_unw_aux_info
* aux
,
7139 Elf_Internal_Shdr
* sec
)
7141 unsigned long size
, nrelas
, i
;
7142 Elf_Internal_Phdr
* seg
;
7143 struct ia64_unw_table_entry
* tep
;
7144 Elf_Internal_Shdr
* relsec
;
7145 Elf_Internal_Rela
* rela
;
7146 Elf_Internal_Rela
* rp
;
7147 unsigned char * table
;
7149 Elf_Internal_Sym
* sym
;
7150 const char * relname
;
7154 /* First, find the starting address of the segment that includes
7157 if (elf_header
.e_phnum
)
7159 if (! get_program_headers (file
))
7162 for (seg
= program_headers
;
7163 seg
< program_headers
+ elf_header
.e_phnum
;
7166 if (seg
->p_type
!= PT_LOAD
)
7169 if (sec
->sh_addr
>= seg
->p_vaddr
7170 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7172 aux
->seg_base
= seg
->p_vaddr
;
7178 /* Second, build the unwind table from the contents of the unwind section: */
7179 size
= sec
->sh_size
;
7180 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7185 aux
->table_len
= size
/ (3 * eh_addr_size
);
7186 aux
->table
= (struct ia64_unw_table_entry
*)
7187 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7190 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7192 tep
->start
.section
= SHN_UNDEF
;
7193 tep
->end
.section
= SHN_UNDEF
;
7194 tep
->info
.section
= SHN_UNDEF
;
7195 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7196 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7197 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7198 tep
->start
.offset
+= aux
->seg_base
;
7199 tep
->end
.offset
+= aux
->seg_base
;
7200 tep
->info
.offset
+= aux
->seg_base
;
7204 /* Third, apply any relocations to the unwind table: */
7205 for (relsec
= section_headers
;
7206 relsec
< section_headers
+ elf_header
.e_shnum
;
7209 if (relsec
->sh_type
!= SHT_RELA
7210 || relsec
->sh_info
>= elf_header
.e_shnum
7211 || section_headers
+ relsec
->sh_info
!= sec
)
7214 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7223 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7225 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7226 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7228 /* PR 17531: file: 9fa67536. */
7229 if (relname
== NULL
)
7231 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7235 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7237 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7241 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7243 /* PR 17531: file: 5bc8d9bf. */
7244 if (i
>= aux
->table_len
)
7246 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7250 switch (rp
->r_offset
/ eh_addr_size
% 3)
7253 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7254 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7257 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7258 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7261 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7262 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7276 ia64_process_unwind (FILE * file
)
7278 Elf_Internal_Shdr
* sec
;
7279 Elf_Internal_Shdr
* unwsec
= NULL
;
7280 Elf_Internal_Shdr
* strsec
;
7281 unsigned long i
, unwcount
= 0, unwstart
= 0;
7282 struct ia64_unw_aux_info aux
;
7284 memset (& aux
, 0, sizeof (aux
));
7286 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7288 if (sec
->sh_type
== SHT_SYMTAB
7289 && sec
->sh_link
< elf_header
.e_shnum
)
7291 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7293 strsec
= section_headers
+ sec
->sh_link
;
7294 if (aux
.strtab
!= NULL
)
7296 error (_("Multiple auxillary string tables encountered\n"));
7299 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7302 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7304 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7309 printf (_("\nThere are no unwind sections in this file.\n"));
7311 while (unwcount
-- > 0)
7316 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7317 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7318 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7323 /* We have already counted the number of SHT_IA64_UNWIND
7324 sections so the loop above should never fail. */
7325 assert (unwsec
!= NULL
);
7328 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7330 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7332 /* We need to find which section group it is in. */
7333 struct group_list
* g
;
7335 if (section_headers_groups
== NULL
7336 || section_headers_groups
[i
] == NULL
)
7337 i
= elf_header
.e_shnum
;
7340 g
= section_headers_groups
[i
]->root
;
7342 for (; g
!= NULL
; g
= g
->next
)
7344 sec
= section_headers
+ g
->section_index
;
7346 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7351 i
= elf_header
.e_shnum
;
7354 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7356 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7357 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7358 suffix
= SECTION_NAME (unwsec
) + len
;
7359 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7361 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7362 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7367 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7368 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7369 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7370 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7372 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7373 suffix
= SECTION_NAME (unwsec
) + len
;
7374 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7376 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7377 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7381 if (i
== elf_header
.e_shnum
)
7383 printf (_("\nCould not find unwind info section for "));
7385 if (string_table
== NULL
)
7386 printf ("%d", unwsec
->sh_name
);
7388 printf ("'%s'", printable_section_name (unwsec
));
7392 aux
.info_addr
= sec
->sh_addr
;
7393 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7396 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7398 printf (_("\nUnwind section "));
7400 if (string_table
== NULL
)
7401 printf ("%d", unwsec
->sh_name
);
7403 printf ("'%s'", printable_section_name (unwsec
));
7405 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7406 (unsigned long) unwsec
->sh_offset
,
7407 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7409 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7410 && aux
.table_len
> 0)
7411 dump_ia64_unwind (& aux
);
7414 free ((char *) aux
.table
);
7416 free ((char *) aux
.info
);
7425 free ((char *) aux
.strtab
);
7428 struct hppa_unw_table_entry
7430 struct absaddr start
;
7432 unsigned int Cannot_unwind
:1; /* 0 */
7433 unsigned int Millicode
:1; /* 1 */
7434 unsigned int Millicode_save_sr0
:1; /* 2 */
7435 unsigned int Region_description
:2; /* 3..4 */
7436 unsigned int reserved1
:1; /* 5 */
7437 unsigned int Entry_SR
:1; /* 6 */
7438 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7439 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7440 unsigned int Args_stored
:1; /* 16 */
7441 unsigned int Variable_Frame
:1; /* 17 */
7442 unsigned int Separate_Package_Body
:1; /* 18 */
7443 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7444 unsigned int Stack_Overflow_Check
:1; /* 20 */
7445 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7446 unsigned int Ada_Region
:1; /* 22 */
7447 unsigned int cxx_info
:1; /* 23 */
7448 unsigned int cxx_try_catch
:1; /* 24 */
7449 unsigned int sched_entry_seq
:1; /* 25 */
7450 unsigned int reserved2
:1; /* 26 */
7451 unsigned int Save_SP
:1; /* 27 */
7452 unsigned int Save_RP
:1; /* 28 */
7453 unsigned int Save_MRP_in_frame
:1; /* 29 */
7454 unsigned int extn_ptr_defined
:1; /* 30 */
7455 unsigned int Cleanup_defined
:1; /* 31 */
7457 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7458 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7459 unsigned int Large_frame
:1; /* 2 */
7460 unsigned int Pseudo_SP_Set
:1; /* 3 */
7461 unsigned int reserved4
:1; /* 4 */
7462 unsigned int Total_frame_size
:27; /* 5..31 */
7465 struct hppa_unw_aux_info
7467 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7468 unsigned long table_len
; /* Length of unwind table. */
7469 bfd_vma seg_base
; /* Starting address of segment. */
7470 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7471 unsigned long nsyms
; /* Number of symbols. */
7472 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7473 unsigned long nfuns
; /* Number of entries in funtab. */
7474 char * strtab
; /* The string table. */
7475 unsigned long strtab_size
; /* Size of string table. */
7479 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7481 struct hppa_unw_table_entry
* tp
;
7482 unsigned long j
, nfuns
;
7484 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7485 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7486 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7487 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7489 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7491 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7494 const char * procname
;
7496 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7497 aux
->strtab_size
, tp
->start
, &procname
,
7500 fputs ("\n<", stdout
);
7504 fputs (procname
, stdout
);
7507 printf ("+%lx", (unsigned long) offset
);
7510 fputs (">: [", stdout
);
7511 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7512 fputc ('-', stdout
);
7513 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7516 #define PF(_m) if (tp->_m) printf (#_m " ");
7517 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7520 PF(Millicode_save_sr0
);
7521 /* PV(Region_description); */
7527 PF(Separate_Package_Body
);
7528 PF(Frame_Extension_Millicode
);
7529 PF(Stack_Overflow_Check
);
7530 PF(Two_Instruction_SP_Increment
);
7534 PF(sched_entry_seq
);
7537 PF(Save_MRP_in_frame
);
7538 PF(extn_ptr_defined
);
7539 PF(Cleanup_defined
);
7540 PF(MPE_XL_interrupt_marker
);
7541 PF(HP_UX_interrupt_marker
);
7544 PV(Total_frame_size
);
7555 slurp_hppa_unwind_table (FILE * file
,
7556 struct hppa_unw_aux_info
* aux
,
7557 Elf_Internal_Shdr
* sec
)
7559 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7560 Elf_Internal_Phdr
* seg
;
7561 struct hppa_unw_table_entry
* tep
;
7562 Elf_Internal_Shdr
* relsec
;
7563 Elf_Internal_Rela
* rela
;
7564 Elf_Internal_Rela
* rp
;
7565 unsigned char * table
;
7567 Elf_Internal_Sym
* sym
;
7568 const char * relname
;
7570 /* First, find the starting address of the segment that includes
7573 if (elf_header
.e_phnum
)
7575 if (! get_program_headers (file
))
7578 for (seg
= program_headers
;
7579 seg
< program_headers
+ elf_header
.e_phnum
;
7582 if (seg
->p_type
!= PT_LOAD
)
7585 if (sec
->sh_addr
>= seg
->p_vaddr
7586 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7588 aux
->seg_base
= seg
->p_vaddr
;
7594 /* Second, build the unwind table from the contents of the unwind
7596 size
= sec
->sh_size
;
7597 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7603 nentries
= size
/ unw_ent_size
;
7604 size
= unw_ent_size
* nentries
;
7606 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7607 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7609 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7611 unsigned int tmp1
, tmp2
;
7613 tep
->start
.section
= SHN_UNDEF
;
7614 tep
->end
.section
= SHN_UNDEF
;
7616 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7617 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7618 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7619 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7621 tep
->start
.offset
+= aux
->seg_base
;
7622 tep
->end
.offset
+= aux
->seg_base
;
7624 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7625 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7626 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7627 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7628 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7629 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7630 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7631 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7632 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7633 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7634 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7635 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7636 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7637 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7638 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7639 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7640 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7641 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7642 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7643 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7644 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7645 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7646 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7647 tep
->Cleanup_defined
= tmp1
& 0x1;
7649 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7650 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7651 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7652 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7653 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7654 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7658 /* Third, apply any relocations to the unwind table. */
7659 for (relsec
= section_headers
;
7660 relsec
< section_headers
+ elf_header
.e_shnum
;
7663 if (relsec
->sh_type
!= SHT_RELA
7664 || relsec
->sh_info
>= elf_header
.e_shnum
7665 || section_headers
+ relsec
->sh_info
!= sec
)
7668 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7672 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7674 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7675 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7677 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7678 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7680 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7684 i
= rp
->r_offset
/ unw_ent_size
;
7686 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7689 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7690 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7693 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7694 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7704 aux
->table_len
= nentries
;
7710 hppa_process_unwind (FILE * file
)
7712 struct hppa_unw_aux_info aux
;
7713 Elf_Internal_Shdr
* unwsec
= NULL
;
7714 Elf_Internal_Shdr
* strsec
;
7715 Elf_Internal_Shdr
* sec
;
7718 if (string_table
== NULL
)
7721 memset (& aux
, 0, sizeof (aux
));
7723 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7725 if (sec
->sh_type
== SHT_SYMTAB
7726 && sec
->sh_link
< elf_header
.e_shnum
)
7728 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7730 strsec
= section_headers
+ sec
->sh_link
;
7731 if (aux
.strtab
!= NULL
)
7733 error (_("Multiple auxillary string tables encountered\n"));
7736 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7739 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7741 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7746 printf (_("\nThere are no unwind sections in this file.\n"));
7748 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7750 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7752 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7753 printable_section_name (sec
),
7754 (unsigned long) sec
->sh_offset
,
7755 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7757 slurp_hppa_unwind_table (file
, &aux
, sec
);
7758 if (aux
.table_len
> 0)
7759 dump_hppa_unwind (&aux
);
7762 free ((char *) aux
.table
);
7770 free ((char *) aux
.strtab
);
7775 unsigned char * data
; /* The unwind data. */
7776 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7777 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7778 unsigned long nrelas
; /* The number of relocations. */
7779 unsigned int rel_type
; /* REL or RELA ? */
7780 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7783 struct arm_unw_aux_info
7785 FILE * file
; /* The file containing the unwind sections. */
7786 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7787 unsigned long nsyms
; /* Number of symbols. */
7788 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7789 unsigned long nfuns
; /* Number of these symbols. */
7790 char * strtab
; /* The file's string table. */
7791 unsigned long strtab_size
; /* Size of string table. */
7795 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7796 bfd_vma fn
, struct absaddr addr
)
7798 const char *procname
;
7801 if (addr
.section
== SHN_UNDEF
)
7804 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7805 aux
->strtab_size
, addr
, &procname
,
7808 print_vma (fn
, PREFIX_HEX
);
7812 fputs (" <", stdout
);
7813 fputs (procname
, stdout
);
7816 printf ("+0x%lx", (unsigned long) sym_offset
);
7817 fputc ('>', stdout
);
7824 arm_free_section (struct arm_section
*arm_sec
)
7826 if (arm_sec
->data
!= NULL
)
7827 free (arm_sec
->data
);
7829 if (arm_sec
->rela
!= NULL
)
7830 free (arm_sec
->rela
);
7833 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7834 cached section and install SEC instead.
7835 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7836 and return its valued in * WORDP, relocating if necessary.
7837 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7838 relocation's offset in ADDR.
7839 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7840 into the string table of the symbol associated with the reloc. If no
7841 reloc was applied store -1 there.
7842 5) Return TRUE upon success, FALSE otherwise. */
7845 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7846 struct arm_section
* arm_sec
,
7847 Elf_Internal_Shdr
* sec
,
7848 bfd_vma word_offset
,
7849 unsigned int * wordp
,
7850 struct absaddr
* addr
,
7853 Elf_Internal_Rela
*rp
;
7854 Elf_Internal_Sym
*sym
;
7855 const char * relname
;
7857 bfd_boolean wrapped
;
7859 if (sec
== NULL
|| arm_sec
== NULL
)
7862 addr
->section
= SHN_UNDEF
;
7865 if (sym_name
!= NULL
)
7866 *sym_name
= (bfd_vma
) -1;
7868 /* If necessary, update the section cache. */
7869 if (sec
!= arm_sec
->sec
)
7871 Elf_Internal_Shdr
*relsec
;
7873 arm_free_section (arm_sec
);
7876 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7877 sec
->sh_size
, _("unwind data"));
7878 arm_sec
->rela
= NULL
;
7879 arm_sec
->nrelas
= 0;
7881 for (relsec
= section_headers
;
7882 relsec
< section_headers
+ elf_header
.e_shnum
;
7885 if (relsec
->sh_info
>= elf_header
.e_shnum
7886 || section_headers
+ relsec
->sh_info
!= sec
7887 /* PR 15745: Check the section type as well. */
7888 || (relsec
->sh_type
!= SHT_REL
7889 && relsec
->sh_type
!= SHT_RELA
))
7892 arm_sec
->rel_type
= relsec
->sh_type
;
7893 if (relsec
->sh_type
== SHT_REL
)
7895 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7897 & arm_sec
->rela
, & arm_sec
->nrelas
))
7900 else /* relsec->sh_type == SHT_RELA */
7902 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7904 & arm_sec
->rela
, & arm_sec
->nrelas
))
7910 arm_sec
->next_rela
= arm_sec
->rela
;
7913 /* If there is no unwind data we can do nothing. */
7914 if (arm_sec
->data
== NULL
)
7917 /* If the offset is invalid then fail. */
7918 if (word_offset
> (sec
->sh_size
- 4)
7920 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7921 || ((bfd_signed_vma
) word_offset
) < 0)
7924 /* Get the word at the required offset. */
7925 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7927 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7928 if (arm_sec
->rela
== NULL
)
7934 /* Look through the relocs to find the one that applies to the provided offset. */
7936 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7938 bfd_vma prelval
, offset
;
7940 if (rp
->r_offset
> word_offset
&& !wrapped
)
7945 if (rp
->r_offset
> word_offset
)
7948 if (rp
->r_offset
& 3)
7950 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7951 (unsigned long) rp
->r_offset
);
7955 if (rp
->r_offset
< word_offset
)
7958 /* PR 17531: file: 027-161405-0.004 */
7959 if (aux
->symtab
== NULL
)
7962 if (arm_sec
->rel_type
== SHT_REL
)
7964 offset
= word
& 0x7fffffff;
7965 if (offset
& 0x40000000)
7966 offset
|= ~ (bfd_vma
) 0x7fffffff;
7968 else if (arm_sec
->rel_type
== SHT_RELA
)
7969 offset
= rp
->r_addend
;
7972 error (_("Unknown section relocation type %d encountered\n"),
7977 /* PR 17531 file: 027-1241568-0.004. */
7978 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7980 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7981 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7985 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7986 offset
+= sym
->st_value
;
7987 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7989 /* Check that we are processing the expected reloc type. */
7990 if (elf_header
.e_machine
== EM_ARM
)
7992 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7993 if (relname
== NULL
)
7995 warn (_("Skipping unknown ARM relocation type: %d\n"),
7996 (int) ELF32_R_TYPE (rp
->r_info
));
8000 if (streq (relname
, "R_ARM_NONE"))
8003 if (! streq (relname
, "R_ARM_PREL31"))
8005 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8009 else if (elf_header
.e_machine
== EM_TI_C6000
)
8011 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8012 if (relname
== NULL
)
8014 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8015 (int) ELF32_R_TYPE (rp
->r_info
));
8019 if (streq (relname
, "R_C6000_NONE"))
8022 if (! streq (relname
, "R_C6000_PREL31"))
8024 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8032 /* This function currently only supports ARM and TI unwinders. */
8033 warn (_("Only TI and ARM unwinders are currently supported\n"));
8037 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8038 addr
->section
= sym
->st_shndx
;
8039 addr
->offset
= offset
;
8042 * sym_name
= sym
->st_name
;
8047 arm_sec
->next_rela
= rp
;
8052 static const char *tic6x_unwind_regnames
[16] =
8054 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8055 "A14", "A13", "A12", "A11", "A10",
8056 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8060 decode_tic6x_unwind_regmask (unsigned int mask
)
8064 for (i
= 12; mask
; mask
>>= 1, i
--)
8068 fputs (tic6x_unwind_regnames
[i
], stdout
);
8070 fputs (", ", stdout
);
8076 if (remaining == 0 && more_words) \
8079 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8080 data_offset, & word, & addr, NULL)) \
8086 #define GET_OP(OP) \
8091 (OP) = word >> 24; \
8096 printf (_("[Truncated opcode]\n")); \
8099 printf ("0x%02x ", OP)
8102 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8104 unsigned int remaining
,
8105 unsigned int more_words
,
8106 bfd_vma data_offset
,
8107 Elf_Internal_Shdr
* data_sec
,
8108 struct arm_section
* data_arm_sec
)
8110 struct absaddr addr
;
8112 /* Decode the unwinding instructions. */
8115 unsigned int op
, op2
;
8124 printf (" 0x%02x ", op
);
8126 if ((op
& 0xc0) == 0x00)
8128 int offset
= ((op
& 0x3f) << 2) + 4;
8130 printf (" vsp = vsp + %d", offset
);
8132 else if ((op
& 0xc0) == 0x40)
8134 int offset
= ((op
& 0x3f) << 2) + 4;
8136 printf (" vsp = vsp - %d", offset
);
8138 else if ((op
& 0xf0) == 0x80)
8141 if (op
== 0x80 && op2
== 0)
8142 printf (_("Refuse to unwind"));
8145 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8150 for (i
= 0; i
< 12; i
++)
8151 if (mask
& (1 << i
))
8157 printf ("r%d", 4 + i
);
8162 else if ((op
& 0xf0) == 0x90)
8164 if (op
== 0x9d || op
== 0x9f)
8165 printf (_(" [Reserved]"));
8167 printf (" vsp = r%d", op
& 0x0f);
8169 else if ((op
& 0xf0) == 0xa0)
8171 int end
= 4 + (op
& 0x07);
8176 for (i
= 4; i
<= end
; i
++)
8192 else if (op
== 0xb0)
8193 printf (_(" finish"));
8194 else if (op
== 0xb1)
8197 if (op2
== 0 || (op2
& 0xf0) != 0)
8198 printf (_("[Spare]"));
8201 unsigned int mask
= op2
& 0x0f;
8206 for (i
= 0; i
< 12; i
++)
8207 if (mask
& (1 << i
))
8218 else if (op
== 0xb2)
8220 unsigned char buf
[9];
8221 unsigned int i
, len
;
8222 unsigned long offset
;
8224 for (i
= 0; i
< sizeof (buf
); i
++)
8227 if ((buf
[i
] & 0x80) == 0)
8230 if (i
== sizeof (buf
))
8231 printf (_("corrupt change to vsp"));
8234 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8235 assert (len
== i
+ 1);
8236 offset
= offset
* 4 + 0x204;
8237 printf ("vsp = vsp + %ld", offset
);
8240 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8242 unsigned int first
, last
;
8249 printf ("pop {D%d", first
);
8251 printf ("-D%d", first
+ last
);
8254 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8256 unsigned int count
= op
& 0x07;
8260 printf ("-D%d", 8 + count
);
8263 else if (op
>= 0xc0 && op
<= 0xc5)
8265 unsigned int count
= op
& 0x07;
8267 printf (" pop {wR10");
8269 printf ("-wR%d", 10 + count
);
8272 else if (op
== 0xc6)
8274 unsigned int first
, last
;
8279 printf ("pop {wR%d", first
);
8281 printf ("-wR%d", first
+ last
);
8284 else if (op
== 0xc7)
8287 if (op2
== 0 || (op2
& 0xf0) != 0)
8288 printf (_("[Spare]"));
8291 unsigned int mask
= op2
& 0x0f;
8296 for (i
= 0; i
< 4; i
++)
8297 if (mask
& (1 << i
))
8303 printf ("wCGR%d", i
);
8309 printf (_(" [unsupported opcode]"));
8315 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8317 unsigned int remaining
,
8318 unsigned int more_words
,
8319 bfd_vma data_offset
,
8320 Elf_Internal_Shdr
* data_sec
,
8321 struct arm_section
* data_arm_sec
)
8323 struct absaddr addr
;
8325 /* Decode the unwinding instructions. */
8328 unsigned int op
, op2
;
8337 printf (" 0x%02x ", op
);
8339 if ((op
& 0xc0) == 0x00)
8341 int offset
= ((op
& 0x3f) << 3) + 8;
8342 printf (" sp = sp + %d", offset
);
8344 else if ((op
& 0xc0) == 0x80)
8347 if (op
== 0x80 && op2
== 0)
8348 printf (_("Refuse to unwind"));
8351 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8353 printf ("pop compact {");
8357 decode_tic6x_unwind_regmask (mask
);
8361 else if ((op
& 0xf0) == 0xc0)
8369 unsigned int offset
;
8373 /* Scan entire instruction first so that GET_OP output is not
8374 interleaved with disassembly. */
8376 for (i
= 0; nregs
< (op
& 0xf); i
++)
8382 regpos
[nregs
].offset
= i
* 2;
8383 regpos
[nregs
].reg
= reg
;
8390 regpos
[nregs
].offset
= i
* 2 + 1;
8391 regpos
[nregs
].reg
= reg
;
8396 printf (_("pop frame {"));
8398 for (i
= i
* 2; i
> 0; i
--)
8400 if (regpos
[reg
].offset
== i
- 1)
8402 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8409 fputs (name
, stdout
);
8416 else if (op
== 0xd0)
8417 printf (" MOV FP, SP");
8418 else if (op
== 0xd1)
8419 printf (" __c6xabi_pop_rts");
8420 else if (op
== 0xd2)
8422 unsigned char buf
[9];
8423 unsigned int i
, len
;
8424 unsigned long offset
;
8426 for (i
= 0; i
< sizeof (buf
); i
++)
8429 if ((buf
[i
] & 0x80) == 0)
8432 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8433 if (i
== sizeof (buf
))
8435 printf ("<corrupt sp adjust>\n");
8436 warn (_("Corrupt stack pointer adjustment detected\n"));
8440 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8441 assert (len
== i
+ 1);
8442 offset
= offset
* 8 + 0x408;
8443 printf (_("sp = sp + %ld"), offset
);
8445 else if ((op
& 0xf0) == 0xe0)
8447 if ((op
& 0x0f) == 7)
8450 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8454 printf (_(" [unsupported opcode]"));
8461 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8465 offset
= word
& 0x7fffffff;
8466 if (offset
& 0x40000000)
8467 offset
|= ~ (bfd_vma
) 0x7fffffff;
8469 if (elf_header
.e_machine
== EM_TI_C6000
)
8472 return offset
+ where
;
8476 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8478 unsigned int remaining
,
8479 bfd_vma data_offset
,
8480 Elf_Internal_Shdr
* data_sec
,
8481 struct arm_section
* data_arm_sec
)
8484 unsigned int more_words
= 0;
8485 struct absaddr addr
;
8486 bfd_vma sym_name
= (bfd_vma
) -1;
8490 /* Fetch the first word.
8491 Note - when decoding an object file the address extracted
8492 here will always be 0. So we also pass in the sym_name
8493 parameter so that we can find the symbol associated with
8494 the personality routine. */
8495 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8496 & word
, & addr
, & sym_name
))
8502 if ((word
& 0x80000000) == 0)
8504 /* Expand prel31 for personality routine. */
8506 const char *procname
;
8508 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8509 printf (_(" Personality routine: "));
8511 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8512 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8514 procname
= aux
->strtab
+ sym_name
;
8515 print_vma (fn
, PREFIX_HEX
);
8518 fputs (" <", stdout
);
8519 fputs (procname
, stdout
);
8520 fputc ('>', stdout
);
8524 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8525 fputc ('\n', stdout
);
8527 /* The GCC personality routines use the standard compact
8528 encoding, starting with one byte giving the number of
8530 if (procname
!= NULL
8531 && (const_strneq (procname
, "__gcc_personality_v0")
8532 || const_strneq (procname
, "__gxx_personality_v0")
8533 || const_strneq (procname
, "__gcj_personality_v0")
8534 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8541 printf (_(" [Truncated data]\n"));
8544 more_words
= word
>> 24;
8554 /* ARM EHABI Section 6.3:
8556 An exception-handling table entry for the compact model looks like:
8560 1 0 index Data for personalityRoutine[index] */
8562 if (elf_header
.e_machine
== EM_ARM
8563 && (word
& 0x70000000))
8564 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8566 per_index
= (word
>> 24) & 0x7f;
8567 printf (_(" Compact model index: %d\n"), per_index
);
8574 else if (per_index
< 3)
8576 more_words
= (word
>> 16) & 0xff;
8582 switch (elf_header
.e_machine
)
8587 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8588 data_offset
, data_sec
, data_arm_sec
);
8592 warn (_("Unknown ARM compact model index encountered\n"));
8593 printf (_(" [reserved]\n"));
8600 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8601 data_offset
, data_sec
, data_arm_sec
);
8603 else if (per_index
< 5)
8605 if (((word
>> 17) & 0x7f) == 0x7f)
8606 printf (_(" Restore stack from frame pointer\n"));
8608 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8609 printf (_(" Registers restored: "));
8611 printf (" (compact) ");
8612 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8614 printf (_(" Return register: %s\n"),
8615 tic6x_unwind_regnames
[word
& 0xf]);
8618 printf (_(" [reserved (%d)]\n"), per_index
);
8622 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8623 elf_header
.e_machine
);
8626 /* Decode the descriptors. Not implemented. */
8630 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8632 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8633 unsigned int i
, exidx_len
;
8634 unsigned long j
, nfuns
;
8636 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8637 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8638 exidx_len
= exidx_sec
->sh_size
/ 8;
8640 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8641 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8642 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8643 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8645 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8647 for (i
= 0; i
< exidx_len
; i
++)
8649 unsigned int exidx_fn
, exidx_entry
;
8650 struct absaddr fn_addr
, entry_addr
;
8653 fputc ('\n', stdout
);
8655 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8656 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8657 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8658 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8661 arm_free_section (& exidx_arm_sec
);
8662 arm_free_section (& extab_arm_sec
);
8666 /* ARM EHABI, Section 5:
8667 An index table entry consists of 2 words.
8668 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8669 if (exidx_fn
& 0x80000000)
8670 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8672 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8674 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8675 fputs (": ", stdout
);
8677 if (exidx_entry
== 1)
8679 print_vma (exidx_entry
, PREFIX_HEX
);
8680 fputs (" [cantunwind]\n", stdout
);
8682 else if (exidx_entry
& 0x80000000)
8684 print_vma (exidx_entry
, PREFIX_HEX
);
8685 fputc ('\n', stdout
);
8686 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8690 bfd_vma table
, table_offset
= 0;
8691 Elf_Internal_Shdr
*table_sec
;
8693 fputs ("@", stdout
);
8694 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8695 print_vma (table
, PREFIX_HEX
);
8698 /* Locate the matching .ARM.extab. */
8699 if (entry_addr
.section
!= SHN_UNDEF
8700 && entry_addr
.section
< elf_header
.e_shnum
)
8702 table_sec
= section_headers
+ entry_addr
.section
;
8703 table_offset
= entry_addr
.offset
;
8705 if (table_offset
> table_sec
->sh_size
8706 || ((bfd_signed_vma
) table_offset
) < 0)
8708 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8709 (unsigned long) table_offset
,
8710 printable_section_name (table_sec
));
8716 table_sec
= find_section_by_address (table
);
8717 if (table_sec
!= NULL
)
8718 table_offset
= table
- table_sec
->sh_addr
;
8720 if (table_sec
== NULL
)
8722 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8723 (unsigned long) table
);
8726 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8734 arm_free_section (&exidx_arm_sec
);
8735 arm_free_section (&extab_arm_sec
);
8738 /* Used for both ARM and C6X unwinding tables. */
8741 arm_process_unwind (FILE *file
)
8743 struct arm_unw_aux_info aux
;
8744 Elf_Internal_Shdr
*unwsec
= NULL
;
8745 Elf_Internal_Shdr
*strsec
;
8746 Elf_Internal_Shdr
*sec
;
8748 unsigned int sec_type
;
8750 switch (elf_header
.e_machine
)
8753 sec_type
= SHT_ARM_EXIDX
;
8757 sec_type
= SHT_C6000_UNWIND
;
8761 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8762 elf_header
.e_machine
);
8766 if (string_table
== NULL
)
8769 memset (& aux
, 0, sizeof (aux
));
8772 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8774 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8776 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8778 strsec
= section_headers
+ sec
->sh_link
;
8780 /* PR binutils/17531 file: 011-12666-0.004. */
8781 if (aux
.strtab
!= NULL
)
8783 error (_("Multiple string tables found in file.\n"));
8786 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8787 1, strsec
->sh_size
, _("string table"));
8788 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8790 else if (sec
->sh_type
== sec_type
)
8795 printf (_("\nThere are no unwind sections in this file.\n"));
8797 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8799 if (sec
->sh_type
== sec_type
)
8801 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8802 printable_section_name (sec
),
8803 (unsigned long) sec
->sh_offset
,
8804 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8806 dump_arm_unwind (&aux
, sec
);
8813 free ((char *) aux
.strtab
);
8817 process_unwind (FILE * file
)
8819 struct unwind_handler
8822 void (* handler
)(FILE *);
8825 { EM_ARM
, arm_process_unwind
},
8826 { EM_IA_64
, ia64_process_unwind
},
8827 { EM_PARISC
, hppa_process_unwind
},
8828 { EM_TI_C6000
, arm_process_unwind
},
8836 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8837 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8839 handlers
[i
].handler (file
);
8843 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8844 get_machine_name (elf_header
.e_machine
));
8848 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8850 switch (entry
->d_tag
)
8853 if (entry
->d_un
.d_val
== 0)
8857 static const char * opts
[] =
8859 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8860 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8861 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8862 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8868 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8869 if (entry
->d_un
.d_val
& (1 << cnt
))
8871 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8877 case DT_MIPS_IVERSION
:
8878 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8879 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8883 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8884 /* Note: coded this way so that there is a single string for translation. */
8885 printf (_("<corrupt: %s>"), buf
);
8889 case DT_MIPS_TIME_STAMP
:
8893 time_t atime
= entry
->d_un
.d_val
;
8895 tmp
= gmtime (&atime
);
8896 /* PR 17531: file: 6accc532. */
8898 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8900 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8901 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8902 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8903 printf (_("Time Stamp: %s"), timebuf
);
8907 case DT_MIPS_RLD_VERSION
:
8908 case DT_MIPS_LOCAL_GOTNO
:
8909 case DT_MIPS_CONFLICTNO
:
8910 case DT_MIPS_LIBLISTNO
:
8911 case DT_MIPS_SYMTABNO
:
8912 case DT_MIPS_UNREFEXTNO
:
8913 case DT_MIPS_HIPAGENO
:
8914 case DT_MIPS_DELTA_CLASS_NO
:
8915 case DT_MIPS_DELTA_INSTANCE_NO
:
8916 case DT_MIPS_DELTA_RELOC_NO
:
8917 case DT_MIPS_DELTA_SYM_NO
:
8918 case DT_MIPS_DELTA_CLASSSYM_NO
:
8919 case DT_MIPS_COMPACT_SIZE
:
8920 print_vma (entry
->d_un
.d_val
, DEC
);
8924 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8930 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8932 switch (entry
->d_tag
)
8934 case DT_HP_DLD_FLAGS
:
8943 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8944 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8945 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8946 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8947 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8948 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8949 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8950 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8951 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8952 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8953 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8954 { DT_HP_GST
, "HP_GST" },
8955 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8956 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8957 { DT_HP_NODELETE
, "HP_NODELETE" },
8958 { DT_HP_GROUP
, "HP_GROUP" },
8959 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8963 bfd_vma val
= entry
->d_un
.d_val
;
8965 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8966 if (val
& flags
[cnt
].bit
)
8970 fputs (flags
[cnt
].str
, stdout
);
8972 val
^= flags
[cnt
].bit
;
8975 if (val
!= 0 || first
)
8979 print_vma (val
, HEX
);
8985 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8993 /* VMS vs Unix time offset and factor. */
8995 #define VMS_EPOCH_OFFSET 35067168000000000LL
8996 #define VMS_GRANULARITY_FACTOR 10000000
8998 /* Display a VMS time in a human readable format. */
9001 print_vms_time (bfd_int64_t vmstime
)
9006 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9007 tm
= gmtime (&unxtime
);
9008 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9009 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9010 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9015 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9017 switch (entry
->d_tag
)
9019 case DT_IA_64_PLT_RESERVE
:
9020 /* First 3 slots reserved. */
9021 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9023 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9026 case DT_IA_64_VMS_LINKTIME
:
9028 print_vms_time (entry
->d_un
.d_val
);
9032 case DT_IA_64_VMS_LNKFLAGS
:
9033 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9034 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9035 printf (" CALL_DEBUG");
9036 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9037 printf (" NOP0BUFS");
9038 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9039 printf (" P0IMAGE");
9040 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9041 printf (" MKTHREADS");
9042 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9043 printf (" UPCALLS");
9044 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9046 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9047 printf (" INITIALIZE");
9048 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9050 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9051 printf (" EXE_INIT");
9052 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9053 printf (" TBK_IN_IMG");
9054 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9055 printf (" DBG_IN_IMG");
9056 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9057 printf (" TBK_IN_DSF");
9058 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9059 printf (" DBG_IN_DSF");
9060 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9061 printf (" SIGNATURES");
9062 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9063 printf (" REL_SEG_OFF");
9067 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9074 get_32bit_dynamic_section (FILE * file
)
9076 Elf32_External_Dyn
* edyn
;
9077 Elf32_External_Dyn
* ext
;
9078 Elf_Internal_Dyn
* entry
;
9080 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9081 dynamic_size
, _("dynamic section"));
9085 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9086 might not have the luxury of section headers. Look for the DT_NULL
9087 terminator to determine the number of entries. */
9088 for (ext
= edyn
, dynamic_nent
= 0;
9089 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9093 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9097 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9099 if (dynamic_section
== NULL
)
9101 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9102 (unsigned long) dynamic_nent
);
9107 for (ext
= edyn
, entry
= dynamic_section
;
9108 entry
< dynamic_section
+ dynamic_nent
;
9111 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9112 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9121 get_64bit_dynamic_section (FILE * file
)
9123 Elf64_External_Dyn
* edyn
;
9124 Elf64_External_Dyn
* ext
;
9125 Elf_Internal_Dyn
* entry
;
9127 /* Read in the data. */
9128 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9129 dynamic_size
, _("dynamic section"));
9133 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9134 might not have the luxury of section headers. Look for the DT_NULL
9135 terminator to determine the number of entries. */
9136 for (ext
= edyn
, dynamic_nent
= 0;
9137 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9138 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9142 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9146 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9148 if (dynamic_section
== NULL
)
9150 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9151 (unsigned long) dynamic_nent
);
9156 /* Convert from external to internal formats. */
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 print_dynamic_flags (bfd_vma flags
)
9179 flag
= flags
& - flags
;
9189 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9190 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9191 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9192 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9193 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9194 default: fputs (_("unknown"), stdout
); break;
9200 /* Parse and display the contents of the dynamic section. */
9203 process_dynamic_section (FILE * file
)
9205 Elf_Internal_Dyn
* entry
;
9207 if (dynamic_size
== 0)
9210 printf (_("\nThere is no dynamic section in this file.\n"));
9217 if (! get_32bit_dynamic_section (file
))
9220 else if (! get_64bit_dynamic_section (file
))
9223 /* Find the appropriate symbol table. */
9224 if (dynamic_symbols
== NULL
)
9226 for (entry
= dynamic_section
;
9227 entry
< dynamic_section
+ dynamic_nent
;
9230 Elf_Internal_Shdr section
;
9232 if (entry
->d_tag
!= DT_SYMTAB
)
9235 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9237 /* Since we do not know how big the symbol table is,
9238 we default to reading in the entire file (!) and
9239 processing that. This is overkill, I know, but it
9241 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9243 if (archive_file_offset
!= 0)
9244 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9247 if (fseek (file
, 0, SEEK_END
))
9248 error (_("Unable to seek to end of file!\n"));
9250 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9254 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9256 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9257 section
.sh_name
= string_table_length
;
9259 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9260 if (num_dynamic_syms
< 1)
9262 error (_("Unable to determine the number of symbols to load\n"));
9268 /* Similarly find a string table. */
9269 if (dynamic_strings
== NULL
)
9271 for (entry
= dynamic_section
;
9272 entry
< dynamic_section
+ dynamic_nent
;
9275 unsigned long offset
;
9278 if (entry
->d_tag
!= DT_STRTAB
)
9281 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9283 /* Since we do not know how big the string table is,
9284 we default to reading in the entire file (!) and
9285 processing that. This is overkill, I know, but it
9288 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9290 if (archive_file_offset
!= 0)
9291 str_tab_len
= archive_file_size
- offset
;
9294 if (fseek (file
, 0, SEEK_END
))
9295 error (_("Unable to seek to end of file\n"));
9296 str_tab_len
= ftell (file
) - offset
;
9299 if (str_tab_len
< 1)
9302 (_("Unable to determine the length of the dynamic string table\n"));
9306 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9308 _("dynamic string table"));
9309 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9314 /* And find the syminfo section if available. */
9315 if (dynamic_syminfo
== NULL
)
9317 unsigned long syminsz
= 0;
9319 for (entry
= dynamic_section
;
9320 entry
< dynamic_section
+ dynamic_nent
;
9323 if (entry
->d_tag
== DT_SYMINENT
)
9325 /* Note: these braces are necessary to avoid a syntax
9326 error from the SunOS4 C compiler. */
9327 /* PR binutils/17531: A corrupt file can trigger this test.
9328 So do not use an assert, instead generate an error message. */
9329 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9330 error (_("Bad value (%d) for SYMINENT entry\n"),
9331 (int) entry
->d_un
.d_val
);
9333 else if (entry
->d_tag
== DT_SYMINSZ
)
9334 syminsz
= entry
->d_un
.d_val
;
9335 else if (entry
->d_tag
== DT_SYMINFO
)
9336 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9340 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9342 Elf_External_Syminfo
* extsyminfo
;
9343 Elf_External_Syminfo
* extsym
;
9344 Elf_Internal_Syminfo
* syminfo
;
9346 /* There is a syminfo section. Read the data. */
9347 extsyminfo
= (Elf_External_Syminfo
*)
9348 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9349 _("symbol information"));
9353 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9354 if (dynamic_syminfo
== NULL
)
9356 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9357 (unsigned long) syminsz
);
9361 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9362 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9363 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9364 ++syminfo
, ++extsym
)
9366 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9367 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9374 if (do_dynamic
&& dynamic_addr
)
9375 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9376 dynamic_addr
, (unsigned long) dynamic_nent
);
9378 printf (_(" Tag Type Name/Value\n"));
9380 for (entry
= dynamic_section
;
9381 entry
< dynamic_section
+ dynamic_nent
;
9389 print_vma (entry
->d_tag
, FULL_HEX
);
9390 dtype
= get_dynamic_type (entry
->d_tag
);
9391 printf (" (%s)%*s", dtype
,
9392 ((is_32bit_elf
? 27 : 19)
9393 - (int) strlen (dtype
)),
9397 switch (entry
->d_tag
)
9401 print_dynamic_flags (entry
->d_un
.d_val
);
9411 switch (entry
->d_tag
)
9414 printf (_("Auxiliary library"));
9418 printf (_("Filter library"));
9422 printf (_("Configuration file"));
9426 printf (_("Dependency audit library"));
9430 printf (_("Audit library"));
9434 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9435 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9439 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9448 printf (_("Flags:"));
9450 if (entry
->d_un
.d_val
== 0)
9451 printf (_(" None\n"));
9454 unsigned long int val
= entry
->d_un
.d_val
;
9456 if (val
& DTF_1_PARINIT
)
9458 printf (" PARINIT");
9459 val
^= DTF_1_PARINIT
;
9461 if (val
& DTF_1_CONFEXP
)
9463 printf (" CONFEXP");
9464 val
^= DTF_1_CONFEXP
;
9467 printf (" %lx", val
);
9476 printf (_("Flags:"));
9478 if (entry
->d_un
.d_val
== 0)
9479 printf (_(" None\n"));
9482 unsigned long int val
= entry
->d_un
.d_val
;
9484 if (val
& DF_P1_LAZYLOAD
)
9486 printf (" LAZYLOAD");
9487 val
^= DF_P1_LAZYLOAD
;
9489 if (val
& DF_P1_GROUPPERM
)
9491 printf (" GROUPPERM");
9492 val
^= DF_P1_GROUPPERM
;
9495 printf (" %lx", val
);
9504 printf (_("Flags:"));
9505 if (entry
->d_un
.d_val
== 0)
9506 printf (_(" None\n"));
9509 unsigned long int val
= entry
->d_un
.d_val
;
9516 if (val
& DF_1_GLOBAL
)
9521 if (val
& DF_1_GROUP
)
9526 if (val
& DF_1_NODELETE
)
9528 printf (" NODELETE");
9529 val
^= DF_1_NODELETE
;
9531 if (val
& DF_1_LOADFLTR
)
9533 printf (" LOADFLTR");
9534 val
^= DF_1_LOADFLTR
;
9536 if (val
& DF_1_INITFIRST
)
9538 printf (" INITFIRST");
9539 val
^= DF_1_INITFIRST
;
9541 if (val
& DF_1_NOOPEN
)
9546 if (val
& DF_1_ORIGIN
)
9551 if (val
& DF_1_DIRECT
)
9556 if (val
& DF_1_TRANS
)
9561 if (val
& DF_1_INTERPOSE
)
9563 printf (" INTERPOSE");
9564 val
^= DF_1_INTERPOSE
;
9566 if (val
& DF_1_NODEFLIB
)
9568 printf (" NODEFLIB");
9569 val
^= DF_1_NODEFLIB
;
9571 if (val
& DF_1_NODUMP
)
9576 if (val
& DF_1_CONFALT
)
9578 printf (" CONFALT");
9579 val
^= DF_1_CONFALT
;
9581 if (val
& DF_1_ENDFILTEE
)
9583 printf (" ENDFILTEE");
9584 val
^= DF_1_ENDFILTEE
;
9586 if (val
& DF_1_DISPRELDNE
)
9588 printf (" DISPRELDNE");
9589 val
^= DF_1_DISPRELDNE
;
9591 if (val
& DF_1_DISPRELPND
)
9593 printf (" DISPRELPND");
9594 val
^= DF_1_DISPRELPND
;
9596 if (val
& DF_1_NODIRECT
)
9598 printf (" NODIRECT");
9599 val
^= DF_1_NODIRECT
;
9601 if (val
& DF_1_IGNMULDEF
)
9603 printf (" IGNMULDEF");
9604 val
^= DF_1_IGNMULDEF
;
9606 if (val
& DF_1_NOKSYMS
)
9608 printf (" NOKSYMS");
9609 val
^= DF_1_NOKSYMS
;
9611 if (val
& DF_1_NOHDR
)
9616 if (val
& DF_1_EDITED
)
9621 if (val
& DF_1_NORELOC
)
9623 printf (" NORELOC");
9624 val
^= DF_1_NORELOC
;
9626 if (val
& DF_1_SYMINTPOSE
)
9628 printf (" SYMINTPOSE");
9629 val
^= DF_1_SYMINTPOSE
;
9631 if (val
& DF_1_GLOBAUDIT
)
9633 printf (" GLOBAUDIT");
9634 val
^= DF_1_GLOBAUDIT
;
9636 if (val
& DF_1_SINGLETON
)
9638 printf (" SINGLETON");
9639 val
^= DF_1_SINGLETON
;
9641 if (val
& DF_1_STUB
)
9652 printf (" %lx", val
);
9659 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9661 puts (get_dynamic_type (entry
->d_un
.d_val
));
9681 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9687 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9688 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9694 switch (entry
->d_tag
)
9697 printf (_("Shared library: [%s]"), name
);
9699 if (streq (name
, program_interpreter
))
9700 printf (_(" program interpreter"));
9704 printf (_("Library soname: [%s]"), name
);
9708 printf (_("Library rpath: [%s]"), name
);
9712 printf (_("Library runpath: [%s]"), name
);
9716 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9721 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9734 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9739 case DT_INIT_ARRAYSZ
:
9740 case DT_FINI_ARRAYSZ
:
9741 case DT_GNU_CONFLICTSZ
:
9742 case DT_GNU_LIBLISTSZ
:
9745 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9746 printf (_(" (bytes)\n"));
9756 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9769 if (entry
->d_tag
== DT_USED
9770 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9772 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9776 printf (_("Not needed object: [%s]\n"), name
);
9781 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9787 /* The value of this entry is ignored. */
9792 case DT_GNU_PRELINKED
:
9796 time_t atime
= entry
->d_un
.d_val
;
9798 tmp
= gmtime (&atime
);
9799 /* PR 17533 file: 041-1244816-0.004. */
9801 printf (_("<corrupt time val: %lx"),
9802 (unsigned long) atime
);
9804 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9805 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9806 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9812 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9815 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9821 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9822 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9827 switch (elf_header
.e_machine
)
9830 case EM_MIPS_RS3_LE
:
9831 dynamic_section_mips_val (entry
);
9834 dynamic_section_parisc_val (entry
);
9837 dynamic_section_ia64_val (entry
);
9840 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9852 get_ver_flags (unsigned int flags
)
9854 static char buff
[32];
9861 if (flags
& VER_FLG_BASE
)
9862 strcat (buff
, "BASE ");
9864 if (flags
& VER_FLG_WEAK
)
9866 if (flags
& VER_FLG_BASE
)
9867 strcat (buff
, "| ");
9869 strcat (buff
, "WEAK ");
9872 if (flags
& VER_FLG_INFO
)
9874 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9875 strcat (buff
, "| ");
9877 strcat (buff
, "INFO ");
9880 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9881 strcat (buff
, _("| <unknown>"));
9886 /* Display the contents of the version sections. */
9889 process_version_sections (FILE * file
)
9891 Elf_Internal_Shdr
* section
;
9898 for (i
= 0, section
= section_headers
;
9899 i
< elf_header
.e_shnum
;
9902 switch (section
->sh_type
)
9904 case SHT_GNU_verdef
:
9906 Elf_External_Verdef
* edefs
;
9913 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9914 printable_section_name (section
),
9917 printf (_(" Addr: 0x"));
9918 printf_vma (section
->sh_addr
);
9919 printf (_(" Offset: %#08lx Link: %u (%s)"),
9920 (unsigned long) section
->sh_offset
, section
->sh_link
,
9921 printable_section_name_from_index (section
->sh_link
));
9923 edefs
= (Elf_External_Verdef
*)
9924 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9925 _("version definition section"));
9928 endbuf
= (char *) edefs
+ section
->sh_size
;
9930 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9933 Elf_External_Verdef
* edef
;
9934 Elf_Internal_Verdef ent
;
9935 Elf_External_Verdaux
* eaux
;
9936 Elf_Internal_Verdaux aux
;
9940 /* Check for very large indicies. */
9941 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9944 vstart
= ((char *) edefs
) + idx
;
9945 if (vstart
+ sizeof (*edef
) > endbuf
)
9948 edef
= (Elf_External_Verdef
*) vstart
;
9950 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9951 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9952 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9953 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9954 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9955 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9956 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9958 printf (_(" %#06x: Rev: %d Flags: %s"),
9959 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9961 printf (_(" Index: %d Cnt: %d "),
9962 ent
.vd_ndx
, ent
.vd_cnt
);
9964 /* Check for overflow. */
9965 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9968 vstart
+= ent
.vd_aux
;
9970 eaux
= (Elf_External_Verdaux
*) vstart
;
9972 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9973 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9975 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9976 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9978 printf (_("Name index: %ld\n"), aux
.vda_name
);
9980 isum
= idx
+ ent
.vd_aux
;
9982 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9984 /* Check for overflow. */
9985 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9988 isum
+= aux
.vda_next
;
9989 vstart
+= aux
.vda_next
;
9991 eaux
= (Elf_External_Verdaux
*) vstart
;
9992 if (vstart
+ sizeof (*eaux
) > endbuf
)
9995 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9996 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9998 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9999 printf (_(" %#06x: Parent %d: %s\n"),
10000 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10002 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10003 isum
, j
, aux
.vda_name
);
10006 if (j
< ent
.vd_cnt
)
10007 printf (_(" Version def aux past end of section\n"));
10009 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10010 if (idx
+ ent
.vd_next
<= idx
)
10013 idx
+= ent
.vd_next
;
10016 if (cnt
< section
->sh_info
)
10017 printf (_(" Version definition past end of section\n"));
10023 case SHT_GNU_verneed
:
10025 Elf_External_Verneed
* eneed
;
10032 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10033 printable_section_name (section
), section
->sh_info
);
10035 printf (_(" Addr: 0x"));
10036 printf_vma (section
->sh_addr
);
10037 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10038 (unsigned long) section
->sh_offset
, section
->sh_link
,
10039 printable_section_name_from_index (section
->sh_link
));
10041 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10042 section
->sh_offset
, 1,
10044 _("Version Needs section"));
10047 endbuf
= (char *) eneed
+ section
->sh_size
;
10049 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10051 Elf_External_Verneed
* entry
;
10052 Elf_Internal_Verneed ent
;
10057 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10060 vstart
= ((char *) eneed
) + idx
;
10061 if (vstart
+ sizeof (*entry
) > endbuf
)
10064 entry
= (Elf_External_Verneed
*) vstart
;
10066 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10067 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10068 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10069 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10070 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10072 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10074 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10075 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10077 printf (_(" File: %lx"), ent
.vn_file
);
10079 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10081 /* Check for overflow. */
10082 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10084 vstart
+= ent
.vn_aux
;
10086 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10088 Elf_External_Vernaux
* eaux
;
10089 Elf_Internal_Vernaux aux
;
10091 if (vstart
+ sizeof (*eaux
) > endbuf
)
10093 eaux
= (Elf_External_Vernaux
*) vstart
;
10095 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10096 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10097 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10098 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10099 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10101 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10102 printf (_(" %#06x: Name: %s"),
10103 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10105 printf (_(" %#06x: Name index: %lx"),
10106 isum
, aux
.vna_name
);
10108 printf (_(" Flags: %s Version: %d\n"),
10109 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10111 /* Check for overflow. */
10112 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10113 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10115 warn (_("Invalid vna_next field of %lx\n"),
10120 isum
+= aux
.vna_next
;
10121 vstart
+= aux
.vna_next
;
10124 if (j
< ent
.vn_cnt
)
10125 warn (_("Missing Version Needs auxillary information\n"));
10127 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10129 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10130 cnt
= section
->sh_info
;
10133 idx
+= ent
.vn_next
;
10136 if (cnt
< section
->sh_info
)
10137 warn (_("Missing Version Needs information\n"));
10143 case SHT_GNU_versym
:
10145 Elf_Internal_Shdr
* link_section
;
10148 unsigned char * edata
;
10149 unsigned short * data
;
10151 Elf_Internal_Sym
* symbols
;
10152 Elf_Internal_Shdr
* string_sec
;
10153 unsigned long num_syms
;
10156 if (section
->sh_link
>= elf_header
.e_shnum
)
10159 link_section
= section_headers
+ section
->sh_link
;
10160 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10162 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10167 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10168 if (symbols
== NULL
)
10171 string_sec
= section_headers
+ link_section
->sh_link
;
10173 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10174 string_sec
->sh_size
,
10175 _("version string table"));
10182 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10183 printable_section_name (section
), (unsigned long) total
);
10185 printf (_(" Addr: "));
10186 printf_vma (section
->sh_addr
);
10187 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10188 (unsigned long) section
->sh_offset
, section
->sh_link
,
10189 printable_section_name (link_section
));
10191 off
= offset_from_vma (file
,
10192 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10193 total
* sizeof (short));
10194 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10196 _("version symbol data"));
10204 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10206 for (cnt
= total
; cnt
--;)
10207 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10212 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10216 char *invalid
= _("*invalid*");
10218 printf (" %03x:", cnt
);
10220 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10221 switch (data
[cnt
+ j
])
10224 fputs (_(" 0 (*local*) "), stdout
);
10228 fputs (_(" 1 (*global*) "), stdout
);
10232 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10233 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10235 /* If this index value is greater than the size of the symbols
10236 array, break to avoid an out-of-bounds read. */
10237 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10239 warn (_("invalid index into symbol array\n"));
10244 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10246 Elf_Internal_Verneed ivn
;
10247 unsigned long offset
;
10249 offset
= offset_from_vma
10250 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10251 sizeof (Elf_External_Verneed
));
10255 Elf_Internal_Vernaux ivna
;
10256 Elf_External_Verneed evn
;
10257 Elf_External_Vernaux evna
;
10258 unsigned long a_off
;
10260 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10261 _("version need")) == NULL
)
10264 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10265 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10267 a_off
= offset
+ ivn
.vn_aux
;
10271 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10272 1, _("version need aux (2)")) == NULL
)
10275 ivna
.vna_other
= 0;
10279 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10280 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10283 a_off
+= ivna
.vna_next
;
10285 while (ivna
.vna_other
!= data
[cnt
+ j
]
10286 && ivna
.vna_next
!= 0);
10288 if (ivna
.vna_other
== data
[cnt
+ j
])
10290 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10292 if (ivna
.vna_name
>= string_sec
->sh_size
)
10295 name
= strtab
+ ivna
.vna_name
;
10299 offset
+= ivn
.vn_next
;
10301 while (ivn
.vn_next
);
10304 if (data
[cnt
+ j
] != 0x8001
10305 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10307 Elf_Internal_Verdef ivd
;
10308 Elf_External_Verdef evd
;
10309 unsigned long offset
;
10311 offset
= offset_from_vma
10312 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10317 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10318 _("version def")) == NULL
)
10321 /* PR 17531: file: 046-1082287-0.004. */
10322 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10327 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10328 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10331 offset
+= ivd
.vd_next
;
10333 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10334 && ivd
.vd_next
!= 0);
10336 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10338 Elf_External_Verdaux evda
;
10339 Elf_Internal_Verdaux ivda
;
10341 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10343 if (get_data (&evda
, file
,
10344 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10346 _("version def aux")) == NULL
)
10349 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10351 if (ivda
.vda_name
>= string_sec
->sh_size
)
10353 else if (name
!= NULL
&& name
!= invalid
)
10354 name
= _("*both*");
10356 name
= strtab
+ ivda
.vda_name
;
10360 nn
+= printf ("(%s%-*s",
10362 12 - (int) strlen (name
),
10366 printf ("%*c", 18 - nn
, ' ');
10384 printf (_("\nNo version information found in this file.\n"));
10389 static const char *
10390 get_symbol_binding (unsigned int binding
)
10392 static char buff
[32];
10396 case STB_LOCAL
: return "LOCAL";
10397 case STB_GLOBAL
: return "GLOBAL";
10398 case STB_WEAK
: return "WEAK";
10400 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10401 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10403 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10405 if (binding
== STB_GNU_UNIQUE
10406 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10407 /* GNU is still using the default value 0. */
10408 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10410 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10413 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10418 static const char *
10419 get_symbol_type (unsigned int type
)
10421 static char buff
[32];
10425 case STT_NOTYPE
: return "NOTYPE";
10426 case STT_OBJECT
: return "OBJECT";
10427 case STT_FUNC
: return "FUNC";
10428 case STT_SECTION
: return "SECTION";
10429 case STT_FILE
: return "FILE";
10430 case STT_COMMON
: return "COMMON";
10431 case STT_TLS
: return "TLS";
10432 case STT_RELC
: return "RELC";
10433 case STT_SRELC
: return "SRELC";
10435 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10437 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10438 return "THUMB_FUNC";
10440 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10443 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10444 return "PARISC_MILLI";
10446 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10448 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10450 if (elf_header
.e_machine
== EM_PARISC
)
10452 if (type
== STT_HP_OPAQUE
)
10453 return "HP_OPAQUE";
10454 if (type
== STT_HP_STUB
)
10458 if (type
== STT_GNU_IFUNC
10459 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10460 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10461 /* GNU is still using the default value 0. */
10462 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10465 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10468 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10473 static const char *
10474 get_symbol_visibility (unsigned int visibility
)
10476 switch (visibility
)
10478 case STV_DEFAULT
: return "DEFAULT";
10479 case STV_INTERNAL
: return "INTERNAL";
10480 case STV_HIDDEN
: return "HIDDEN";
10481 case STV_PROTECTED
: return "PROTECTED";
10483 error (_("Unrecognized visibility value: %u"), visibility
);
10484 return _("<unknown>");
10488 static const char *
10489 get_solaris_symbol_visibility (unsigned int visibility
)
10491 switch (visibility
)
10493 case 4: return "EXPORTED";
10494 case 5: return "SINGLETON";
10495 case 6: return "ELIMINATE";
10496 default: return get_symbol_visibility (visibility
);
10500 static const char *
10501 get_mips_symbol_other (unsigned int other
)
10511 case STO_MICROMIPS
:
10512 return "MICROMIPS";
10513 case STO_MICROMIPS
| STO_MIPS_PIC
:
10514 return "MICROMIPS, MIPS PIC";
10522 static const char *
10523 get_ia64_symbol_other (unsigned int other
)
10525 if (is_ia64_vms ())
10527 static char res
[32];
10531 /* Function types is for images and .STB files only. */
10532 switch (elf_header
.e_type
)
10536 switch (VMS_ST_FUNC_TYPE (other
))
10538 case VMS_SFT_CODE_ADDR
:
10539 strcat (res
, " CA");
10541 case VMS_SFT_SYMV_IDX
:
10542 strcat (res
, " VEC");
10545 strcat (res
, " FD");
10547 case VMS_SFT_RESERVE
:
10548 strcat (res
, " RSV");
10551 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10552 VMS_ST_FUNC_TYPE (other
));
10553 strcat (res
, " <unknown>");
10560 switch (VMS_ST_LINKAGE (other
))
10562 case VMS_STL_IGNORE
:
10563 strcat (res
, " IGN");
10565 case VMS_STL_RESERVE
:
10566 strcat (res
, " RSV");
10569 strcat (res
, " STD");
10572 strcat (res
, " LNK");
10575 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10576 VMS_ST_LINKAGE (other
));
10577 strcat (res
, " <unknown>");
10589 static const char *
10590 get_ppc64_symbol_other (unsigned int other
)
10592 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10594 static char buf
[32];
10595 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10596 PPC64_LOCAL_ENTRY_OFFSET (other
));
10602 static const char *
10603 get_symbol_other (unsigned int other
)
10605 const char * result
= NULL
;
10606 static char buff
[32];
10611 switch (elf_header
.e_machine
)
10614 result
= get_mips_symbol_other (other
);
10617 result
= get_ia64_symbol_other (other
);
10620 result
= get_ppc64_symbol_other (other
);
10630 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10634 static const char *
10635 get_symbol_index_type (unsigned int type
)
10637 static char buff
[32];
10641 case SHN_UNDEF
: return "UND";
10642 case SHN_ABS
: return "ABS";
10643 case SHN_COMMON
: return "COM";
10645 if (type
== SHN_IA_64_ANSI_COMMON
10646 && elf_header
.e_machine
== EM_IA_64
10647 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10649 else if ((elf_header
.e_machine
== EM_X86_64
10650 || elf_header
.e_machine
== EM_L1OM
10651 || elf_header
.e_machine
== EM_K1OM
)
10652 && type
== SHN_X86_64_LCOMMON
)
10653 return "LARGE_COM";
10654 else if ((type
== SHN_MIPS_SCOMMON
10655 && elf_header
.e_machine
== EM_MIPS
)
10656 || (type
== SHN_TIC6X_SCOMMON
10657 && elf_header
.e_machine
== EM_TI_C6000
))
10659 else if (type
== SHN_MIPS_SUNDEFINED
10660 && elf_header
.e_machine
== EM_MIPS
)
10662 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10663 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10664 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10665 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10666 else if (type
>= SHN_LORESERVE
)
10667 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10668 else if (type
>= elf_header
.e_shnum
)
10669 sprintf (buff
, _("bad section index[%3d]"), type
);
10671 sprintf (buff
, "%3d", type
);
10679 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10681 unsigned char * e_data
;
10684 /* If the size_t type is smaller than the bfd_size_type, eg because
10685 you are building a 32-bit tool on a 64-bit host, then make sure
10686 that when (number) is cast to (size_t) no information is lost. */
10687 if (sizeof (size_t) < sizeof (bfd_size_type
)
10688 && (bfd_size_type
) ((size_t) number
) != number
)
10690 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10691 " elements of size %u\n"),
10696 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10697 attempting to allocate memory when the read is bound to fail. */
10698 if (ent_size
* number
> current_file_size
)
10700 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10705 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10706 if (e_data
== NULL
)
10708 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10713 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10715 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10716 number
* ent_size
);
10721 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10722 if (i_data
== NULL
)
10724 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10725 " dynamic entries\n"),
10732 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10740 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10742 Elf_Internal_Sym
* psym
;
10745 n
= print_vma (si
, DEC_5
);
10747 fputs (&" "[n
], stdout
);
10748 printf (" %3lu: ", hn
);
10750 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10752 printf (_("<No info available for dynamic symbol number %lu>\n"),
10753 (unsigned long) si
);
10757 psym
= dynamic_symbols
+ si
;
10758 print_vma (psym
->st_value
, LONG_HEX
);
10760 print_vma (psym
->st_size
, DEC_5
);
10762 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10763 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10765 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10766 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10769 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10771 printf (" %-7s", get_symbol_visibility (vis
));
10772 /* Check to see if any other bits in the st_other field are set.
10773 Note - displaying this information disrupts the layout of the
10774 table being generated, but for the moment this case is very
10776 if (psym
->st_other
^ vis
)
10777 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10780 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10781 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10782 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10784 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10788 static const char *
10789 get_symbol_version_string (FILE * file
,
10790 bfd_boolean is_dynsym
,
10791 const char * strtab
,
10792 unsigned long int strtab_size
,
10794 Elf_Internal_Sym
* psym
,
10795 enum versioned_symbol_info
* sym_info
,
10796 unsigned short * vna_other
)
10798 unsigned char data
[2];
10799 unsigned short vers_data
;
10800 unsigned long offset
;
10803 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10806 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10807 sizeof data
+ si
* sizeof (vers_data
));
10809 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10810 sizeof (data
), 1, _("version data")) == NULL
)
10813 vers_data
= byte_get (data
, 2);
10815 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10818 /* Usually we'd only see verdef for defined symbols, and verneed for
10819 undefined symbols. However, symbols defined by the linker in
10820 .dynbss for variables copied from a shared library in order to
10821 avoid text relocations are defined yet have verneed. We could
10822 use a heuristic to detect the special case, for example, check
10823 for verneed first on symbols defined in SHT_NOBITS sections, but
10824 it is simpler and more reliable to just look for both verdef and
10825 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10827 if (psym
->st_shndx
!= SHN_UNDEF
10828 && vers_data
!= 0x8001
10829 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10831 Elf_Internal_Verdef ivd
;
10832 Elf_Internal_Verdaux ivda
;
10833 Elf_External_Verdaux evda
;
10836 off
= offset_from_vma (file
,
10837 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10838 sizeof (Elf_External_Verdef
));
10842 Elf_External_Verdef evd
;
10844 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10845 _("version def")) == NULL
)
10853 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10854 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10855 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10858 off
+= ivd
.vd_next
;
10860 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10862 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10864 off
-= ivd
.vd_next
;
10867 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10868 _("version def aux")) != NULL
)
10870 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10872 if (psym
->st_name
!= ivda
.vda_name
)
10874 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10875 ? symbol_hidden
: symbol_public
);
10876 return (ivda
.vda_name
< strtab_size
10877 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10883 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10885 Elf_External_Verneed evn
;
10886 Elf_Internal_Verneed ivn
;
10887 Elf_Internal_Vernaux ivna
;
10889 offset
= offset_from_vma (file
,
10890 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10894 unsigned long vna_off
;
10896 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10897 _("version need")) == NULL
)
10900 ivna
.vna_other
= 0;
10905 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10906 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10908 vna_off
= offset
+ ivn
.vn_aux
;
10912 Elf_External_Vernaux evna
;
10914 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10915 _("version need aux (3)")) == NULL
)
10918 ivna
.vna_other
= 0;
10923 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10924 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10925 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10928 vna_off
+= ivna
.vna_next
;
10930 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10932 if (ivna
.vna_other
== vers_data
)
10935 offset
+= ivn
.vn_next
;
10937 while (ivn
.vn_next
!= 0);
10939 if (ivna
.vna_other
== vers_data
)
10941 *sym_info
= symbol_undefined
;
10942 *vna_other
= ivna
.vna_other
;
10943 return (ivna
.vna_name
< strtab_size
10944 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10950 /* Dump the symbol table. */
10952 process_symbol_table (FILE * file
)
10954 Elf_Internal_Shdr
* section
;
10955 bfd_size_type nbuckets
= 0;
10956 bfd_size_type nchains
= 0;
10957 bfd_vma
* buckets
= NULL
;
10958 bfd_vma
* chains
= NULL
;
10959 bfd_vma ngnubuckets
= 0;
10960 bfd_vma
* gnubuckets
= NULL
;
10961 bfd_vma
* gnuchains
= NULL
;
10962 bfd_vma gnusymidx
= 0;
10963 bfd_size_type ngnuchains
= 0;
10965 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10968 if (dynamic_info
[DT_HASH
]
10970 || (do_using_dynamic
10972 && dynamic_strings
!= NULL
)))
10974 unsigned char nb
[8];
10975 unsigned char nc
[8];
10976 unsigned int hash_ent_size
= 4;
10978 if ((elf_header
.e_machine
== EM_ALPHA
10979 || elf_header
.e_machine
== EM_S390
10980 || elf_header
.e_machine
== EM_S390_OLD
)
10981 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10985 (archive_file_offset
10986 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10987 sizeof nb
+ sizeof nc
)),
10990 error (_("Unable to seek to start of dynamic information\n"));
10994 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10996 error (_("Failed to read in number of buckets\n"));
11000 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11002 error (_("Failed to read in number of chains\n"));
11006 nbuckets
= byte_get (nb
, hash_ent_size
);
11007 nchains
= byte_get (nc
, hash_ent_size
);
11009 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11010 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11013 if (buckets
== NULL
|| chains
== NULL
)
11015 if (do_using_dynamic
)
11026 if (dynamic_info_DT_GNU_HASH
11028 || (do_using_dynamic
11030 && dynamic_strings
!= NULL
)))
11032 unsigned char nb
[16];
11033 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11034 bfd_vma buckets_vma
;
11037 (archive_file_offset
11038 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11042 error (_("Unable to seek to start of dynamic information\n"));
11046 if (fread (nb
, 16, 1, file
) != 1)
11048 error (_("Failed to read in number of buckets\n"));
11052 ngnubuckets
= byte_get (nb
, 4);
11053 gnusymidx
= byte_get (nb
+ 4, 4);
11054 bitmaskwords
= byte_get (nb
+ 8, 4);
11055 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11057 buckets_vma
+= bitmaskwords
* 4;
11059 buckets_vma
+= bitmaskwords
* 8;
11062 (archive_file_offset
11063 + offset_from_vma (file
, buckets_vma
, 4)),
11066 error (_("Unable to seek to start of dynamic information\n"));
11070 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11072 if (gnubuckets
== NULL
)
11075 for (i
= 0; i
< ngnubuckets
; i
++)
11076 if (gnubuckets
[i
] != 0)
11078 if (gnubuckets
[i
] < gnusymidx
)
11081 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11082 maxchain
= gnubuckets
[i
];
11085 if (maxchain
== 0xffffffff)
11088 maxchain
-= gnusymidx
;
11091 (archive_file_offset
11092 + offset_from_vma (file
, buckets_vma
11093 + 4 * (ngnubuckets
+ maxchain
), 4)),
11096 error (_("Unable to seek to start of dynamic information\n"));
11102 if (fread (nb
, 4, 1, file
) != 1)
11104 error (_("Failed to determine last chain length\n"));
11108 if (maxchain
+ 1 == 0)
11113 while ((byte_get (nb
, 4) & 1) == 0);
11116 (archive_file_offset
11117 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11120 error (_("Unable to seek to start of dynamic information\n"));
11124 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11125 ngnuchains
= maxchain
;
11128 if (gnuchains
== NULL
)
11133 if (do_using_dynamic
)
11138 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11140 && do_using_dynamic
11141 && dynamic_strings
!= NULL
11142 && dynamic_symbols
!= NULL
)
11146 if (dynamic_info
[DT_HASH
])
11150 printf (_("\nSymbol table for image:\n"));
11152 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11154 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11156 for (hn
= 0; hn
< nbuckets
; hn
++)
11161 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11162 print_dynamic_symbol (si
, hn
);
11166 if (dynamic_info_DT_GNU_HASH
)
11168 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11170 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11172 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11174 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11175 if (gnubuckets
[hn
] != 0)
11177 bfd_vma si
= gnubuckets
[hn
];
11178 bfd_vma off
= si
- gnusymidx
;
11182 print_dynamic_symbol (si
, hn
);
11185 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11189 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11190 && section_headers
!= NULL
)
11194 for (i
= 0, section
= section_headers
;
11195 i
< elf_header
.e_shnum
;
11199 char * strtab
= NULL
;
11200 unsigned long int strtab_size
= 0;
11201 Elf_Internal_Sym
* symtab
;
11202 Elf_Internal_Sym
* psym
;
11203 unsigned long num_syms
;
11205 if ((section
->sh_type
!= SHT_SYMTAB
11206 && section
->sh_type
!= SHT_DYNSYM
)
11208 && section
->sh_type
== SHT_SYMTAB
))
11211 if (section
->sh_entsize
== 0)
11213 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11214 printable_section_name (section
));
11218 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11219 printable_section_name (section
),
11220 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11223 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11225 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11227 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11228 if (symtab
== NULL
)
11231 if (section
->sh_link
== elf_header
.e_shstrndx
)
11233 strtab
= string_table
;
11234 strtab_size
= string_table_length
;
11236 else if (section
->sh_link
< elf_header
.e_shnum
)
11238 Elf_Internal_Shdr
* string_sec
;
11240 string_sec
= section_headers
+ section
->sh_link
;
11242 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11243 1, string_sec
->sh_size
,
11244 _("string table"));
11245 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11248 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11250 const char *version_string
;
11251 enum versioned_symbol_info sym_info
;
11252 unsigned short vna_other
;
11254 printf ("%6d: ", si
);
11255 print_vma (psym
->st_value
, LONG_HEX
);
11257 print_vma (psym
->st_size
, DEC_5
);
11258 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11259 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11260 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11261 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11264 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11266 printf (" %-7s", get_symbol_visibility (vis
));
11267 /* Check to see if any other bits in the st_other field are set.
11268 Note - displaying this information disrupts the layout of the
11269 table being generated, but for the moment this case is very rare. */
11270 if (psym
->st_other
^ vis
)
11271 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11273 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11274 print_symbol (25, psym
->st_name
< strtab_size
11275 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11278 = get_symbol_version_string (file
,
11279 section
->sh_type
== SHT_DYNSYM
,
11280 strtab
, strtab_size
, si
,
11281 psym
, &sym_info
, &vna_other
);
11282 if (version_string
)
11284 if (sym_info
== symbol_undefined
)
11285 printf ("@%s (%d)", version_string
, vna_other
);
11287 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11293 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11294 && si
>= section
->sh_info
11295 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11296 && elf_header
.e_machine
!= EM_MIPS
11297 /* Solaris binaries have been found to violate this requirement as
11298 well. Not sure if this is a bug or an ABI requirement. */
11299 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11300 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11301 si
, printable_section_name (section
), section
->sh_info
);
11305 if (strtab
!= string_table
)
11311 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11313 if (do_histogram
&& buckets
!= NULL
)
11315 unsigned long * lengths
;
11316 unsigned long * counts
;
11319 unsigned long maxlength
= 0;
11320 unsigned long nzero_counts
= 0;
11321 unsigned long nsyms
= 0;
11322 unsigned long chained
;
11324 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11325 (unsigned long) nbuckets
);
11327 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11328 if (lengths
== NULL
)
11330 error (_("Out of memory allocating space for histogram buckets\n"));
11334 printf (_(" Length Number %% of total Coverage\n"));
11335 for (hn
= 0; hn
< nbuckets
; ++hn
)
11337 for (si
= buckets
[hn
], chained
= 0;
11338 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11339 si
= chains
[si
], ++chained
)
11342 if (maxlength
< ++lengths
[hn
])
11346 /* PR binutils/17531: A corrupt binary could contain broken
11347 histogram data. Do not go into an infinite loop trying
11349 if (chained
> nchains
)
11351 error (_("histogram chain is corrupt\n"));
11356 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11357 if (counts
== NULL
)
11360 error (_("Out of memory allocating space for histogram counts\n"));
11364 for (hn
= 0; hn
< nbuckets
; ++hn
)
11365 ++counts
[lengths
[hn
]];
11370 printf (" 0 %-10lu (%5.1f%%)\n",
11371 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11372 for (i
= 1; i
<= maxlength
; ++i
)
11374 nzero_counts
+= counts
[i
] * i
;
11375 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11376 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11377 (nzero_counts
* 100.0) / nsyms
);
11385 if (buckets
!= NULL
)
11391 if (do_histogram
&& gnubuckets
!= NULL
)
11393 unsigned long * lengths
;
11394 unsigned long * counts
;
11396 unsigned long maxlength
= 0;
11397 unsigned long nzero_counts
= 0;
11398 unsigned long nsyms
= 0;
11400 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11401 (unsigned long) ngnubuckets
);
11403 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11404 if (lengths
== NULL
)
11406 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11410 printf (_(" Length Number %% of total Coverage\n"));
11412 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11413 if (gnubuckets
[hn
] != 0)
11415 bfd_vma off
, length
= 1;
11417 for (off
= gnubuckets
[hn
] - gnusymidx
;
11418 /* PR 17531 file: 010-77222-0.004. */
11419 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11422 lengths
[hn
] = length
;
11423 if (length
> maxlength
)
11424 maxlength
= length
;
11428 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11429 if (counts
== NULL
)
11432 error (_("Out of memory allocating space for gnu histogram counts\n"));
11436 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11437 ++counts
[lengths
[hn
]];
11439 if (ngnubuckets
> 0)
11442 printf (" 0 %-10lu (%5.1f%%)\n",
11443 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11444 for (j
= 1; j
<= maxlength
; ++j
)
11446 nzero_counts
+= counts
[j
] * j
;
11447 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11448 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11449 (nzero_counts
* 100.0) / nsyms
);
11463 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11467 if (dynamic_syminfo
== NULL
11469 /* No syminfo, this is ok. */
11472 /* There better should be a dynamic symbol section. */
11473 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11477 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11478 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11480 printf (_(" Num: Name BoundTo Flags\n"));
11481 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11483 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11485 printf ("%4d: ", i
);
11486 if (i
>= num_dynamic_syms
)
11487 printf (_("<corrupt index>"));
11488 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11489 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11491 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11494 switch (dynamic_syminfo
[i
].si_boundto
)
11496 case SYMINFO_BT_SELF
:
11497 fputs ("SELF ", stdout
);
11499 case SYMINFO_BT_PARENT
:
11500 fputs ("PARENT ", stdout
);
11503 if (dynamic_syminfo
[i
].si_boundto
> 0
11504 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11505 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11507 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11511 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11515 if (flags
& SYMINFO_FLG_DIRECT
)
11516 printf (" DIRECT");
11517 if (flags
& SYMINFO_FLG_PASSTHRU
)
11518 printf (" PASSTHRU");
11519 if (flags
& SYMINFO_FLG_COPY
)
11521 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11522 printf (" LAZYLOAD");
11530 /* Check to see if the given reloc needs to be handled in a target specific
11531 manner. If so then process the reloc and return TRUE otherwise return
11535 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11536 unsigned char * start
,
11537 Elf_Internal_Sym
* symtab
)
11539 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11541 switch (elf_header
.e_machine
)
11544 case EM_MSP430_OLD
:
11546 static Elf_Internal_Sym
* saved_sym
= NULL
;
11548 switch (reloc_type
)
11550 case 10: /* R_MSP430_SYM_DIFF */
11551 if (uses_msp430x_relocs ())
11553 /* Fall through. */
11554 case 21: /* R_MSP430X_SYM_DIFF */
11555 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11558 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11559 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11560 goto handle_sym_diff
;
11562 case 5: /* R_MSP430_16_BYTE */
11563 case 9: /* R_MSP430_8 */
11564 if (uses_msp430x_relocs ())
11566 goto handle_sym_diff
;
11568 case 2: /* R_MSP430_ABS16 */
11569 case 15: /* R_MSP430X_ABS16 */
11570 if (! uses_msp430x_relocs ())
11572 goto handle_sym_diff
;
11575 if (saved_sym
!= NULL
)
11579 value
= reloc
->r_addend
11580 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11581 - saved_sym
->st_value
);
11583 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11591 if (saved_sym
!= NULL
)
11592 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11599 case EM_CYGNUS_MN10300
:
11601 static Elf_Internal_Sym
* saved_sym
= NULL
;
11603 switch (reloc_type
)
11605 case 34: /* R_MN10300_ALIGN */
11607 case 33: /* R_MN10300_SYM_DIFF */
11608 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11610 case 1: /* R_MN10300_32 */
11611 case 2: /* R_MN10300_16 */
11612 if (saved_sym
!= NULL
)
11616 value
= reloc
->r_addend
11617 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11618 - saved_sym
->st_value
);
11620 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11627 if (saved_sym
!= NULL
)
11628 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11636 static bfd_vma saved_sym1
= 0;
11637 static bfd_vma saved_sym2
= 0;
11638 static bfd_vma value
;
11640 switch (reloc_type
)
11642 case 0x80: /* R_RL78_SYM. */
11643 saved_sym1
= saved_sym2
;
11644 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11645 saved_sym2
+= reloc
->r_addend
;
11648 case 0x83: /* R_RL78_OPsub. */
11649 value
= saved_sym1
- saved_sym2
;
11650 saved_sym2
= saved_sym1
= 0;
11654 case 0x41: /* R_RL78_ABS32. */
11655 byte_put (start
+ reloc
->r_offset
, value
, 4);
11659 case 0x43: /* R_RL78_ABS16. */
11660 byte_put (start
+ reloc
->r_offset
, value
, 2);
11674 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11675 DWARF debug sections. This is a target specific test. Note - we do not
11676 go through the whole including-target-headers-multiple-times route, (as
11677 we have already done with <elf/h8.h>) because this would become very
11678 messy and even then this function would have to contain target specific
11679 information (the names of the relocs instead of their numeric values).
11680 FIXME: This is not the correct way to solve this problem. The proper way
11681 is to have target specific reloc sizing and typing functions created by
11682 the reloc-macros.h header, in the same way that it already creates the
11683 reloc naming functions. */
11686 is_32bit_abs_reloc (unsigned int reloc_type
)
11688 /* Please keep this table alpha-sorted for ease of visual lookup. */
11689 switch (elf_header
.e_machine
)
11693 return reloc_type
== 1; /* R_386_32. */
11695 return reloc_type
== 1; /* R_68K_32. */
11697 return reloc_type
== 1; /* R_860_32. */
11699 return reloc_type
== 2; /* R_960_32. */
11701 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11702 case EM_ADAPTEVA_EPIPHANY
:
11703 return reloc_type
== 3;
11705 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11707 return reloc_type
== 1; /* R_ARC_32. */
11708 case EM_ARC_COMPACT
:
11709 case EM_ARC_COMPACT2
:
11710 return reloc_type
== 4; /* R_ARC_32. */
11712 return reloc_type
== 2; /* R_ARM_ABS32 */
11715 return reloc_type
== 1;
11717 return reloc_type
== 0x12; /* R_byte4_data. */
11719 return reloc_type
== 3; /* R_CRIS_32. */
11721 return reloc_type
== 3; /* R_CR16_NUM32. */
11723 return reloc_type
== 15; /* R_CRX_NUM32. */
11724 case EM_CYGNUS_FRV
:
11725 return reloc_type
== 1;
11726 case EM_CYGNUS_D10V
:
11728 return reloc_type
== 6; /* R_D10V_32. */
11729 case EM_CYGNUS_D30V
:
11731 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11733 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11734 case EM_CYGNUS_FR30
:
11736 return reloc_type
== 3; /* R_FR30_32. */
11738 return reloc_type
== 1; /* R_FT32_32. */
11742 return reloc_type
== 1; /* R_H8_DIR32. */
11744 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11745 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11748 return reloc_type
== 2; /* R_IP2K_32. */
11750 return reloc_type
== 2; /* R_IQ2000_32. */
11751 case EM_LATTICEMICO32
:
11752 return reloc_type
== 3; /* R_LM32_32. */
11755 return reloc_type
== 3; /* R_M32C_32. */
11757 return reloc_type
== 34; /* R_M32R_32_RELA. */
11760 return reloc_type
== 6; /* R_M68HC11_32. */
11762 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11763 case EM_CYGNUS_MEP
:
11764 return reloc_type
== 4; /* R_MEP_32. */
11766 return reloc_type
== 2; /* R_METAG_ADDR32. */
11767 case EM_MICROBLAZE
:
11768 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11770 return reloc_type
== 2; /* R_MIPS_32. */
11772 return reloc_type
== 4; /* R_MMIX_32. */
11773 case EM_CYGNUS_MN10200
:
11775 return reloc_type
== 1; /* R_MN10200_32. */
11776 case EM_CYGNUS_MN10300
:
11778 return reloc_type
== 1; /* R_MN10300_32. */
11780 return reloc_type
== 1; /* R_MOXIE_32. */
11781 case EM_MSP430_OLD
:
11783 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11785 return reloc_type
== 2; /* R_MT_32. */
11787 return reloc_type
== 20; /* R_NDS32_RELA. */
11788 case EM_ALTERA_NIOS2
:
11789 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11791 return reloc_type
== 1; /* R_NIOS_32. */
11793 return reloc_type
== 1; /* R_OR1K_32. */
11795 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11796 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11799 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11801 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11803 return reloc_type
== 1; /* R_PPC_ADDR32. */
11805 return reloc_type
== 1; /* R_RISCV_32. */
11807 return reloc_type
== 1; /* R_RL78_DIR32. */
11809 return reloc_type
== 1; /* R_RX_DIR32. */
11811 return reloc_type
== 1; /* R_I370_ADDR31. */
11814 return reloc_type
== 4; /* R_S390_32. */
11816 return reloc_type
== 8; /* R_SCORE_ABS32. */
11818 return reloc_type
== 1; /* R_SH_DIR32. */
11819 case EM_SPARC32PLUS
:
11822 return reloc_type
== 3 /* R_SPARC_32. */
11823 || reloc_type
== 23; /* R_SPARC_UA32. */
11825 return reloc_type
== 6; /* R_SPU_ADDR32 */
11827 return reloc_type
== 1; /* R_C6000_ABS32. */
11829 return reloc_type
== 2; /* R_TILEGX_32. */
11831 return reloc_type
== 1; /* R_TILEPRO_32. */
11832 case EM_CYGNUS_V850
:
11834 return reloc_type
== 6; /* R_V850_ABS32. */
11836 return reloc_type
== 0x33; /* R_V810_WORD. */
11838 return reloc_type
== 1; /* R_VAX_32. */
11840 return reloc_type
== 3; /* R_VISIUM_32. */
11844 return reloc_type
== 10; /* R_X86_64_32. */
11847 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11849 return reloc_type
== 4; /* R_XGATE_32. */
11851 return reloc_type
== 1; /* R_XSTROMY16_32. */
11852 case EM_XTENSA_OLD
:
11854 return reloc_type
== 1; /* R_XTENSA_32. */
11857 static unsigned int prev_warn
= 0;
11859 /* Avoid repeating the same warning multiple times. */
11860 if (prev_warn
!= elf_header
.e_machine
)
11861 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11862 elf_header
.e_machine
);
11863 prev_warn
= elf_header
.e_machine
;
11869 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11870 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11873 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11875 switch (elf_header
.e_machine
)
11876 /* Please keep this table alpha-sorted for ease of visual lookup. */
11880 return reloc_type
== 2; /* R_386_PC32. */
11882 return reloc_type
== 4; /* R_68K_PC32. */
11884 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11885 case EM_ADAPTEVA_EPIPHANY
:
11886 return reloc_type
== 6;
11888 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11889 case EM_ARC_COMPACT
:
11890 case EM_ARC_COMPACT2
:
11891 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11893 return reloc_type
== 3; /* R_ARM_REL32 */
11896 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11897 case EM_MICROBLAZE
:
11898 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11900 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11902 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11904 return reloc_type
== 26; /* R_PPC_REL32. */
11906 return reloc_type
== 26; /* R_PPC64_REL32. */
11909 return reloc_type
== 5; /* R_390_PC32. */
11911 return reloc_type
== 2; /* R_SH_REL32. */
11912 case EM_SPARC32PLUS
:
11915 return reloc_type
== 6; /* R_SPARC_DISP32. */
11917 return reloc_type
== 13; /* R_SPU_REL32. */
11919 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11921 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11923 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11927 return reloc_type
== 2; /* R_X86_64_PC32. */
11928 case EM_XTENSA_OLD
:
11930 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11932 /* Do not abort or issue an error message here. Not all targets use
11933 pc-relative 32-bit relocs in their DWARF debug information and we
11934 have already tested for target coverage in is_32bit_abs_reloc. A
11935 more helpful warning message will be generated by apply_relocations
11936 anyway, so just return. */
11941 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11942 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11945 is_64bit_abs_reloc (unsigned int reloc_type
)
11947 switch (elf_header
.e_machine
)
11950 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11952 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11954 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11956 return reloc_type
== 80; /* R_PARISC_DIR64. */
11958 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11960 return reloc_type
== 2; /* R_RISCV_64. */
11961 case EM_SPARC32PLUS
:
11964 return reloc_type
== 54; /* R_SPARC_UA64. */
11968 return reloc_type
== 1; /* R_X86_64_64. */
11971 return reloc_type
== 22; /* R_S390_64. */
11973 return reloc_type
== 1; /* R_TILEGX_64. */
11975 return reloc_type
== 18; /* R_MIPS_64. */
11981 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11982 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11985 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11987 switch (elf_header
.e_machine
)
11990 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11992 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11994 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11996 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11998 return reloc_type
== 44; /* R_PPC64_REL64. */
11999 case EM_SPARC32PLUS
:
12002 return reloc_type
== 46; /* R_SPARC_DISP64. */
12006 return reloc_type
== 24; /* R_X86_64_PC64. */
12009 return reloc_type
== 23; /* R_S390_PC64. */
12011 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12017 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12018 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12021 is_24bit_abs_reloc (unsigned int reloc_type
)
12023 switch (elf_header
.e_machine
)
12025 case EM_CYGNUS_MN10200
:
12027 return reloc_type
== 4; /* R_MN10200_24. */
12029 return reloc_type
== 5; /* R_FT32_20. */
12035 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12036 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12039 is_16bit_abs_reloc (unsigned int reloc_type
)
12041 /* Please keep this table alpha-sorted for ease of visual lookup. */
12042 switch (elf_header
.e_machine
)
12045 case EM_ARC_COMPACT
:
12046 case EM_ARC_COMPACT2
:
12047 return reloc_type
== 2; /* R_ARC_16. */
12048 case EM_ADAPTEVA_EPIPHANY
:
12049 return reloc_type
== 5;
12052 return reloc_type
== 4; /* R_AVR_16. */
12053 case EM_CYGNUS_D10V
:
12055 return reloc_type
== 3; /* R_D10V_16. */
12059 return reloc_type
== R_H8_DIR16
;
12062 return reloc_type
== 1; /* R_IP2K_16. */
12065 return reloc_type
== 1; /* R_M32C_16 */
12066 case EM_CYGNUS_MN10200
:
12068 return reloc_type
== 2; /* R_MN10200_16. */
12069 case EM_CYGNUS_MN10300
:
12071 return reloc_type
== 2; /* R_MN10300_16. */
12073 if (uses_msp430x_relocs ())
12074 return reloc_type
== 2; /* R_MSP430_ABS16. */
12075 /* Fall through. */
12076 case EM_MSP430_OLD
:
12077 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12079 return reloc_type
== 19; /* R_NDS32_RELA. */
12080 case EM_ALTERA_NIOS2
:
12081 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12083 return reloc_type
== 9; /* R_NIOS_16. */
12085 return reloc_type
== 2; /* R_OR1K_16. */
12087 return reloc_type
== 2; /* R_C6000_ABS16. */
12089 return reloc_type
== 2; /* R_VISIUM_16. */
12092 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12094 return reloc_type
== 3; /* R_XGATE_16. */
12100 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12101 relocation entries (possibly formerly used for SHT_GROUP sections). */
12104 is_none_reloc (unsigned int reloc_type
)
12106 switch (elf_header
.e_machine
)
12108 case EM_386
: /* R_386_NONE. */
12109 case EM_68K
: /* R_68K_NONE. */
12110 case EM_ADAPTEVA_EPIPHANY
:
12111 case EM_ALPHA
: /* R_ALPHA_NONE. */
12112 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12113 case EM_ARC
: /* R_ARC_NONE. */
12114 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12115 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12116 case EM_ARM
: /* R_ARM_NONE. */
12117 case EM_C166
: /* R_XC16X_NONE. */
12118 case EM_CRIS
: /* R_CRIS_NONE. */
12119 case EM_FT32
: /* R_FT32_NONE. */
12120 case EM_IA_64
: /* R_IA64_NONE. */
12121 case EM_K1OM
: /* R_X86_64_NONE. */
12122 case EM_L1OM
: /* R_X86_64_NONE. */
12123 case EM_M32R
: /* R_M32R_NONE. */
12124 case EM_MIPS
: /* R_MIPS_NONE. */
12125 case EM_MN10300
: /* R_MN10300_NONE. */
12126 case EM_MOXIE
: /* R_MOXIE_NONE. */
12127 case EM_NIOS32
: /* R_NIOS_NONE. */
12128 case EM_OR1K
: /* R_OR1K_NONE. */
12129 case EM_PARISC
: /* R_PARISC_NONE. */
12130 case EM_PPC64
: /* R_PPC64_NONE. */
12131 case EM_PPC
: /* R_PPC_NONE. */
12132 case EM_RISCV
: /* R_RISCV_NONE. */
12133 case EM_S390
: /* R_390_NONE. */
12135 case EM_SH
: /* R_SH_NONE. */
12136 case EM_SPARC32PLUS
:
12137 case EM_SPARC
: /* R_SPARC_NONE. */
12139 case EM_TILEGX
: /* R_TILEGX_NONE. */
12140 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12141 case EM_TI_C6000
:/* R_C6000_NONE. */
12142 case EM_X86_64
: /* R_X86_64_NONE. */
12144 return reloc_type
== 0;
12147 return reloc_type
== 0 || reloc_type
== 256;
12150 return (reloc_type
== 0 /* R_AVR_NONE. */
12151 || reloc_type
== 30 /* R_AVR_DIFF8. */
12152 || reloc_type
== 31 /* R_AVR_DIFF16. */
12153 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12155 return reloc_type
== 3; /* R_METAG_NONE. */
12157 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12158 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12159 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12160 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12161 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12162 case EM_XTENSA_OLD
:
12164 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12165 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12166 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12167 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12172 /* Returns TRUE if there is a relocation against
12173 section NAME at OFFSET bytes. */
12176 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12178 Elf_Internal_Rela
* relocs
;
12179 Elf_Internal_Rela
* rp
;
12181 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12184 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12186 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12187 if (rp
->r_offset
== offset
)
12193 /* Apply relocations to a section.
12194 Note: So far support has been added only for those relocations
12195 which can be found in debug sections.
12196 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12197 loaded relocs. It is then the caller's responsibility to free them.
12198 FIXME: Add support for more relocations ? */
12201 apply_relocations (void * file
,
12202 const Elf_Internal_Shdr
* section
,
12203 unsigned char * start
,
12204 bfd_size_type size
,
12205 void ** relocs_return
,
12206 unsigned long * num_relocs_return
)
12208 Elf_Internal_Shdr
* relsec
;
12209 unsigned char * end
= start
+ size
;
12211 if (relocs_return
!= NULL
)
12213 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12214 * num_relocs_return
= 0;
12217 if (elf_header
.e_type
!= ET_REL
)
12220 /* Find the reloc section associated with the section. */
12221 for (relsec
= section_headers
;
12222 relsec
< section_headers
+ elf_header
.e_shnum
;
12225 bfd_boolean is_rela
;
12226 unsigned long num_relocs
;
12227 Elf_Internal_Rela
* relocs
;
12228 Elf_Internal_Rela
* rp
;
12229 Elf_Internal_Shdr
* symsec
;
12230 Elf_Internal_Sym
* symtab
;
12231 unsigned long num_syms
;
12232 Elf_Internal_Sym
* sym
;
12234 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12235 || relsec
->sh_info
>= elf_header
.e_shnum
12236 || section_headers
+ relsec
->sh_info
!= section
12237 || relsec
->sh_size
== 0
12238 || relsec
->sh_link
>= elf_header
.e_shnum
)
12241 is_rela
= relsec
->sh_type
== SHT_RELA
;
12245 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12246 relsec
->sh_size
, & relocs
, & num_relocs
))
12251 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12252 relsec
->sh_size
, & relocs
, & num_relocs
))
12256 /* SH uses RELA but uses in place value instead of the addend field. */
12257 if (elf_header
.e_machine
== EM_SH
)
12260 symsec
= section_headers
+ relsec
->sh_link
;
12261 if (symsec
->sh_type
!= SHT_SYMTAB
12262 && symsec
->sh_type
!= SHT_DYNSYM
)
12264 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12266 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12269 unsigned int reloc_type
;
12270 unsigned int reloc_size
;
12271 unsigned char * rloc
;
12272 unsigned long sym_index
;
12274 reloc_type
= get_reloc_type (rp
->r_info
);
12276 if (target_specific_reloc_handling (rp
, start
, symtab
))
12278 else if (is_none_reloc (reloc_type
))
12280 else if (is_32bit_abs_reloc (reloc_type
)
12281 || is_32bit_pcrel_reloc (reloc_type
))
12283 else if (is_64bit_abs_reloc (reloc_type
)
12284 || is_64bit_pcrel_reloc (reloc_type
))
12286 else if (is_24bit_abs_reloc (reloc_type
))
12288 else if (is_16bit_abs_reloc (reloc_type
))
12292 static unsigned int prev_reloc
= 0;
12293 if (reloc_type
!= prev_reloc
)
12294 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12295 reloc_type
, printable_section_name (section
));
12296 prev_reloc
= reloc_type
;
12300 rloc
= start
+ rp
->r_offset
;
12301 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12303 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12304 (unsigned long) rp
->r_offset
,
12305 printable_section_name (section
));
12309 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12310 if (sym_index
>= num_syms
)
12312 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12313 sym_index
, printable_section_name (section
));
12316 sym
= symtab
+ sym_index
;
12318 /* If the reloc has a symbol associated with it,
12319 make sure that it is of an appropriate type.
12321 Relocations against symbols without type can happen.
12322 Gcc -feliminate-dwarf2-dups may generate symbols
12323 without type for debug info.
12325 Icc generates relocations against function symbols
12326 instead of local labels.
12328 Relocations against object symbols can happen, eg when
12329 referencing a global array. For an example of this see
12330 the _clz.o binary in libgcc.a. */
12332 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12333 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12335 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12336 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12337 (long int)(rp
- relocs
),
12338 printable_section_name (relsec
));
12344 addend
+= rp
->r_addend
;
12345 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12346 partial_inplace. */
12348 || (elf_header
.e_machine
== EM_XTENSA
12349 && reloc_type
== 1)
12350 || ((elf_header
.e_machine
== EM_PJ
12351 || elf_header
.e_machine
== EM_PJ_OLD
)
12352 && reloc_type
== 1)
12353 || ((elf_header
.e_machine
== EM_D30V
12354 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12355 && reloc_type
== 12))
12356 addend
+= byte_get (rloc
, reloc_size
);
12358 if (is_32bit_pcrel_reloc (reloc_type
)
12359 || is_64bit_pcrel_reloc (reloc_type
))
12361 /* On HPPA, all pc-relative relocations are biased by 8. */
12362 if (elf_header
.e_machine
== EM_PARISC
)
12364 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12368 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12375 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12376 * num_relocs_return
= num_relocs
;
12385 #ifdef SUPPORT_DISASSEMBLY
12387 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12389 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12391 /* FIXME: XXX -- to be done --- XXX */
12397 /* Reads in the contents of SECTION from FILE, returning a pointer
12398 to a malloc'ed buffer or NULL if something went wrong. */
12401 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12403 bfd_size_type num_bytes
;
12405 num_bytes
= section
->sh_size
;
12407 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12409 printf (_("\nSection '%s' has no data to dump.\n"),
12410 printable_section_name (section
));
12414 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12415 _("section contents"));
12418 /* Uncompresses a section that was compressed using zlib, in place. */
12421 uncompress_section_contents (unsigned char **buffer
,
12422 dwarf_size_type uncompressed_size
,
12423 dwarf_size_type
*size
)
12425 dwarf_size_type compressed_size
= *size
;
12426 unsigned char * compressed_buffer
= *buffer
;
12427 unsigned char * uncompressed_buffer
;
12431 /* It is possible the section consists of several compressed
12432 buffers concatenated together, so we uncompress in a loop. */
12433 /* PR 18313: The state field in the z_stream structure is supposed
12434 to be invisible to the user (ie us), but some compilers will
12435 still complain about it being used without initialisation. So
12436 we first zero the entire z_stream structure and then set the fields
12438 memset (& strm
, 0, sizeof strm
);
12439 strm
.avail_in
= compressed_size
;
12440 strm
.next_in
= (Bytef
*) compressed_buffer
;
12441 strm
.avail_out
= uncompressed_size
;
12442 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12444 rc
= inflateInit (& strm
);
12445 while (strm
.avail_in
> 0)
12449 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12450 + (uncompressed_size
- strm
.avail_out
));
12451 rc
= inflate (&strm
, Z_FINISH
);
12452 if (rc
!= Z_STREAM_END
)
12454 rc
= inflateReset (& strm
);
12456 rc
= inflateEnd (& strm
);
12458 || strm
.avail_out
!= 0)
12461 *buffer
= uncompressed_buffer
;
12462 *size
= uncompressed_size
;
12466 free (uncompressed_buffer
);
12467 /* Indicate decompression failure. */
12473 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12475 Elf_Internal_Shdr
* relsec
;
12476 bfd_size_type num_bytes
;
12477 unsigned char * data
;
12478 unsigned char * end
;
12479 unsigned char * real_start
;
12480 unsigned char * start
;
12481 bfd_boolean some_strings_shown
;
12483 real_start
= start
= (unsigned char *) get_section_contents (section
,
12487 num_bytes
= section
->sh_size
;
12489 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12491 if (decompress_dumps
)
12493 dwarf_size_type new_size
= num_bytes
;
12494 dwarf_size_type uncompressed_size
= 0;
12496 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12498 Elf_Internal_Chdr chdr
;
12499 unsigned int compression_header_size
12500 = get_compression_header (& chdr
, (unsigned char *) start
);
12502 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12504 warn (_("section '%s' has unsupported compress type: %d\n"),
12505 printable_section_name (section
), chdr
.ch_type
);
12508 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12510 warn (_("compressed section '%s' is corrupted\n"),
12511 printable_section_name (section
));
12514 uncompressed_size
= chdr
.ch_size
;
12515 start
+= compression_header_size
;
12516 new_size
-= compression_header_size
;
12518 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12520 /* Read the zlib header. In this case, it should be "ZLIB"
12521 followed by the uncompressed section size, 8 bytes in
12522 big-endian order. */
12523 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12524 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12525 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12526 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12527 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12528 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12529 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12530 uncompressed_size
+= start
[11];
12535 if (uncompressed_size
12536 && uncompress_section_contents (& start
,
12537 uncompressed_size
, & new_size
))
12538 num_bytes
= new_size
;
12541 /* If the section being dumped has relocations against it the user might
12542 be expecting these relocations to have been applied. Check for this
12543 case and issue a warning message in order to avoid confusion.
12544 FIXME: Maybe we ought to have an option that dumps a section with
12545 relocs applied ? */
12546 for (relsec
= section_headers
;
12547 relsec
< section_headers
+ elf_header
.e_shnum
;
12550 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12551 || relsec
->sh_info
>= elf_header
.e_shnum
12552 || section_headers
+ relsec
->sh_info
!= section
12553 || relsec
->sh_size
== 0
12554 || relsec
->sh_link
>= elf_header
.e_shnum
)
12557 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12562 end
= start
+ num_bytes
;
12563 some_strings_shown
= FALSE
;
12567 while (!ISPRINT (* data
))
12568 if (++ data
>= end
)
12573 size_t maxlen
= end
- data
;
12576 /* PR 11128: Use two separate invocations in order to work
12577 around bugs in the Solaris 8 implementation of printf. */
12578 printf (" [%6tx] ", data
- start
);
12580 printf (" [%6Ix] ", (size_t) (data
- start
));
12584 print_symbol ((int) maxlen
, (const char *) data
);
12586 data
+= strnlen ((const char *) data
, maxlen
);
12590 printf (_("<corrupt>\n"));
12593 some_strings_shown
= TRUE
;
12597 if (! some_strings_shown
)
12598 printf (_(" No strings found in this section."));
12606 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12608 bfd_boolean relocate
)
12610 Elf_Internal_Shdr
* relsec
;
12611 bfd_size_type bytes
;
12612 bfd_size_type section_size
;
12614 unsigned char * data
;
12615 unsigned char * real_start
;
12616 unsigned char * start
;
12618 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12621 section_size
= section
->sh_size
;
12623 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12625 if (decompress_dumps
)
12627 dwarf_size_type new_size
= section_size
;
12628 dwarf_size_type uncompressed_size
= 0;
12630 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12632 Elf_Internal_Chdr chdr
;
12633 unsigned int compression_header_size
12634 = get_compression_header (& chdr
, start
);
12636 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12638 warn (_("section '%s' has unsupported compress type: %d\n"),
12639 printable_section_name (section
), chdr
.ch_type
);
12642 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12644 warn (_("compressed section '%s' is corrupted\n"),
12645 printable_section_name (section
));
12648 uncompressed_size
= chdr
.ch_size
;
12649 start
+= compression_header_size
;
12650 new_size
-= compression_header_size
;
12652 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12654 /* Read the zlib header. In this case, it should be "ZLIB"
12655 followed by the uncompressed section size, 8 bytes in
12656 big-endian order. */
12657 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12658 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12659 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12660 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12661 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12662 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12663 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12664 uncompressed_size
+= start
[11];
12669 if (uncompressed_size
12670 && uncompress_section_contents (& start
, uncompressed_size
,
12672 section_size
= new_size
;
12677 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12681 /* If the section being dumped has relocations against it the user might
12682 be expecting these relocations to have been applied. Check for this
12683 case and issue a warning message in order to avoid confusion.
12684 FIXME: Maybe we ought to have an option that dumps a section with
12685 relocs applied ? */
12686 for (relsec
= section_headers
;
12687 relsec
< section_headers
+ elf_header
.e_shnum
;
12690 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12691 || relsec
->sh_info
>= elf_header
.e_shnum
12692 || section_headers
+ relsec
->sh_info
!= section
12693 || relsec
->sh_size
== 0
12694 || relsec
->sh_link
>= elf_header
.e_shnum
)
12697 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12702 addr
= section
->sh_addr
;
12703 bytes
= section_size
;
12712 lbytes
= (bytes
> 16 ? 16 : bytes
);
12714 printf (" 0x%8.8lx ", (unsigned long) addr
);
12716 for (j
= 0; j
< 16; j
++)
12719 printf ("%2.2x", data
[j
]);
12727 for (j
= 0; j
< lbytes
; j
++)
12730 if (k
>= ' ' && k
< 0x7f)
12749 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12750 const Elf_Internal_Shdr
* sec
, void * file
)
12752 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12755 /* If it is already loaded, do nothing. */
12756 if (section
->start
!= NULL
)
12759 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12760 section
->address
= sec
->sh_addr
;
12761 section
->user_data
= NULL
;
12762 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12764 sec
->sh_size
, buf
);
12765 if (section
->start
== NULL
)
12769 unsigned char *start
= section
->start
;
12770 dwarf_size_type size
= sec
->sh_size
;
12771 dwarf_size_type uncompressed_size
= 0;
12773 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12775 Elf_Internal_Chdr chdr
;
12776 unsigned int compression_header_size
;
12778 if (size
< (is_32bit_elf
12779 ? sizeof (Elf32_External_Chdr
)
12780 : sizeof (Elf64_External_Chdr
)))
12782 warn (_("compressed section %s is too small to contain a compression header"),
12787 compression_header_size
= get_compression_header (&chdr
, start
);
12789 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12791 warn (_("section '%s' has unsupported compress type: %d\n"),
12792 section
->name
, chdr
.ch_type
);
12795 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12797 warn (_("compressed section '%s' is corrupted\n"),
12801 uncompressed_size
= chdr
.ch_size
;
12802 start
+= compression_header_size
;
12803 size
-= compression_header_size
;
12805 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12807 /* Read the zlib header. In this case, it should be "ZLIB"
12808 followed by the uncompressed section size, 8 bytes in
12809 big-endian order. */
12810 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12811 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12812 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12813 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12814 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12815 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12816 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12817 uncompressed_size
+= start
[11];
12822 if (uncompressed_size
12823 && uncompress_section_contents (&start
, uncompressed_size
,
12826 /* Free the compressed buffer, update the section buffer
12827 and the section size if uncompress is successful. */
12828 free (section
->start
);
12829 section
->start
= start
;
12831 section
->size
= size
;
12834 if (section
->start
== NULL
)
12837 if (debug_displays
[debug
].relocate
)
12838 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12839 & section
->reloc_info
, & section
->num_relocs
);
12842 section
->reloc_info
= NULL
;
12843 section
->num_relocs
= 0;
12849 /* If this is not NULL, load_debug_section will only look for sections
12850 within the list of sections given here. */
12851 unsigned int *section_subset
= NULL
;
12854 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12856 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12857 Elf_Internal_Shdr
* sec
;
12859 /* Locate the debug section. */
12860 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12862 section
->name
= section
->uncompressed_name
;
12865 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12867 section
->name
= section
->compressed_name
;
12872 /* If we're loading from a subset of sections, and we've loaded
12873 a section matching this name before, it's likely that it's a
12875 if (section_subset
!= NULL
)
12876 free_debug_section (debug
);
12878 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12882 free_debug_section (enum dwarf_section_display_enum debug
)
12884 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12886 if (section
->start
== NULL
)
12889 free ((char *) section
->start
);
12890 section
->start
= NULL
;
12891 section
->address
= 0;
12896 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12898 char * name
= SECTION_NAME (section
);
12899 const char * print_name
= printable_section_name (section
);
12900 bfd_size_type length
;
12904 length
= section
->sh_size
;
12907 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12910 if (section
->sh_type
== SHT_NOBITS
)
12912 /* There is no point in dumping the contents of a debugging section
12913 which has the NOBITS type - the bits in the file will be random.
12914 This can happen when a file containing a .eh_frame section is
12915 stripped with the --only-keep-debug command line option. */
12916 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12921 if (const_strneq (name
, ".gnu.linkonce.wi."))
12922 name
= ".debug_info";
12924 /* See if we know how to display the contents of this section. */
12925 for (i
= 0; i
< max
; i
++)
12926 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12927 || (i
== line
&& const_strneq (name
, ".debug_line."))
12928 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12930 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12931 int secondary
= (section
!= find_section (name
));
12934 free_debug_section ((enum dwarf_section_display_enum
) i
);
12936 if (i
== line
&& const_strneq (name
, ".debug_line."))
12938 else if (streq (sec
->uncompressed_name
, name
))
12939 sec
->name
= sec
->uncompressed_name
;
12941 sec
->name
= sec
->compressed_name
;
12942 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12945 /* If this debug section is part of a CU/TU set in a .dwp file,
12946 restrict load_debug_section to the sections in that set. */
12947 section_subset
= find_cu_tu_set (file
, shndx
);
12949 result
&= debug_displays
[i
].display (sec
, file
);
12951 section_subset
= NULL
;
12953 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12954 free_debug_section ((enum dwarf_section_display_enum
) i
);
12962 printf (_("Unrecognized debug section: %s\n"), print_name
);
12969 /* Set DUMP_SECTS for all sections where dumps were requested
12970 based on section name. */
12973 initialise_dumps_byname (void)
12975 struct dump_list_entry
* cur
;
12977 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12982 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12983 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12985 request_dump_bynumber (i
, cur
->type
);
12990 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12996 process_section_contents (FILE * file
)
12998 Elf_Internal_Shdr
* section
;
13004 initialise_dumps_byname ();
13006 for (i
= 0, section
= section_headers
;
13007 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13010 #ifdef SUPPORT_DISASSEMBLY
13011 if (dump_sects
[i
] & DISASS_DUMP
)
13012 disassemble_section (section
, file
);
13014 if (dump_sects
[i
] & HEX_DUMP
)
13015 dump_section_as_bytes (section
, file
, FALSE
);
13017 if (dump_sects
[i
] & RELOC_DUMP
)
13018 dump_section_as_bytes (section
, file
, TRUE
);
13020 if (dump_sects
[i
] & STRING_DUMP
)
13021 dump_section_as_strings (section
, file
);
13023 if (dump_sects
[i
] & DEBUG_DUMP
)
13024 display_debug_section (i
, section
, file
);
13027 /* Check to see if the user requested a
13028 dump of a section that does not exist. */
13029 while (i
++ < num_dump_sects
)
13031 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13035 process_mips_fpe_exception (int mask
)
13040 if (mask
& OEX_FPU_INEX
)
13041 fputs ("INEX", stdout
), first
= 0;
13042 if (mask
& OEX_FPU_UFLO
)
13043 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13044 if (mask
& OEX_FPU_OFLO
)
13045 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13046 if (mask
& OEX_FPU_DIV0
)
13047 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13048 if (mask
& OEX_FPU_INVAL
)
13049 printf ("%sINVAL", first
? "" : "|");
13052 fputs ("0", stdout
);
13055 /* Display's the value of TAG at location P. If TAG is
13056 greater than 0 it is assumed to be an unknown tag, and
13057 a message is printed to this effect. Otherwise it is
13058 assumed that a message has already been printed.
13060 If the bottom bit of TAG is set it assumed to have a
13061 string value, otherwise it is assumed to have an integer
13064 Returns an updated P pointing to the first unread byte
13065 beyond the end of TAG's value.
13067 Reads at or beyond END will not be made. */
13069 static unsigned char *
13070 display_tag_value (int tag
,
13072 const unsigned char * const end
)
13077 printf (" Tag_unknown_%d: ", tag
);
13081 warn (_("<corrupt tag>\n"));
13085 /* PR 17531 file: 027-19978-0.004. */
13086 size_t maxlen
= (end
- p
) - 1;
13091 print_symbol ((int) maxlen
, (const char *) p
);
13092 p
+= strnlen ((char *) p
, maxlen
) + 1;
13096 printf (_("<corrupt string tag>"));
13097 p
= (unsigned char *) end
;
13105 val
= read_uleb128 (p
, &len
, end
);
13107 printf ("%ld (0x%lx)\n", val
, val
);
13114 /* ARM EABI attributes section. */
13119 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13121 const char ** table
;
13122 } arm_attr_public_tag
;
13124 static const char * arm_attr_tag_CPU_arch
[] =
13125 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13126 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13128 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13129 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13130 {"No", "Thumb-1", "Thumb-2", "Yes"};
13131 static const char * arm_attr_tag_FP_arch
[] =
13132 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13133 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13134 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13135 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13136 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13137 "NEON for ARMv8.1"};
13138 static const char * arm_attr_tag_PCS_config
[] =
13139 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13140 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13141 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13142 {"V6", "SB", "TLS", "Unused"};
13143 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13144 {"Absolute", "PC-relative", "SB-relative", "None"};
13145 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13146 {"Absolute", "PC-relative", "None"};
13147 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13148 {"None", "direct", "GOT-indirect"};
13149 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13150 {"None", "??? 1", "2", "??? 3", "4"};
13151 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13152 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13153 {"Unused", "Needed", "Sign only"};
13154 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13155 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13156 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13157 {"Unused", "Finite", "RTABI", "IEEE 754"};
13158 static const char * arm_attr_tag_ABI_enum_size
[] =
13159 {"Unused", "small", "int", "forced to int"};
13160 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13161 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13162 static const char * arm_attr_tag_ABI_VFP_args
[] =
13163 {"AAPCS", "VFP registers", "custom", "compatible"};
13164 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13165 {"AAPCS", "WMMX registers", "custom"};
13166 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13167 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13168 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13169 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13170 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13171 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13172 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13173 static const char * arm_attr_tag_FP_HP_extension
[] =
13174 {"Not Allowed", "Allowed"};
13175 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13176 {"None", "IEEE 754", "Alternative Format"};
13177 static const char * arm_attr_tag_DSP_extension
[] =
13178 {"Follow architecture", "Allowed"};
13179 static const char * arm_attr_tag_MPextension_use
[] =
13180 {"Not Allowed", "Allowed"};
13181 static const char * arm_attr_tag_DIV_use
[] =
13182 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13183 "Allowed in v7-A with integer division extension"};
13184 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13185 static const char * arm_attr_tag_Virtualization_use
[] =
13186 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13187 "TrustZone and Virtualization Extensions"};
13188 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13189 {"Not Allowed", "Allowed"};
13191 #define LOOKUP(id, name) \
13192 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13193 static arm_attr_public_tag arm_attr_public_tags
[] =
13195 {4, "CPU_raw_name", 1, NULL
},
13196 {5, "CPU_name", 1, NULL
},
13197 LOOKUP(6, CPU_arch
),
13198 {7, "CPU_arch_profile", 0, NULL
},
13199 LOOKUP(8, ARM_ISA_use
),
13200 LOOKUP(9, THUMB_ISA_use
),
13201 LOOKUP(10, FP_arch
),
13202 LOOKUP(11, WMMX_arch
),
13203 LOOKUP(12, Advanced_SIMD_arch
),
13204 LOOKUP(13, PCS_config
),
13205 LOOKUP(14, ABI_PCS_R9_use
),
13206 LOOKUP(15, ABI_PCS_RW_data
),
13207 LOOKUP(16, ABI_PCS_RO_data
),
13208 LOOKUP(17, ABI_PCS_GOT_use
),
13209 LOOKUP(18, ABI_PCS_wchar_t
),
13210 LOOKUP(19, ABI_FP_rounding
),
13211 LOOKUP(20, ABI_FP_denormal
),
13212 LOOKUP(21, ABI_FP_exceptions
),
13213 LOOKUP(22, ABI_FP_user_exceptions
),
13214 LOOKUP(23, ABI_FP_number_model
),
13215 {24, "ABI_align_needed", 0, NULL
},
13216 {25, "ABI_align_preserved", 0, NULL
},
13217 LOOKUP(26, ABI_enum_size
),
13218 LOOKUP(27, ABI_HardFP_use
),
13219 LOOKUP(28, ABI_VFP_args
),
13220 LOOKUP(29, ABI_WMMX_args
),
13221 LOOKUP(30, ABI_optimization_goals
),
13222 LOOKUP(31, ABI_FP_optimization_goals
),
13223 {32, "compatibility", 0, NULL
},
13224 LOOKUP(34, CPU_unaligned_access
),
13225 LOOKUP(36, FP_HP_extension
),
13226 LOOKUP(38, ABI_FP_16bit_format
),
13227 LOOKUP(42, MPextension_use
),
13228 LOOKUP(44, DIV_use
),
13229 LOOKUP(46, DSP_extension
),
13230 {64, "nodefaults", 0, NULL
},
13231 {65, "also_compatible_with", 0, NULL
},
13232 LOOKUP(66, T2EE_use
),
13233 {67, "conformance", 1, NULL
},
13234 LOOKUP(68, Virtualization_use
),
13235 LOOKUP(70, MPextension_use_legacy
)
13239 static unsigned char *
13240 display_arm_attribute (unsigned char * p
,
13241 const unsigned char * const end
)
13246 arm_attr_public_tag
* attr
;
13250 tag
= read_uleb128 (p
, &len
, end
);
13253 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13255 if (arm_attr_public_tags
[i
].tag
== tag
)
13257 attr
= &arm_attr_public_tags
[i
];
13264 printf (" Tag_%s: ", attr
->name
);
13265 switch (attr
->type
)
13270 case 7: /* Tag_CPU_arch_profile. */
13271 val
= read_uleb128 (p
, &len
, end
);
13275 case 0: printf (_("None\n")); break;
13276 case 'A': printf (_("Application\n")); break;
13277 case 'R': printf (_("Realtime\n")); break;
13278 case 'M': printf (_("Microcontroller\n")); break;
13279 case 'S': printf (_("Application or Realtime\n")); break;
13280 default: printf ("??? (%d)\n", val
); break;
13284 case 24: /* Tag_align_needed. */
13285 val
= read_uleb128 (p
, &len
, end
);
13289 case 0: printf (_("None\n")); break;
13290 case 1: printf (_("8-byte\n")); break;
13291 case 2: printf (_("4-byte\n")); break;
13292 case 3: printf ("??? 3\n"); break;
13295 printf (_("8-byte and up to %d-byte extended\n"),
13298 printf ("??? (%d)\n", val
);
13303 case 25: /* Tag_align_preserved. */
13304 val
= read_uleb128 (p
, &len
, end
);
13308 case 0: printf (_("None\n")); break;
13309 case 1: printf (_("8-byte, except leaf SP\n")); break;
13310 case 2: printf (_("8-byte\n")); break;
13311 case 3: printf ("??? 3\n"); break;
13314 printf (_("8-byte and up to %d-byte extended\n"),
13317 printf ("??? (%d)\n", val
);
13322 case 32: /* Tag_compatibility. */
13324 val
= read_uleb128 (p
, &len
, end
);
13326 printf (_("flag = %d, vendor = "), val
);
13329 size_t maxlen
= (end
- p
) - 1;
13331 print_symbol ((int) maxlen
, (const char *) p
);
13332 p
+= strnlen ((char *) p
, maxlen
) + 1;
13336 printf (_("<corrupt>"));
13337 p
= (unsigned char *) end
;
13343 case 64: /* Tag_nodefaults. */
13344 /* PR 17531: file: 001-505008-0.01. */
13347 printf (_("True\n"));
13350 case 65: /* Tag_also_compatible_with. */
13351 val
= read_uleb128 (p
, &len
, end
);
13353 if (val
== 6 /* Tag_CPU_arch. */)
13355 val
= read_uleb128 (p
, &len
, end
);
13357 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13358 printf ("??? (%d)\n", val
);
13360 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13364 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13369 printf (_("<unknown: %d>\n"), tag
);
13375 return display_tag_value (-1, p
, end
);
13377 return display_tag_value (0, p
, end
);
13380 assert (attr
->type
& 0x80);
13381 val
= read_uleb128 (p
, &len
, end
);
13383 type
= attr
->type
& 0x7f;
13385 printf ("??? (%d)\n", val
);
13387 printf ("%s\n", attr
->table
[val
]);
13392 return display_tag_value (tag
, p
, end
);
13395 static unsigned char *
13396 display_gnu_attribute (unsigned char * p
,
13397 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13398 const unsigned char * const end
)
13404 tag
= read_uleb128 (p
, &len
, end
);
13407 /* Tag_compatibility is the only generic GNU attribute defined at
13411 val
= read_uleb128 (p
, &len
, end
);
13414 printf (_("flag = %d, vendor = "), val
);
13417 printf (_("<corrupt>\n"));
13418 warn (_("corrupt vendor attribute\n"));
13424 size_t maxlen
= (end
- p
) - 1;
13426 print_symbol ((int) maxlen
, (const char *) p
);
13427 p
+= strnlen ((char *) p
, maxlen
) + 1;
13431 printf (_("<corrupt>"));
13432 p
= (unsigned char *) end
;
13439 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13440 return display_proc_gnu_attribute (p
, tag
, end
);
13442 return display_tag_value (tag
, p
, end
);
13445 static unsigned char *
13446 display_power_gnu_attribute (unsigned char * p
,
13448 const unsigned char * const end
)
13453 if (tag
== Tag_GNU_Power_ABI_FP
)
13455 val
= read_uleb128 (p
, &len
, end
);
13457 printf (" Tag_GNU_Power_ABI_FP: ");
13460 printf (_("<corrupt>\n"));
13465 printf ("(%#x), ", val
);
13470 printf (_("unspecified hard/soft float, "));
13473 printf (_("hard float, "));
13476 printf (_("soft float, "));
13479 printf (_("single-precision hard float, "));
13486 printf (_("unspecified long double\n"));
13489 printf (_("128-bit IBM long double\n"));
13492 printf (_("64-bit long double\n"));
13495 printf (_("128-bit IEEE long double\n"));
13501 if (tag
== Tag_GNU_Power_ABI_Vector
)
13503 val
= read_uleb128 (p
, &len
, end
);
13505 printf (" Tag_GNU_Power_ABI_Vector: ");
13508 printf (_("<corrupt>\n"));
13513 printf ("(%#x), ", val
);
13518 printf (_("unspecified\n"));
13521 printf (_("generic\n"));
13524 printf ("AltiVec\n");
13533 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13535 val
= read_uleb128 (p
, &len
, end
);
13537 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13540 printf (_("<corrupt>\n"));
13545 printf ("(%#x), ", val
);
13550 printf (_("unspecified\n"));
13553 printf ("r3/r4\n");
13556 printf (_("memory\n"));
13565 return display_tag_value (tag
& 1, p
, end
);
13568 static unsigned char *
13569 display_s390_gnu_attribute (unsigned char * p
,
13571 const unsigned char * const end
)
13576 if (tag
== Tag_GNU_S390_ABI_Vector
)
13578 val
= read_uleb128 (p
, &len
, end
);
13580 printf (" Tag_GNU_S390_ABI_Vector: ");
13585 printf (_("any\n"));
13588 printf (_("software\n"));
13591 printf (_("hardware\n"));
13594 printf ("??? (%d)\n", val
);
13600 return display_tag_value (tag
& 1, p
, end
);
13604 display_sparc_hwcaps (int mask
)
13610 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13611 fputs ("mul32", stdout
), first
= 0;
13612 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13613 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13614 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13615 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13616 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13617 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13618 if (mask
& ELF_SPARC_HWCAP_POPC
)
13619 printf ("%spopc", first
? "" : "|"), first
= 0;
13620 if (mask
& ELF_SPARC_HWCAP_VIS
)
13621 printf ("%svis", first
? "" : "|"), first
= 0;
13622 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13623 printf ("%svis2", first
? "" : "|"), first
= 0;
13624 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13625 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13626 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13627 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13628 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13629 printf ("%svis3", first
? "" : "|"), first
= 0;
13630 if (mask
& ELF_SPARC_HWCAP_HPC
)
13631 printf ("%shpc", first
? "" : "|"), first
= 0;
13632 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13633 printf ("%srandom", first
? "" : "|"), first
= 0;
13634 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13635 printf ("%strans", first
? "" : "|"), first
= 0;
13636 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13637 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13638 if (mask
& ELF_SPARC_HWCAP_IMA
)
13639 printf ("%sima", first
? "" : "|"), first
= 0;
13640 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13641 printf ("%scspare", first
? "" : "|"), first
= 0;
13644 fputc ('0', stdout
);
13645 fputc ('\n', stdout
);
13649 display_sparc_hwcaps2 (int mask
)
13655 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13656 fputs ("fjathplus", stdout
), first
= 0;
13657 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13658 printf ("%svis3b", first
? "" : "|"), first
= 0;
13659 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13660 printf ("%sadp", first
? "" : "|"), first
= 0;
13661 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13662 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13663 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13664 printf ("%smwait", first
? "" : "|"), first
= 0;
13665 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13666 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13667 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13668 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13669 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13670 printf ("%snsec", first
? "" : "|"), first
= 0;
13671 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13672 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13673 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13674 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13675 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13676 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13679 fputc ('0', stdout
);
13680 fputc ('\n', stdout
);
13683 static unsigned char *
13684 display_sparc_gnu_attribute (unsigned char * p
,
13686 const unsigned char * const end
)
13691 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13693 val
= read_uleb128 (p
, &len
, end
);
13695 printf (" Tag_GNU_Sparc_HWCAPS: ");
13696 display_sparc_hwcaps (val
);
13699 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13701 val
= read_uleb128 (p
, &len
, end
);
13703 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13704 display_sparc_hwcaps2 (val
);
13708 return display_tag_value (tag
, p
, end
);
13712 print_mips_fp_abi_value (int val
)
13716 case Val_GNU_MIPS_ABI_FP_ANY
:
13717 printf (_("Hard or soft float\n"));
13719 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13720 printf (_("Hard float (double precision)\n"));
13722 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13723 printf (_("Hard float (single precision)\n"));
13725 case Val_GNU_MIPS_ABI_FP_SOFT
:
13726 printf (_("Soft float\n"));
13728 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13729 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13731 case Val_GNU_MIPS_ABI_FP_XX
:
13732 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13734 case Val_GNU_MIPS_ABI_FP_64
:
13735 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13737 case Val_GNU_MIPS_ABI_FP_64A
:
13738 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13740 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13741 printf (_("NaN 2008 compatibility\n"));
13744 printf ("??? (%d)\n", val
);
13749 static unsigned char *
13750 display_mips_gnu_attribute (unsigned char * p
,
13752 const unsigned char * const end
)
13754 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13759 val
= read_uleb128 (p
, &len
, end
);
13761 printf (" Tag_GNU_MIPS_ABI_FP: ");
13763 print_mips_fp_abi_value (val
);
13768 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13773 val
= read_uleb128 (p
, &len
, end
);
13775 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13779 case Val_GNU_MIPS_ABI_MSA_ANY
:
13780 printf (_("Any MSA or not\n"));
13782 case Val_GNU_MIPS_ABI_MSA_128
:
13783 printf (_("128-bit MSA\n"));
13786 printf ("??? (%d)\n", val
);
13792 return display_tag_value (tag
& 1, p
, end
);
13795 static unsigned char *
13796 display_tic6x_attribute (unsigned char * p
,
13797 const unsigned char * const end
)
13803 tag
= read_uleb128 (p
, &len
, end
);
13809 val
= read_uleb128 (p
, &len
, end
);
13811 printf (" Tag_ISA: ");
13815 case C6XABI_Tag_ISA_none
:
13816 printf (_("None\n"));
13818 case C6XABI_Tag_ISA_C62X
:
13821 case C6XABI_Tag_ISA_C67X
:
13824 case C6XABI_Tag_ISA_C67XP
:
13825 printf ("C67x+\n");
13827 case C6XABI_Tag_ISA_C64X
:
13830 case C6XABI_Tag_ISA_C64XP
:
13831 printf ("C64x+\n");
13833 case C6XABI_Tag_ISA_C674X
:
13834 printf ("C674x\n");
13837 printf ("??? (%d)\n", val
);
13842 case Tag_ABI_wchar_t
:
13843 val
= read_uleb128 (p
, &len
, end
);
13845 printf (" Tag_ABI_wchar_t: ");
13849 printf (_("Not used\n"));
13852 printf (_("2 bytes\n"));
13855 printf (_("4 bytes\n"));
13858 printf ("??? (%d)\n", val
);
13863 case Tag_ABI_stack_align_needed
:
13864 val
= read_uleb128 (p
, &len
, end
);
13866 printf (" Tag_ABI_stack_align_needed: ");
13870 printf (_("8-byte\n"));
13873 printf (_("16-byte\n"));
13876 printf ("??? (%d)\n", val
);
13881 case Tag_ABI_stack_align_preserved
:
13882 val
= read_uleb128 (p
, &len
, end
);
13884 printf (" Tag_ABI_stack_align_preserved: ");
13888 printf (_("8-byte\n"));
13891 printf (_("16-byte\n"));
13894 printf ("??? (%d)\n", val
);
13900 val
= read_uleb128 (p
, &len
, end
);
13902 printf (" Tag_ABI_DSBT: ");
13906 printf (_("DSBT addressing not used\n"));
13909 printf (_("DSBT addressing used\n"));
13912 printf ("??? (%d)\n", val
);
13918 val
= read_uleb128 (p
, &len
, end
);
13920 printf (" Tag_ABI_PID: ");
13924 printf (_("Data addressing position-dependent\n"));
13927 printf (_("Data addressing position-independent, GOT near DP\n"));
13930 printf (_("Data addressing position-independent, GOT far from DP\n"));
13933 printf ("??? (%d)\n", val
);
13939 val
= read_uleb128 (p
, &len
, end
);
13941 printf (" Tag_ABI_PIC: ");
13945 printf (_("Code addressing position-dependent\n"));
13948 printf (_("Code addressing position-independent\n"));
13951 printf ("??? (%d)\n", val
);
13956 case Tag_ABI_array_object_alignment
:
13957 val
= read_uleb128 (p
, &len
, end
);
13959 printf (" Tag_ABI_array_object_alignment: ");
13963 printf (_("8-byte\n"));
13966 printf (_("4-byte\n"));
13969 printf (_("16-byte\n"));
13972 printf ("??? (%d)\n", val
);
13977 case Tag_ABI_array_object_align_expected
:
13978 val
= read_uleb128 (p
, &len
, end
);
13980 printf (" Tag_ABI_array_object_align_expected: ");
13984 printf (_("8-byte\n"));
13987 printf (_("4-byte\n"));
13990 printf (_("16-byte\n"));
13993 printf ("??? (%d)\n", val
);
13998 case Tag_ABI_compatibility
:
14000 val
= read_uleb128 (p
, &len
, end
);
14002 printf (" Tag_ABI_compatibility: ");
14003 printf (_("flag = %d, vendor = "), val
);
14006 size_t maxlen
= (end
- p
) - 1;
14008 print_symbol ((int) maxlen
, (const char *) p
);
14009 p
+= strnlen ((char *) p
, maxlen
) + 1;
14013 printf (_("<corrupt>"));
14014 p
= (unsigned char *) end
;
14020 case Tag_ABI_conformance
:
14022 printf (" Tag_ABI_conformance: \"");
14025 size_t maxlen
= (end
- p
) - 1;
14027 print_symbol ((int) maxlen
, (const char *) p
);
14028 p
+= strnlen ((char *) p
, maxlen
) + 1;
14032 printf (_("<corrupt>"));
14033 p
= (unsigned char *) end
;
14040 return display_tag_value (tag
, p
, end
);
14044 display_raw_attribute (unsigned char * p
, unsigned char * end
)
14046 unsigned long addr
= 0;
14047 size_t bytes
= end
- p
;
14054 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14056 printf (" 0x%8.8lx ", addr
);
14058 for (j
= 0; j
< 16; j
++)
14061 printf ("%2.2x", p
[j
]);
14069 for (j
= 0; j
< lbytes
; j
++)
14072 if (k
>= ' ' && k
< 0x7f)
14088 static unsigned char *
14089 display_msp430x_attribute (unsigned char * p
,
14090 const unsigned char * const end
)
14096 tag
= read_uleb128 (p
, & len
, end
);
14101 case OFBA_MSPABI_Tag_ISA
:
14102 val
= read_uleb128 (p
, &len
, end
);
14104 printf (" Tag_ISA: ");
14107 case 0: printf (_("None\n")); break;
14108 case 1: printf (_("MSP430\n")); break;
14109 case 2: printf (_("MSP430X\n")); break;
14110 default: printf ("??? (%d)\n", val
); break;
14114 case OFBA_MSPABI_Tag_Code_Model
:
14115 val
= read_uleb128 (p
, &len
, end
);
14117 printf (" Tag_Code_Model: ");
14120 case 0: printf (_("None\n")); break;
14121 case 1: printf (_("Small\n")); break;
14122 case 2: printf (_("Large\n")); break;
14123 default: printf ("??? (%d)\n", val
); break;
14127 case OFBA_MSPABI_Tag_Data_Model
:
14128 val
= read_uleb128 (p
, &len
, end
);
14130 printf (" Tag_Data_Model: ");
14133 case 0: printf (_("None\n")); break;
14134 case 1: printf (_("Small\n")); break;
14135 case 2: printf (_("Large\n")); break;
14136 case 3: printf (_("Restricted Large\n")); break;
14137 default: printf ("??? (%d)\n", val
); break;
14142 printf (_(" <unknown tag %d>: "), tag
);
14149 size_t maxlen
= (end
- p
) - 1;
14151 print_symbol ((int) maxlen
, (const char *) p
);
14152 p
+= strnlen ((char *) p
, maxlen
) + 1;
14156 printf (_("<corrupt>"));
14157 p
= (unsigned char *) end
;
14163 val
= read_uleb128 (p
, &len
, end
);
14165 printf ("%d (0x%x)\n", val
, val
);
14175 process_attributes (FILE * file
,
14176 const char * public_name
,
14177 unsigned int proc_type
,
14178 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14179 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14181 Elf_Internal_Shdr
* sect
;
14184 /* Find the section header so that we get the size. */
14185 for (i
= 0, sect
= section_headers
;
14186 i
< elf_header
.e_shnum
;
14189 unsigned char * contents
;
14192 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14195 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14196 sect
->sh_size
, _("attributes"));
14197 if (contents
== NULL
)
14203 bfd_vma section_len
;
14205 section_len
= sect
->sh_size
- 1;
14208 while (section_len
> 0)
14211 unsigned int namelen
;
14212 bfd_boolean public_section
;
14213 bfd_boolean gnu_section
;
14215 if (section_len
<= 4)
14217 error (_("Tag section ends prematurely\n"));
14220 attr_len
= byte_get (p
, 4);
14223 if (attr_len
> section_len
)
14225 error (_("Bad attribute length (%u > %u)\n"),
14226 (unsigned) attr_len
, (unsigned) section_len
);
14227 attr_len
= section_len
;
14229 /* PR 17531: file: 001-101425-0.004 */
14230 else if (attr_len
< 5)
14232 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14236 section_len
-= attr_len
;
14239 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14240 if (namelen
== 0 || namelen
>= attr_len
)
14242 error (_("Corrupt attribute section name\n"));
14246 printf (_("Attribute Section: "));
14247 print_symbol (INT_MAX
, (const char *) p
);
14250 if (public_name
&& streq ((char *) p
, public_name
))
14251 public_section
= TRUE
;
14253 public_section
= FALSE
;
14255 if (streq ((char *) p
, "gnu"))
14256 gnu_section
= TRUE
;
14258 gnu_section
= FALSE
;
14261 attr_len
-= namelen
;
14263 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14268 unsigned char * end
;
14270 /* PR binutils/17531: Safe handling of corrupt files. */
14273 error (_("Unused bytes at end of section\n"));
14279 size
= byte_get (p
, 4);
14280 if (size
> attr_len
)
14282 error (_("Bad subsection length (%u > %u)\n"),
14283 (unsigned) size
, (unsigned) attr_len
);
14286 /* PR binutils/17531: Safe handling of corrupt files. */
14289 error (_("Bad subsection length (%u < 6)\n"),
14296 end
= p
+ size
- 1;
14297 assert (end
<= contents
+ sect
->sh_size
);
14303 printf (_("File Attributes\n"));
14306 printf (_("Section Attributes:"));
14309 printf (_("Symbol Attributes:"));
14310 /* Fall through. */
14316 val
= read_uleb128 (p
, &j
, end
);
14320 printf (" %d", val
);
14325 printf (_("Unknown tag: %d\n"), tag
);
14326 public_section
= FALSE
;
14330 if (public_section
&& display_pub_attribute
!= NULL
)
14333 p
= display_pub_attribute (p
, end
);
14336 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14339 p
= display_gnu_attribute (p
,
14340 display_proc_gnu_attribute
,
14346 printf (_(" Unknown attribute:\n"));
14347 display_raw_attribute (p
, end
);
14356 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14364 process_arm_specific (FILE * file
)
14366 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14367 display_arm_attribute
, NULL
);
14371 process_power_specific (FILE * file
)
14373 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14374 display_power_gnu_attribute
);
14378 process_s390_specific (FILE * file
)
14380 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14381 display_s390_gnu_attribute
);
14385 process_sparc_specific (FILE * file
)
14387 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14388 display_sparc_gnu_attribute
);
14392 process_tic6x_specific (FILE * file
)
14394 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14395 display_tic6x_attribute
, NULL
);
14399 process_msp430x_specific (FILE * file
)
14401 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14402 display_msp430x_attribute
, NULL
);
14405 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14406 Print the Address, Access and Initial fields of an entry at VMA ADDR
14407 and return the VMA of the next entry, or -1 if there was a problem.
14408 Does not read from DATA_END or beyond. */
14411 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14412 unsigned char * data_end
)
14415 print_vma (addr
, LONG_HEX
);
14417 if (addr
< pltgot
+ 0xfff0)
14418 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14420 printf ("%10s", "");
14423 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14427 unsigned char * from
= data
+ addr
- pltgot
;
14429 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14431 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14432 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14433 return (bfd_vma
) -1;
14437 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14438 print_vma (entry
, LONG_HEX
);
14441 return addr
+ (is_32bit_elf
? 4 : 8);
14444 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14445 PLTGOT. Print the Address and Initial fields of an entry at VMA
14446 ADDR and return the VMA of the next entry. */
14449 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14452 print_vma (addr
, LONG_HEX
);
14455 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14460 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14461 print_vma (entry
, LONG_HEX
);
14463 return addr
+ (is_32bit_elf
? 4 : 8);
14467 print_mips_ases (unsigned int mask
)
14469 if (mask
& AFL_ASE_DSP
)
14470 fputs ("\n\tDSP ASE", stdout
);
14471 if (mask
& AFL_ASE_DSPR2
)
14472 fputs ("\n\tDSP R2 ASE", stdout
);
14473 if (mask
& AFL_ASE_DSPR3
)
14474 fputs ("\n\tDSP R3 ASE", stdout
);
14475 if (mask
& AFL_ASE_EVA
)
14476 fputs ("\n\tEnhanced VA Scheme", stdout
);
14477 if (mask
& AFL_ASE_MCU
)
14478 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14479 if (mask
& AFL_ASE_MDMX
)
14480 fputs ("\n\tMDMX ASE", stdout
);
14481 if (mask
& AFL_ASE_MIPS3D
)
14482 fputs ("\n\tMIPS-3D ASE", stdout
);
14483 if (mask
& AFL_ASE_MT
)
14484 fputs ("\n\tMT ASE", stdout
);
14485 if (mask
& AFL_ASE_SMARTMIPS
)
14486 fputs ("\n\tSmartMIPS ASE", stdout
);
14487 if (mask
& AFL_ASE_VIRT
)
14488 fputs ("\n\tVZ ASE", stdout
);
14489 if (mask
& AFL_ASE_MSA
)
14490 fputs ("\n\tMSA ASE", stdout
);
14491 if (mask
& AFL_ASE_MIPS16
)
14492 fputs ("\n\tMIPS16 ASE", stdout
);
14493 if (mask
& AFL_ASE_MICROMIPS
)
14494 fputs ("\n\tMICROMIPS ASE", stdout
);
14495 if (mask
& AFL_ASE_XPA
)
14496 fputs ("\n\tXPA ASE", stdout
);
14498 fprintf (stdout
, "\n\t%s", _("None"));
14499 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14500 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14504 print_mips_isa_ext (unsigned int isa_ext
)
14509 fputs (_("None"), stdout
);
14512 fputs ("RMI XLR", stdout
);
14514 case AFL_EXT_OCTEON3
:
14515 fputs ("Cavium Networks Octeon3", stdout
);
14517 case AFL_EXT_OCTEON2
:
14518 fputs ("Cavium Networks Octeon2", stdout
);
14520 case AFL_EXT_OCTEONP
:
14521 fputs ("Cavium Networks OcteonP", stdout
);
14523 case AFL_EXT_LOONGSON_3A
:
14524 fputs ("Loongson 3A", stdout
);
14526 case AFL_EXT_OCTEON
:
14527 fputs ("Cavium Networks Octeon", stdout
);
14530 fputs ("Toshiba R5900", stdout
);
14533 fputs ("MIPS R4650", stdout
);
14536 fputs ("LSI R4010", stdout
);
14539 fputs ("NEC VR4100", stdout
);
14542 fputs ("Toshiba R3900", stdout
);
14544 case AFL_EXT_10000
:
14545 fputs ("MIPS R10000", stdout
);
14548 fputs ("Broadcom SB-1", stdout
);
14551 fputs ("NEC VR4111/VR4181", stdout
);
14554 fputs ("NEC VR4120", stdout
);
14557 fputs ("NEC VR5400", stdout
);
14560 fputs ("NEC VR5500", stdout
);
14562 case AFL_EXT_LOONGSON_2E
:
14563 fputs ("ST Microelectronics Loongson 2E", stdout
);
14565 case AFL_EXT_LOONGSON_2F
:
14566 fputs ("ST Microelectronics Loongson 2F", stdout
);
14569 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14574 get_mips_reg_size (int reg_size
)
14576 return (reg_size
== AFL_REG_NONE
) ? 0
14577 : (reg_size
== AFL_REG_32
) ? 32
14578 : (reg_size
== AFL_REG_64
) ? 64
14579 : (reg_size
== AFL_REG_128
) ? 128
14584 process_mips_specific (FILE * file
)
14586 Elf_Internal_Dyn
* entry
;
14587 Elf_Internal_Shdr
*sect
= NULL
;
14588 size_t liblist_offset
= 0;
14589 size_t liblistno
= 0;
14590 size_t conflictsno
= 0;
14591 size_t options_offset
= 0;
14592 size_t conflicts_offset
= 0;
14593 size_t pltrelsz
= 0;
14595 bfd_vma pltgot
= 0;
14596 bfd_vma mips_pltgot
= 0;
14597 bfd_vma jmprel
= 0;
14598 bfd_vma local_gotno
= 0;
14599 bfd_vma gotsym
= 0;
14600 bfd_vma symtabno
= 0;
14602 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14603 display_mips_gnu_attribute
);
14605 sect
= find_section (".MIPS.abiflags");
14609 Elf_External_ABIFlags_v0
*abiflags_ext
;
14610 Elf_Internal_ABIFlags_v0 abiflags_in
;
14612 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14613 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14616 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14617 sect
->sh_size
, _("MIPS ABI Flags section"));
14620 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14621 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14622 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14623 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14624 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14625 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14626 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14627 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14628 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14629 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14630 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14632 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14633 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14634 if (abiflags_in
.isa_rev
> 1)
14635 printf ("r%d", abiflags_in
.isa_rev
);
14636 printf ("\nGPR size: %d",
14637 get_mips_reg_size (abiflags_in
.gpr_size
));
14638 printf ("\nCPR1 size: %d",
14639 get_mips_reg_size (abiflags_in
.cpr1_size
));
14640 printf ("\nCPR2 size: %d",
14641 get_mips_reg_size (abiflags_in
.cpr2_size
));
14642 fputs ("\nFP ABI: ", stdout
);
14643 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14644 fputs ("ISA Extension: ", stdout
);
14645 print_mips_isa_ext (abiflags_in
.isa_ext
);
14646 fputs ("\nASEs:", stdout
);
14647 print_mips_ases (abiflags_in
.ases
);
14648 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14649 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14650 fputc ('\n', stdout
);
14651 free (abiflags_ext
);
14656 /* We have a lot of special sections. Thanks SGI! */
14657 if (dynamic_section
== NULL
)
14658 /* No information available. */
14661 for (entry
= dynamic_section
;
14662 /* PR 17531 file: 012-50589-0.004. */
14663 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14665 switch (entry
->d_tag
)
14667 case DT_MIPS_LIBLIST
:
14669 = offset_from_vma (file
, entry
->d_un
.d_val
,
14670 liblistno
* sizeof (Elf32_External_Lib
));
14672 case DT_MIPS_LIBLISTNO
:
14673 liblistno
= entry
->d_un
.d_val
;
14675 case DT_MIPS_OPTIONS
:
14676 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14678 case DT_MIPS_CONFLICT
:
14680 = offset_from_vma (file
, entry
->d_un
.d_val
,
14681 conflictsno
* sizeof (Elf32_External_Conflict
));
14683 case DT_MIPS_CONFLICTNO
:
14684 conflictsno
= entry
->d_un
.d_val
;
14687 pltgot
= entry
->d_un
.d_ptr
;
14689 case DT_MIPS_LOCAL_GOTNO
:
14690 local_gotno
= entry
->d_un
.d_val
;
14692 case DT_MIPS_GOTSYM
:
14693 gotsym
= entry
->d_un
.d_val
;
14695 case DT_MIPS_SYMTABNO
:
14696 symtabno
= entry
->d_un
.d_val
;
14698 case DT_MIPS_PLTGOT
:
14699 mips_pltgot
= entry
->d_un
.d_ptr
;
14702 pltrel
= entry
->d_un
.d_val
;
14705 pltrelsz
= entry
->d_un
.d_val
;
14708 jmprel
= entry
->d_un
.d_ptr
;
14714 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14716 Elf32_External_Lib
* elib
;
14719 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14721 sizeof (Elf32_External_Lib
),
14722 _("liblist section data"));
14725 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14726 (unsigned long) liblistno
);
14727 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14730 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14737 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14738 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14739 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14740 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14741 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14743 tmp
= gmtime (&atime
);
14744 snprintf (timebuf
, sizeof (timebuf
),
14745 "%04u-%02u-%02uT%02u:%02u:%02u",
14746 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14747 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14749 printf ("%3lu: ", (unsigned long) cnt
);
14750 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14751 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14753 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14754 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14755 liblist
.l_version
);
14757 if (liblist
.l_flags
== 0)
14761 static const struct
14768 { " EXACT_MATCH", LL_EXACT_MATCH
},
14769 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14770 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14771 { " EXPORTS", LL_EXPORTS
},
14772 { " DELAY_LOAD", LL_DELAY_LOAD
},
14773 { " DELTA", LL_DELTA
}
14775 int flags
= liblist
.l_flags
;
14778 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14779 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14781 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14782 flags
^= l_flags_vals
[fcnt
].bit
;
14785 printf (" %#x", (unsigned int) flags
);
14795 if (options_offset
!= 0)
14797 Elf_External_Options
* eopt
;
14798 Elf_Internal_Options
* iopt
;
14799 Elf_Internal_Options
* option
;
14802 sect
= section_headers
;
14804 /* Find the section header so that we get the size. */
14805 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14806 /* PR 17533 file: 012-277276-0.004. */
14809 error (_("No MIPS_OPTIONS header found\n"));
14813 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14814 sect
->sh_size
, _("options"));
14817 iopt
= (Elf_Internal_Options
*)
14818 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14821 error (_("Out of memory allocating space for MIPS options\n"));
14828 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14830 Elf_External_Options
* eoption
;
14832 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14834 option
->kind
= BYTE_GET (eoption
->kind
);
14835 option
->size
= BYTE_GET (eoption
->size
);
14836 option
->section
= BYTE_GET (eoption
->section
);
14837 option
->info
= BYTE_GET (eoption
->info
);
14839 /* PR 17531: file: ffa0fa3b. */
14840 if (option
->size
< sizeof (* eopt
)
14841 || offset
+ option
->size
> sect
->sh_size
)
14843 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14846 offset
+= option
->size
;
14852 printf (_("\nSection '%s' contains %d entries:\n"),
14853 printable_section_name (sect
), cnt
);
14862 switch (option
->kind
)
14865 /* This shouldn't happen. */
14866 printf (" NULL %d %lx", option
->section
, option
->info
);
14869 printf (" REGINFO ");
14870 if (elf_header
.e_machine
== EM_MIPS
)
14873 Elf32_External_RegInfo
* ereg
;
14874 Elf32_RegInfo reginfo
;
14876 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14877 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14878 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14879 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14880 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14881 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14882 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14884 printf ("GPR %08lx GP 0x%lx\n",
14885 reginfo
.ri_gprmask
,
14886 (unsigned long) reginfo
.ri_gp_value
);
14887 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14888 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14889 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14894 Elf64_External_RegInfo
* ereg
;
14895 Elf64_Internal_RegInfo reginfo
;
14897 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14898 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14899 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14900 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14901 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14902 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14903 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14905 printf ("GPR %08lx GP 0x",
14906 reginfo
.ri_gprmask
);
14907 printf_vma (reginfo
.ri_gp_value
);
14910 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14911 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14912 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14916 case ODK_EXCEPTIONS
:
14917 fputs (" EXCEPTIONS fpe_min(", stdout
);
14918 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14919 fputs (") fpe_max(", stdout
);
14920 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14921 fputs (")", stdout
);
14923 if (option
->info
& OEX_PAGE0
)
14924 fputs (" PAGE0", stdout
);
14925 if (option
->info
& OEX_SMM
)
14926 fputs (" SMM", stdout
);
14927 if (option
->info
& OEX_FPDBUG
)
14928 fputs (" FPDBUG", stdout
);
14929 if (option
->info
& OEX_DISMISS
)
14930 fputs (" DISMISS", stdout
);
14933 fputs (" PAD ", stdout
);
14934 if (option
->info
& OPAD_PREFIX
)
14935 fputs (" PREFIX", stdout
);
14936 if (option
->info
& OPAD_POSTFIX
)
14937 fputs (" POSTFIX", stdout
);
14938 if (option
->info
& OPAD_SYMBOL
)
14939 fputs (" SYMBOL", stdout
);
14942 fputs (" HWPATCH ", stdout
);
14943 if (option
->info
& OHW_R4KEOP
)
14944 fputs (" R4KEOP", stdout
);
14945 if (option
->info
& OHW_R8KPFETCH
)
14946 fputs (" R8KPFETCH", stdout
);
14947 if (option
->info
& OHW_R5KEOP
)
14948 fputs (" R5KEOP", stdout
);
14949 if (option
->info
& OHW_R5KCVTL
)
14950 fputs (" R5KCVTL", stdout
);
14953 fputs (" FILL ", stdout
);
14954 /* XXX Print content of info word? */
14957 fputs (" TAGS ", stdout
);
14958 /* XXX Print content of info word? */
14961 fputs (" HWAND ", stdout
);
14962 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14963 fputs (" R4KEOP_CHECKED", stdout
);
14964 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14965 fputs (" R4KEOP_CLEAN", stdout
);
14968 fputs (" HWOR ", stdout
);
14969 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14970 fputs (" R4KEOP_CHECKED", stdout
);
14971 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14972 fputs (" R4KEOP_CLEAN", stdout
);
14975 printf (" GP_GROUP %#06lx self-contained %#06lx",
14976 option
->info
& OGP_GROUP
,
14977 (option
->info
& OGP_SELF
) >> 16);
14980 printf (" IDENT %#06lx self-contained %#06lx",
14981 option
->info
& OGP_GROUP
,
14982 (option
->info
& OGP_SELF
) >> 16);
14985 /* This shouldn't happen. */
14986 printf (" %3d ??? %d %lx",
14987 option
->kind
, option
->section
, option
->info
);
14991 len
= sizeof (* eopt
);
14992 while (len
< option
->size
)
14994 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14996 if (ISPRINT (datum
))
14997 printf ("%c", datum
);
14999 printf ("\\%03o", datum
);
15002 fputs ("\n", stdout
);
15004 offset
+= option
->size
;
15012 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15014 Elf32_Conflict
* iconf
;
15017 if (dynamic_symbols
== NULL
)
15019 error (_("conflict list found without a dynamic symbol table\n"));
15023 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15026 error (_("Out of memory allocating space for dynamic conflicts\n"));
15032 Elf32_External_Conflict
* econf32
;
15034 econf32
= (Elf32_External_Conflict
*)
15035 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15036 sizeof (* econf32
), _("conflict"));
15040 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15041 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15047 Elf64_External_Conflict
* econf64
;
15049 econf64
= (Elf64_External_Conflict
*)
15050 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15051 sizeof (* econf64
), _("conflict"));
15055 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15056 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15061 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15062 (unsigned long) conflictsno
);
15063 puts (_(" Num: Index Value Name"));
15065 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15067 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15069 if (iconf
[cnt
] >= num_dynamic_syms
)
15070 printf (_("<corrupt symbol index>"));
15073 Elf_Internal_Sym
* psym
;
15075 psym
= & dynamic_symbols
[iconf
[cnt
]];
15076 print_vma (psym
->st_value
, FULL_HEX
);
15078 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15079 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15081 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15089 if (pltgot
!= 0 && local_gotno
!= 0)
15091 bfd_vma ent
, local_end
, global_end
;
15093 unsigned char * data
;
15094 unsigned char * data_end
;
15098 addr_size
= (is_32bit_elf
? 4 : 8);
15099 local_end
= pltgot
+ local_gotno
* addr_size
;
15101 /* PR binutils/17533 file: 012-111227-0.004 */
15102 if (symtabno
< gotsym
)
15104 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15105 (unsigned long) gotsym
, (unsigned long) symtabno
);
15109 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15110 /* PR 17531: file: 54c91a34. */
15111 if (global_end
< local_end
)
15113 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15117 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15118 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15119 global_end
- pltgot
, 1,
15120 _("Global Offset Table data"));
15123 data_end
= data
+ (global_end
- pltgot
);
15125 printf (_("\nPrimary GOT:\n"));
15126 printf (_(" Canonical gp value: "));
15127 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15130 printf (_(" Reserved entries:\n"));
15131 printf (_(" %*s %10s %*s Purpose\n"),
15132 addr_size
* 2, _("Address"), _("Access"),
15133 addr_size
* 2, _("Initial"));
15134 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15135 printf (_(" Lazy resolver\n"));
15136 if (ent
== (bfd_vma
) -1)
15137 goto got_print_fail
;
15139 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15140 >> (addr_size
* 8 - 1)) != 0)
15142 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15143 printf (_(" Module pointer (GNU extension)\n"));
15144 if (ent
== (bfd_vma
) -1)
15145 goto got_print_fail
;
15149 if (ent
< local_end
)
15151 printf (_(" Local entries:\n"));
15152 printf (" %*s %10s %*s\n",
15153 addr_size
* 2, _("Address"), _("Access"),
15154 addr_size
* 2, _("Initial"));
15155 while (ent
< local_end
)
15157 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15159 if (ent
== (bfd_vma
) -1)
15160 goto got_print_fail
;
15165 if (gotsym
< symtabno
)
15169 printf (_(" Global entries:\n"));
15170 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15171 addr_size
* 2, _("Address"),
15173 addr_size
* 2, _("Initial"),
15174 addr_size
* 2, _("Sym.Val."),
15176 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15177 _("Ndx"), _("Name"));
15179 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15181 for (i
= gotsym
; i
< symtabno
; i
++)
15183 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15186 if (dynamic_symbols
== NULL
)
15187 printf (_("<no dynamic symbols>"));
15188 else if (i
< num_dynamic_syms
)
15190 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15192 print_vma (psym
->st_value
, LONG_HEX
);
15193 printf (" %-7s %3s ",
15194 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15195 get_symbol_index_type (psym
->st_shndx
));
15197 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15198 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15200 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15203 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15204 (unsigned long) i
);
15207 if (ent
== (bfd_vma
) -1)
15218 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15221 size_t offset
, rel_offset
;
15222 unsigned long count
, i
;
15223 unsigned char * data
;
15224 int addr_size
, sym_width
;
15225 Elf_Internal_Rela
* rels
;
15227 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15228 if (pltrel
== DT_RELA
)
15230 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15235 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15240 addr_size
= (is_32bit_elf
? 4 : 8);
15241 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15243 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15244 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15245 1, _("Procedure Linkage Table data"));
15249 printf ("\nPLT GOT:\n\n");
15250 printf (_(" Reserved entries:\n"));
15251 printf (_(" %*s %*s Purpose\n"),
15252 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15253 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15254 printf (_(" PLT lazy resolver\n"));
15255 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15256 printf (_(" Module pointer\n"));
15259 printf (_(" Entries:\n"));
15260 printf (" %*s %*s %*s %-7s %3s %s\n",
15261 addr_size
* 2, _("Address"),
15262 addr_size
* 2, _("Initial"),
15263 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15264 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15265 for (i
= 0; i
< count
; i
++)
15267 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15269 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15272 if (idx
>= num_dynamic_syms
)
15273 printf (_("<corrupt symbol index: %lu>"), idx
);
15276 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15278 print_vma (psym
->st_value
, LONG_HEX
);
15279 printf (" %-7s %3s ",
15280 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15281 get_symbol_index_type (psym
->st_shndx
));
15282 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15283 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15285 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15300 process_nds32_specific (FILE * file
)
15302 Elf_Internal_Shdr
*sect
= NULL
;
15304 sect
= find_section (".nds32_e_flags");
15307 unsigned int *flag
;
15309 printf ("\nNDS32 elf flags section:\n");
15310 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15311 sect
->sh_size
, _("NDS32 elf flags section"));
15313 switch ((*flag
) & 0x3)
15316 printf ("(VEC_SIZE):\tNo entry.\n");
15319 printf ("(VEC_SIZE):\t4 bytes\n");
15322 printf ("(VEC_SIZE):\t16 bytes\n");
15325 printf ("(VEC_SIZE):\treserved\n");
15334 process_gnu_liblist (FILE * file
)
15336 Elf_Internal_Shdr
* section
;
15337 Elf_Internal_Shdr
* string_sec
;
15338 Elf32_External_Lib
* elib
;
15340 size_t strtab_size
;
15347 for (i
= 0, section
= section_headers
;
15348 i
< elf_header
.e_shnum
;
15351 switch (section
->sh_type
)
15353 case SHT_GNU_LIBLIST
:
15354 if (section
->sh_link
>= elf_header
.e_shnum
)
15357 elib
= (Elf32_External_Lib
*)
15358 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15359 _("liblist section data"));
15363 string_sec
= section_headers
+ section
->sh_link
;
15365 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15366 string_sec
->sh_size
,
15367 _("liblist string table"));
15369 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15375 strtab_size
= string_sec
->sh_size
;
15377 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15378 printable_section_name (section
),
15379 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15381 puts (_(" Library Time Stamp Checksum Version Flags"));
15383 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15391 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15392 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15393 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15394 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15395 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15397 tmp
= gmtime (&atime
);
15398 snprintf (timebuf
, sizeof (timebuf
),
15399 "%04u-%02u-%02uT%02u:%02u:%02u",
15400 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15401 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15403 printf ("%3lu: ", (unsigned long) cnt
);
15405 printf ("%-20s", liblist
.l_name
< strtab_size
15406 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15408 printf ("%-20.20s", liblist
.l_name
< strtab_size
15409 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15410 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15411 liblist
.l_version
, liblist
.l_flags
);
15422 static const char *
15423 get_note_type (unsigned e_type
)
15425 static char buff
[64];
15427 if (elf_header
.e_type
== ET_CORE
)
15431 return _("NT_AUXV (auxiliary vector)");
15433 return _("NT_PRSTATUS (prstatus structure)");
15435 return _("NT_FPREGSET (floating point registers)");
15437 return _("NT_PRPSINFO (prpsinfo structure)");
15438 case NT_TASKSTRUCT
:
15439 return _("NT_TASKSTRUCT (task structure)");
15441 return _("NT_PRXFPREG (user_xfpregs structure)");
15443 return _("NT_PPC_VMX (ppc Altivec registers)");
15445 return _("NT_PPC_VSX (ppc VSX registers)");
15447 return _("NT_386_TLS (x86 TLS information)");
15448 case NT_386_IOPERM
:
15449 return _("NT_386_IOPERM (x86 I/O permissions)");
15450 case NT_X86_XSTATE
:
15451 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15452 case NT_S390_HIGH_GPRS
:
15453 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15454 case NT_S390_TIMER
:
15455 return _("NT_S390_TIMER (s390 timer register)");
15456 case NT_S390_TODCMP
:
15457 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15458 case NT_S390_TODPREG
:
15459 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15461 return _("NT_S390_CTRS (s390 control registers)");
15462 case NT_S390_PREFIX
:
15463 return _("NT_S390_PREFIX (s390 prefix register)");
15464 case NT_S390_LAST_BREAK
:
15465 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15466 case NT_S390_SYSTEM_CALL
:
15467 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15469 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15470 case NT_S390_VXRS_LOW
:
15471 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15472 case NT_S390_VXRS_HIGH
:
15473 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15475 return _("NT_ARM_VFP (arm VFP registers)");
15477 return _("NT_ARM_TLS (AArch TLS registers)");
15478 case NT_ARM_HW_BREAK
:
15479 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15480 case NT_ARM_HW_WATCH
:
15481 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15483 return _("NT_PSTATUS (pstatus structure)");
15485 return _("NT_FPREGS (floating point registers)");
15487 return _("NT_PSINFO (psinfo structure)");
15489 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15491 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15492 case NT_WIN32PSTATUS
:
15493 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15495 return _("NT_SIGINFO (siginfo_t data)");
15497 return _("NT_FILE (mapped files)");
15505 return _("NT_VERSION (version)");
15507 return _("NT_ARCH (architecture)");
15512 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15517 print_core_note (Elf_Internal_Note
*pnote
)
15519 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15520 bfd_vma count
, page_size
;
15521 unsigned char *descdata
, *filenames
, *descend
;
15523 if (pnote
->type
!= NT_FILE
)
15529 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15530 /* Still "successful". */
15535 if (pnote
->descsz
< 2 * addr_size
)
15537 printf (_(" Malformed note - too short for header\n"));
15541 descdata
= (unsigned char *) pnote
->descdata
;
15542 descend
= descdata
+ pnote
->descsz
;
15544 if (descdata
[pnote
->descsz
- 1] != '\0')
15546 printf (_(" Malformed note - does not end with \\0\n"));
15550 count
= byte_get (descdata
, addr_size
);
15551 descdata
+= addr_size
;
15553 page_size
= byte_get (descdata
, addr_size
);
15554 descdata
+= addr_size
;
15556 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15558 printf (_(" Malformed note - too short for supplied file count\n"));
15562 printf (_(" Page size: "));
15563 print_vma (page_size
, DEC
);
15566 printf (_(" %*s%*s%*s\n"),
15567 (int) (2 + 2 * addr_size
), _("Start"),
15568 (int) (4 + 2 * addr_size
), _("End"),
15569 (int) (4 + 2 * addr_size
), _("Page Offset"));
15570 filenames
= descdata
+ count
* 3 * addr_size
;
15571 while (count
-- > 0)
15573 bfd_vma start
, end
, file_ofs
;
15575 if (filenames
== descend
)
15577 printf (_(" Malformed note - filenames end too early\n"));
15581 start
= byte_get (descdata
, addr_size
);
15582 descdata
+= addr_size
;
15583 end
= byte_get (descdata
, addr_size
);
15584 descdata
+= addr_size
;
15585 file_ofs
= byte_get (descdata
, addr_size
);
15586 descdata
+= addr_size
;
15589 print_vma (start
, FULL_HEX
);
15591 print_vma (end
, FULL_HEX
);
15593 print_vma (file_ofs
, FULL_HEX
);
15594 printf ("\n %s\n", filenames
);
15596 filenames
+= 1 + strlen ((char *) filenames
);
15602 static const char *
15603 get_gnu_elf_note_type (unsigned e_type
)
15605 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15608 case NT_GNU_ABI_TAG
:
15609 return _("NT_GNU_ABI_TAG (ABI version tag)");
15611 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15612 case NT_GNU_BUILD_ID
:
15613 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15614 case NT_GNU_GOLD_VERSION
:
15615 return _("NT_GNU_GOLD_VERSION (gold version)");
15618 static char buff
[64];
15620 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15627 print_gnu_note (Elf_Internal_Note
*pnote
)
15629 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15630 switch (pnote
->type
)
15632 case NT_GNU_BUILD_ID
:
15636 printf (_(" Build ID: "));
15637 for (i
= 0; i
< pnote
->descsz
; ++i
)
15638 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15643 case NT_GNU_ABI_TAG
:
15645 unsigned long os
, major
, minor
, subminor
;
15646 const char *osname
;
15648 /* PR 17531: file: 030-599401-0.004. */
15649 if (pnote
->descsz
< 16)
15651 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15655 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15656 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15657 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15658 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15662 case GNU_ABI_TAG_LINUX
:
15665 case GNU_ABI_TAG_HURD
:
15668 case GNU_ABI_TAG_SOLARIS
:
15669 osname
= "Solaris";
15671 case GNU_ABI_TAG_FREEBSD
:
15672 osname
= "FreeBSD";
15674 case GNU_ABI_TAG_NETBSD
:
15677 case GNU_ABI_TAG_SYLLABLE
:
15678 osname
= "Syllable";
15680 case GNU_ABI_TAG_NACL
:
15684 osname
= "Unknown";
15688 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15689 major
, minor
, subminor
);
15693 case NT_GNU_GOLD_VERSION
:
15697 printf (_(" Version: "));
15698 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15699 printf ("%c", pnote
->descdata
[i
]);
15706 unsigned long num_entries
, mask
;
15708 /* Hardware capabilities information. Word 0 is the number of entries.
15709 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15710 is a series of entries, where each entry is a single byte followed
15711 by a nul terminated string. The byte gives the bit number to test
15712 if enabled in the bitmask. */
15713 printf (_(" Hardware Capabilities: "));
15714 if (pnote
->descsz
< 8)
15716 printf (_("<corrupt GNU_HWCAP>\n"));
15719 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15720 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15721 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15722 /* FIXME: Add code to display the entries... */
15727 /* Handle unrecognised types. An error message should have already been
15728 created by get_gnu_elf_note_type(), so all that we need to do is to
15729 display the data. */
15733 printf (_(" Description data: "));
15734 for (i
= 0; i
< pnote
->descsz
; ++i
)
15735 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15744 static const char *
15745 get_v850_elf_note_type (enum v850_notes n_type
)
15747 static char buff
[64];
15751 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15752 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15753 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15754 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15755 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15756 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15758 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15764 print_v850_note (Elf_Internal_Note
* pnote
)
15768 if (pnote
->descsz
!= 4)
15770 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15774 printf (_("not set\n"));
15778 switch (pnote
->type
)
15780 case V850_NOTE_ALIGNMENT
:
15783 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15784 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15788 case V850_NOTE_DATA_SIZE
:
15791 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15792 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15796 case V850_NOTE_FPU_INFO
:
15799 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15800 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15804 case V850_NOTE_MMU_INFO
:
15805 case V850_NOTE_CACHE_INFO
:
15806 case V850_NOTE_SIMD_INFO
:
15807 if (val
== EF_RH850_SIMD
)
15809 printf (_("yes\n"));
15815 /* An 'unknown note type' message will already have been displayed. */
15819 printf (_("unknown value: %x\n"), val
);
15824 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15826 unsigned int version
;
15828 switch (pnote
->type
)
15830 case NT_NETBSD_IDENT
:
15831 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15832 if ((version
/ 10000) % 100)
15833 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15834 version
, version
/ 100000000, (version
/ 1000000) % 100,
15835 (version
/ 10000) % 100 > 26 ? "Z" : "",
15836 'A' + (version
/ 10000) % 26);
15838 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15839 version
, version
/ 100000000, (version
/ 1000000) % 100,
15840 (version
/ 100) % 100);
15843 case NT_NETBSD_MARCH
:
15844 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15852 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15857 static const char *
15858 get_freebsd_elfcore_note_type (unsigned e_type
)
15862 case NT_FREEBSD_THRMISC
:
15863 return _("NT_THRMISC (thrmisc structure)");
15864 case NT_FREEBSD_PROCSTAT_PROC
:
15865 return _("NT_PROCSTAT_PROC (proc data)");
15866 case NT_FREEBSD_PROCSTAT_FILES
:
15867 return _("NT_PROCSTAT_FILES (files data)");
15868 case NT_FREEBSD_PROCSTAT_VMMAP
:
15869 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15870 case NT_FREEBSD_PROCSTAT_GROUPS
:
15871 return _("NT_PROCSTAT_GROUPS (groups data)");
15872 case NT_FREEBSD_PROCSTAT_UMASK
:
15873 return _("NT_PROCSTAT_UMASK (umask data)");
15874 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15875 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15876 case NT_FREEBSD_PROCSTAT_OSREL
:
15877 return _("NT_PROCSTAT_OSREL (osreldate data)");
15878 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15879 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15880 case NT_FREEBSD_PROCSTAT_AUXV
:
15881 return _("NT_PROCSTAT_AUXV (auxv data)");
15883 return get_note_type (e_type
);
15886 static const char *
15887 get_netbsd_elfcore_note_type (unsigned e_type
)
15889 static char buff
[64];
15891 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15893 /* NetBSD core "procinfo" structure. */
15894 return _("NetBSD procinfo structure");
15897 /* As of Jan 2002 there are no other machine-independent notes
15898 defined for NetBSD core files. If the note type is less
15899 than the start of the machine-dependent note types, we don't
15902 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15904 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15908 switch (elf_header
.e_machine
)
15910 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15911 and PT_GETFPREGS == mach+2. */
15916 case EM_SPARC32PLUS
:
15920 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15921 return _("PT_GETREGS (reg structure)");
15922 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15923 return _("PT_GETFPREGS (fpreg structure)");
15929 /* On all other arch's, PT_GETREGS == mach+1 and
15930 PT_GETFPREGS == mach+3. */
15934 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15935 return _("PT_GETREGS (reg structure)");
15936 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15937 return _("PT_GETFPREGS (fpreg structure)");
15943 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15944 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15948 static const char *
15949 get_stapsdt_note_type (unsigned e_type
)
15951 static char buff
[64];
15956 return _("NT_STAPSDT (SystemTap probe descriptors)");
15962 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15967 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15969 int addr_size
= is_32bit_elf
? 4 : 8;
15970 char *data
= pnote
->descdata
;
15971 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15972 bfd_vma pc
, base_addr
, semaphore
;
15973 char *provider
, *probe
, *arg_fmt
;
15975 pc
= byte_get ((unsigned char *) data
, addr_size
);
15977 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15979 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15983 data
+= strlen (data
) + 1;
15985 data
+= strlen (data
) + 1;
15987 data
+= strlen (data
) + 1;
15989 printf (_(" Provider: %s\n"), provider
);
15990 printf (_(" Name: %s\n"), probe
);
15991 printf (_(" Location: "));
15992 print_vma (pc
, FULL_HEX
);
15993 printf (_(", Base: "));
15994 print_vma (base_addr
, FULL_HEX
);
15995 printf (_(", Semaphore: "));
15996 print_vma (semaphore
, FULL_HEX
);
15998 printf (_(" Arguments: %s\n"), arg_fmt
);
16000 return data
== data_end
;
16003 static const char *
16004 get_ia64_vms_note_type (unsigned e_type
)
16006 static char buff
[64];
16011 return _("NT_VMS_MHD (module header)");
16013 return _("NT_VMS_LNM (language name)");
16015 return _("NT_VMS_SRC (source files)");
16017 return "NT_VMS_TITLE";
16019 return _("NT_VMS_EIDC (consistency check)");
16020 case NT_VMS_FPMODE
:
16021 return _("NT_VMS_FPMODE (FP mode)");
16022 case NT_VMS_LINKTIME
:
16023 return "NT_VMS_LINKTIME";
16024 case NT_VMS_IMGNAM
:
16025 return _("NT_VMS_IMGNAM (image name)");
16027 return _("NT_VMS_IMGID (image id)");
16028 case NT_VMS_LINKID
:
16029 return _("NT_VMS_LINKID (link id)");
16030 case NT_VMS_IMGBID
:
16031 return _("NT_VMS_IMGBID (build id)");
16032 case NT_VMS_GSTNAM
:
16033 return _("NT_VMS_GSTNAM (sym table name)");
16034 case NT_VMS_ORIG_DYN
:
16035 return "NT_VMS_ORIG_DYN";
16036 case NT_VMS_PATCHTIME
:
16037 return "NT_VMS_PATCHTIME";
16039 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16045 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16047 switch (pnote
->type
)
16050 if (pnote
->descsz
> 36)
16052 size_t l
= strlen (pnote
->descdata
+ 34);
16053 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16054 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16055 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16056 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16059 printf (_(" Invalid size\n"));
16062 printf (_(" Language: %s\n"), pnote
->descdata
);
16065 case NT_VMS_FPMODE
:
16066 printf (_(" Floating Point mode: "));
16067 printf ("0x%016" BFD_VMA_FMT
"x\n",
16068 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16070 case NT_VMS_LINKTIME
:
16071 printf (_(" Link time: "));
16073 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16076 case NT_VMS_PATCHTIME
:
16077 printf (_(" Patch time: "));
16079 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16082 case NT_VMS_ORIG_DYN
:
16083 printf (_(" Major id: %u, minor id: %u\n"),
16084 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16085 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16086 printf (_(" Last modified : "));
16088 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16089 printf (_("\n Link flags : "));
16090 printf ("0x%016" BFD_VMA_FMT
"x\n",
16091 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16092 printf (_(" Header flags: 0x%08x\n"),
16093 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16094 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16097 case NT_VMS_IMGNAM
:
16098 printf (_(" Image name: %s\n"), pnote
->descdata
);
16100 case NT_VMS_GSTNAM
:
16101 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16104 printf (_(" Image id: %s\n"), pnote
->descdata
);
16106 case NT_VMS_LINKID
:
16107 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16115 /* Note that by the ELF standard, the name field is already null byte
16116 terminated, and namesz includes the terminating null byte.
16117 I.E. the value of namesz for the name "FSF" is 4.
16119 If the value of namesz is zero, there is no name present. */
16121 process_note (Elf_Internal_Note
* pnote
,
16122 FILE * file ATTRIBUTE_UNUSED
,
16123 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16125 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16128 if (pnote
->namesz
== 0)
16129 /* If there is no note name, then use the default set of
16130 note type strings. */
16131 nt
= get_note_type (pnote
->type
);
16133 else if (const_strneq (pnote
->namedata
, "GNU"))
16134 /* GNU-specific object file notes. */
16135 nt
= get_gnu_elf_note_type (pnote
->type
);
16137 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16138 /* FreeBSD-specific core file notes. */
16139 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16141 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16142 /* NetBSD-specific core file notes. */
16143 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16145 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16146 /* NetBSD-specific core file notes. */
16147 return process_netbsd_elf_note (pnote
);
16149 else if (strneq (pnote
->namedata
, "SPU/", 4))
16151 /* SPU-specific core file notes. */
16152 nt
= pnote
->namedata
+ 4;
16156 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16157 /* VMS/ia64-specific file notes. */
16158 nt
= get_ia64_vms_note_type (pnote
->type
);
16160 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16161 nt
= get_stapsdt_note_type (pnote
->type
);
16164 /* Don't recognize this note name; just use the default set of
16165 note type strings. */
16166 nt
= get_note_type (pnote
->type
);
16169 print_symbol (-20, name
);
16170 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16172 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16173 return print_ia64_vms_note (pnote
);
16174 else if (const_strneq (pnote
->namedata
, "GNU"))
16175 return print_gnu_note (pnote
);
16176 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16177 return print_stapsdt_note (pnote
);
16178 else if (const_strneq (pnote
->namedata
, "CORE"))
16179 return print_core_note (pnote
);
16181 else if (pnote
->descsz
)
16185 printf (_(" description data: "));
16186 for (i
= 0; i
< pnote
->descsz
; i
++)
16187 printf ("%02x ", pnote
->descdata
[i
]);
16195 process_notes_at (FILE * file
,
16196 Elf_Internal_Shdr
* section
,
16200 Elf_External_Note
* pnotes
;
16201 Elf_External_Note
* external
;
16210 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16212 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16215 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16217 if (pnotes
== NULL
)
16223 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16225 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16226 (unsigned long) offset
, (unsigned long) length
);
16228 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16230 end
= (char *) pnotes
+ length
;
16231 while ((char *) external
< end
)
16233 Elf_Internal_Note inote
;
16236 char * temp
= NULL
;
16237 size_t data_remaining
= end
- (char *) external
;
16239 if (!is_ia64_vms ())
16241 /* PR binutils/15191
16242 Make sure that there is enough data to read. */
16243 min_notesz
= offsetof (Elf_External_Note
, name
);
16244 if (data_remaining
< min_notesz
)
16246 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16247 (int) data_remaining
);
16250 inote
.type
= BYTE_GET (external
->type
);
16251 inote
.namesz
= BYTE_GET (external
->namesz
);
16252 inote
.namedata
= external
->name
;
16253 inote
.descsz
= BYTE_GET (external
->descsz
);
16254 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16255 /* PR 17531: file: 3443835e. */
16256 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16258 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16259 inote
.descdata
= inote
.namedata
;
16263 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16264 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16268 Elf64_External_VMS_Note
*vms_external
;
16270 /* PR binutils/15191
16271 Make sure that there is enough data to read. */
16272 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16273 if (data_remaining
< min_notesz
)
16275 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16276 (int) data_remaining
);
16280 vms_external
= (Elf64_External_VMS_Note
*) external
;
16281 inote
.type
= BYTE_GET (vms_external
->type
);
16282 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16283 inote
.namedata
= vms_external
->name
;
16284 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16285 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16286 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16287 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16290 if (inote
.descdata
< (char *) external
+ min_notesz
16291 || next
< (char *) external
+ min_notesz
16292 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16293 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16294 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16295 || data_remaining
< (size_t)(next
- (char *) external
))
16297 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16298 (unsigned long) ((char *) external
- (char *) pnotes
));
16299 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16300 inote
.type
, inote
.namesz
, inote
.descsz
);
16304 external
= (Elf_External_Note
*) next
;
16306 /* Verify that name is null terminated. It appears that at least
16307 one version of Linux (RedHat 6.0) generates corefiles that don't
16308 comply with the ELF spec by failing to include the null byte in
16310 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16312 temp
= (char *) malloc (inote
.namesz
+ 1);
16315 error (_("Out of memory allocating space for inote name\n"));
16320 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16321 temp
[inote
.namesz
] = 0;
16323 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16324 inote
.namedata
= temp
;
16327 res
&= process_note (& inote
, file
, section
);
16342 process_corefile_note_segments (FILE * file
)
16344 Elf_Internal_Phdr
* segment
;
16348 if (! get_program_headers (file
))
16351 for (i
= 0, segment
= program_headers
;
16352 i
< elf_header
.e_phnum
;
16355 if (segment
->p_type
== PT_NOTE
)
16356 res
&= process_notes_at (file
, NULL
,
16357 (bfd_vma
) segment
->p_offset
,
16358 (bfd_vma
) segment
->p_filesz
);
16365 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16367 Elf_External_Note
* pnotes
;
16368 Elf_External_Note
* external
;
16375 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16377 if (pnotes
== NULL
)
16381 end
= (char*) pnotes
+ length
;
16383 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16384 (unsigned long) offset
, (unsigned long) length
);
16386 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16388 Elf_External_Note
* next
;
16389 Elf_Internal_Note inote
;
16391 inote
.type
= BYTE_GET (external
->type
);
16392 inote
.namesz
= BYTE_GET (external
->namesz
);
16393 inote
.namedata
= external
->name
;
16394 inote
.descsz
= BYTE_GET (external
->descsz
);
16395 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16396 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16398 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16400 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16401 inote
.descdata
= inote
.namedata
;
16405 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16407 if ( ((char *) next
> end
)
16408 || ((char *) next
< (char *) pnotes
))
16410 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16411 (unsigned long) ((char *) external
- (char *) pnotes
));
16412 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16413 inote
.type
, inote
.namesz
, inote
.descsz
);
16419 /* Prevent out-of-bounds indexing. */
16420 if ( inote
.namedata
+ inote
.namesz
> end
16421 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16423 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16424 (unsigned long) ((char *) external
- (char *) pnotes
));
16425 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16426 inote
.type
, inote
.namesz
, inote
.descsz
);
16430 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16432 if (! print_v850_note (& inote
))
16435 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16436 inote
.namesz
, inote
.descsz
);
16446 process_note_sections (FILE * file
)
16448 Elf_Internal_Shdr
* section
;
16453 for (i
= 0, section
= section_headers
;
16454 i
< elf_header
.e_shnum
&& section
!= NULL
;
16457 if (section
->sh_type
== SHT_NOTE
)
16459 res
&= process_notes_at (file
, section
,
16460 (bfd_vma
) section
->sh_offset
,
16461 (bfd_vma
) section
->sh_size
);
16465 if (( elf_header
.e_machine
== EM_V800
16466 || elf_header
.e_machine
== EM_V850
16467 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16468 && section
->sh_type
== SHT_RENESAS_INFO
)
16470 res
&= process_v850_notes (file
,
16471 (bfd_vma
) section
->sh_offset
,
16472 (bfd_vma
) section
->sh_size
);
16478 /* Try processing NOTE segments instead. */
16479 return process_corefile_note_segments (file
);
16485 process_notes (FILE * file
)
16487 /* If we have not been asked to display the notes then do nothing. */
16491 if (elf_header
.e_type
!= ET_CORE
)
16492 return process_note_sections (file
);
16494 /* No program headers means no NOTE segment. */
16495 if (elf_header
.e_phnum
> 0)
16496 return process_corefile_note_segments (file
);
16498 printf (_("No note segments present in the core file.\n"));
16503 process_arch_specific (FILE * file
)
16508 switch (elf_header
.e_machine
)
16511 return process_arm_specific (file
);
16513 case EM_MIPS_RS3_LE
:
16514 return process_mips_specific (file
);
16517 return process_nds32_specific (file
);
16521 return process_power_specific (file
);
16525 return process_s390_specific (file
);
16528 case EM_SPARC32PLUS
:
16530 return process_sparc_specific (file
);
16533 return process_tic6x_specific (file
);
16536 return process_msp430x_specific (file
);
16544 get_file_header (FILE * file
)
16546 /* Read in the identity array. */
16547 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16550 /* Determine how to read the rest of the header. */
16551 switch (elf_header
.e_ident
[EI_DATA
])
16556 byte_get
= byte_get_little_endian
;
16557 byte_put
= byte_put_little_endian
;
16560 byte_get
= byte_get_big_endian
;
16561 byte_put
= byte_put_big_endian
;
16565 /* For now we only support 32 bit and 64 bit ELF files. */
16566 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16568 /* Read in the rest of the header. */
16571 Elf32_External_Ehdr ehdr32
;
16573 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16576 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16577 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16578 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16579 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16580 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16581 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16582 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16583 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16584 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16585 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16586 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16587 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16588 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16592 Elf64_External_Ehdr ehdr64
;
16594 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16595 we will not be able to cope with the 64bit data found in
16596 64 ELF files. Detect this now and abort before we start
16597 overwriting things. */
16598 if (sizeof (bfd_vma
) < 8)
16600 error (_("This instance of readelf has been built without support for a\n\
16601 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16605 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16608 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16609 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16610 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16611 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16612 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16613 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16614 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16615 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16616 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16617 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16618 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16619 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16620 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16623 if (elf_header
.e_shoff
)
16625 /* There may be some extensions in the first section header. Don't
16626 bomb if we can't read it. */
16628 get_32bit_section_headers (file
, TRUE
);
16630 get_64bit_section_headers (file
, TRUE
);
16636 /* Process one ELF object file according to the command line options.
16637 This file may actually be stored in an archive. The file is
16638 positioned at the start of the ELF object. */
16641 process_object (char * file_name
, FILE * file
)
16645 if (! get_file_header (file
))
16647 error (_("%s: Failed to read file header\n"), file_name
);
16651 /* Initialise per file variables. */
16652 for (i
= ARRAY_SIZE (version_info
); i
--;)
16653 version_info
[i
] = 0;
16655 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16656 dynamic_info
[i
] = 0;
16657 dynamic_info_DT_GNU_HASH
= 0;
16659 /* Process the file. */
16661 printf (_("\nFile: %s\n"), file_name
);
16663 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16664 Note we do this even if cmdline_dump_sects is empty because we
16665 must make sure that the dump_sets array is zeroed out before each
16666 object file is processed. */
16667 if (num_dump_sects
> num_cmdline_dump_sects
)
16668 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16670 if (num_cmdline_dump_sects
> 0)
16672 if (num_dump_sects
== 0)
16673 /* A sneaky way of allocating the dump_sects array. */
16674 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16676 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16677 memcpy (dump_sects
, cmdline_dump_sects
,
16678 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16681 if (! process_file_header ())
16684 if (! process_section_headers (file
))
16686 /* Without loaded section headers we cannot process lots of
16688 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16690 if (! do_using_dynamic
)
16691 do_syms
= do_dyn_syms
= do_reloc
= 0;
16694 if (! process_section_groups (file
))
16696 /* Without loaded section groups we cannot process unwind. */
16700 if (process_program_headers (file
))
16701 process_dynamic_section (file
);
16703 process_relocs (file
);
16705 process_unwind (file
);
16707 process_symbol_table (file
);
16709 process_syminfo (file
);
16711 process_version_sections (file
);
16713 process_section_contents (file
);
16715 process_notes (file
);
16717 process_gnu_liblist (file
);
16719 process_arch_specific (file
);
16721 if (program_headers
)
16723 free (program_headers
);
16724 program_headers
= NULL
;
16727 if (section_headers
)
16729 free (section_headers
);
16730 section_headers
= NULL
;
16735 free (string_table
);
16736 string_table
= NULL
;
16737 string_table_length
= 0;
16740 if (dynamic_strings
)
16742 free (dynamic_strings
);
16743 dynamic_strings
= NULL
;
16744 dynamic_strings_length
= 0;
16747 if (dynamic_symbols
)
16749 free (dynamic_symbols
);
16750 dynamic_symbols
= NULL
;
16751 num_dynamic_syms
= 0;
16754 if (dynamic_syminfo
)
16756 free (dynamic_syminfo
);
16757 dynamic_syminfo
= NULL
;
16760 if (dynamic_section
)
16762 free (dynamic_section
);
16763 dynamic_section
= NULL
;
16766 if (section_headers_groups
)
16768 free (section_headers_groups
);
16769 section_headers_groups
= NULL
;
16772 if (section_groups
)
16774 struct group_list
* g
;
16775 struct group_list
* next
;
16777 for (i
= 0; i
< group_count
; i
++)
16779 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16786 free (section_groups
);
16787 section_groups
= NULL
;
16790 free_debug_memory ();
16795 /* Process an ELF archive.
16796 On entry the file is positioned just after the ARMAG string. */
16799 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16801 struct archive_info arch
;
16802 struct archive_info nested_arch
;
16808 /* The ARCH structure is used to hold information about this archive. */
16809 arch
.file_name
= NULL
;
16811 arch
.index_array
= NULL
;
16812 arch
.sym_table
= NULL
;
16813 arch
.longnames
= NULL
;
16815 /* The NESTED_ARCH structure is used as a single-item cache of information
16816 about a nested archive (when members of a thin archive reside within
16817 another regular archive file). */
16818 nested_arch
.file_name
= NULL
;
16819 nested_arch
.file
= NULL
;
16820 nested_arch
.index_array
= NULL
;
16821 nested_arch
.sym_table
= NULL
;
16822 nested_arch
.longnames
= NULL
;
16824 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16830 if (do_archive_index
)
16832 if (arch
.sym_table
== NULL
)
16833 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16836 unsigned long i
, l
;
16837 unsigned long current_pos
;
16839 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16840 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16841 current_pos
= ftell (file
);
16843 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16845 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16847 char * member_name
;
16849 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16851 if (member_name
!= NULL
)
16853 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16855 if (qualified_name
!= NULL
)
16857 printf (_("Contents of binary %s at offset "), qualified_name
);
16858 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16860 free (qualified_name
);
16865 if (l
>= arch
.sym_size
)
16867 error (_("%s: end of the symbol table reached before the end of the index\n"),
16871 /* PR 17531: file: 0b6630b2. */
16872 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16873 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16876 if (arch
.uses_64bit_indicies
)
16881 if (l
< arch
.sym_size
)
16882 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16883 file_name
, arch
.sym_size
- l
);
16885 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16887 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16893 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16894 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16895 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16896 && !do_section_groups
&& !do_dyn_syms
)
16898 ret
= 0; /* Archive index only. */
16909 char * qualified_name
;
16911 /* Read the next archive header. */
16912 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16914 error (_("%s: failed to seek to next archive header\n"), file_name
);
16917 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16918 if (got
!= sizeof arch
.arhdr
)
16922 error (_("%s: failed to read archive header\n"), file_name
);
16926 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16928 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16933 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16935 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16936 if (archive_file_size
& 01)
16937 ++archive_file_size
;
16939 name
= get_archive_member_name (&arch
, &nested_arch
);
16942 error (_("%s: bad archive file name\n"), file_name
);
16946 namelen
= strlen (name
);
16948 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16949 if (qualified_name
== NULL
)
16951 error (_("%s: bad archive file name\n"), file_name
);
16956 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16958 /* This is a proxy for an external member of a thin archive. */
16959 FILE * member_file
;
16960 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16961 if (member_file_name
== NULL
)
16967 member_file
= fopen (member_file_name
, "rb");
16968 if (member_file
== NULL
)
16970 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16971 free (member_file_name
);
16976 archive_file_offset
= arch
.nested_member_origin
;
16978 ret
|= process_object (qualified_name
, member_file
);
16980 fclose (member_file
);
16981 free (member_file_name
);
16983 else if (is_thin_archive
)
16985 /* PR 15140: Allow for corrupt thin archives. */
16986 if (nested_arch
.file
== NULL
)
16988 error (_("%s: contains corrupt thin archive: %s\n"),
16994 /* This is a proxy for a member of a nested archive. */
16995 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16997 /* The nested archive file will have been opened and setup by
16998 get_archive_member_name. */
16999 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17001 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17006 ret
|= process_object (qualified_name
, nested_arch
.file
);
17010 archive_file_offset
= arch
.next_arhdr_offset
;
17011 arch
.next_arhdr_offset
+= archive_file_size
;
17013 ret
|= process_object (qualified_name
, file
);
17016 if (dump_sects
!= NULL
)
17020 num_dump_sects
= 0;
17023 free (qualified_name
);
17027 if (nested_arch
.file
!= NULL
)
17028 fclose (nested_arch
.file
);
17029 release_archive (&nested_arch
);
17030 release_archive (&arch
);
17036 process_file (char * file_name
)
17039 struct stat statbuf
;
17040 char armag
[SARMAG
];
17043 if (stat (file_name
, &statbuf
) < 0)
17045 if (errno
== ENOENT
)
17046 error (_("'%s': No such file\n"), file_name
);
17048 error (_("Could not locate '%s'. System error message: %s\n"),
17049 file_name
, strerror (errno
));
17053 if (! S_ISREG (statbuf
.st_mode
))
17055 error (_("'%s' is not an ordinary file\n"), file_name
);
17059 file
= fopen (file_name
, "rb");
17062 error (_("Input file '%s' is not readable.\n"), file_name
);
17066 if (fread (armag
, SARMAG
, 1, file
) != 1)
17068 error (_("%s: Failed to read file's magic number\n"), file_name
);
17073 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17075 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17076 ret
= process_archive (file_name
, file
, FALSE
);
17077 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17078 ret
= process_archive (file_name
, file
, TRUE
);
17081 if (do_archive_index
)
17082 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17086 archive_file_size
= archive_file_offset
= 0;
17087 ret
= process_object (file_name
, file
);
17092 current_file_size
= 0;
17096 #ifdef SUPPORT_DISASSEMBLY
17097 /* Needed by the i386 disassembler. For extra credit, someone could
17098 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17102 print_address (unsigned int addr
, FILE * outfile
)
17104 fprintf (outfile
,"0x%8.8x", addr
);
17107 /* Needed by the i386 disassembler. */
17109 db_task_printsym (unsigned int addr
)
17111 print_address (addr
, stderr
);
17116 main (int argc
, char ** argv
)
17120 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17121 setlocale (LC_MESSAGES
, "");
17123 #if defined (HAVE_SETLOCALE)
17124 setlocale (LC_CTYPE
, "");
17126 bindtextdomain (PACKAGE
, LOCALEDIR
);
17127 textdomain (PACKAGE
);
17129 expandargv (&argc
, &argv
);
17131 parse_args (argc
, argv
);
17133 if (num_dump_sects
> 0)
17135 /* Make a copy of the dump_sects array. */
17136 cmdline_dump_sects
= (dump_type
*)
17137 malloc (num_dump_sects
* sizeof (* dump_sects
));
17138 if (cmdline_dump_sects
== NULL
)
17139 error (_("Out of memory allocating dump request table.\n"));
17142 memcpy (cmdline_dump_sects
, dump_sects
,
17143 num_dump_sects
* sizeof (* dump_sects
));
17144 num_cmdline_dump_sects
= num_dump_sects
;
17148 if (optind
< (argc
- 1))
17150 else if (optind
>= argc
)
17152 warn (_("Nothing to do.\n"));
17157 while (optind
< argc
)
17158 err
|= process_file (argv
[optind
++]);
17160 if (dump_sects
!= NULL
)
17162 if (cmdline_dump_sects
!= NULL
)
17163 free (cmdline_dump_sects
);