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
;
4773 Elf_Internal_Phdr
* previous_load
= NULL
;
4775 if (elf_header
.e_phnum
== 0)
4777 /* PR binutils/12467. */
4778 if (elf_header
.e_phoff
!= 0)
4779 warn (_("possibly corrupt ELF header - it has a non-zero program"
4780 " header offset, but no program headers\n"));
4781 else if (do_segments
)
4782 printf (_("\nThere are no program headers in this file.\n"));
4786 if (do_segments
&& !do_header
)
4788 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4789 printf (_("Entry point "));
4790 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4791 printf (_("\nThere are %d program headers, starting at offset "),
4792 elf_header
.e_phnum
);
4793 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4797 if (! get_program_headers (file
))
4802 if (elf_header
.e_phnum
> 1)
4803 printf (_("\nProgram Headers:\n"));
4805 printf (_("\nProgram Headers:\n"));
4809 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4812 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4816 (_(" Type Offset VirtAddr PhysAddr\n"));
4818 (_(" FileSiz MemSiz Flags Align\n"));
4825 for (i
= 0, segment
= program_headers
;
4826 i
< elf_header
.e_phnum
;
4831 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4835 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4836 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4837 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4838 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4839 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4841 (segment
->p_flags
& PF_R
? 'R' : ' '),
4842 (segment
->p_flags
& PF_W
? 'W' : ' '),
4843 (segment
->p_flags
& PF_X
? 'E' : ' '));
4844 printf ("%#lx", (unsigned long) segment
->p_align
);
4848 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4849 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4852 print_vma (segment
->p_offset
, FULL_HEX
);
4856 print_vma (segment
->p_vaddr
, FULL_HEX
);
4858 print_vma (segment
->p_paddr
, FULL_HEX
);
4861 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4862 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4865 print_vma (segment
->p_filesz
, FULL_HEX
);
4869 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4870 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4873 print_vma (segment
->p_memsz
, FULL_HEX
);
4877 (segment
->p_flags
& PF_R
? 'R' : ' '),
4878 (segment
->p_flags
& PF_W
? 'W' : ' '),
4879 (segment
->p_flags
& PF_X
? 'E' : ' '));
4881 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4882 printf ("%#lx", (unsigned long) segment
->p_align
);
4885 print_vma (segment
->p_align
, PREFIX_HEX
);
4890 print_vma (segment
->p_offset
, FULL_HEX
);
4892 print_vma (segment
->p_vaddr
, FULL_HEX
);
4894 print_vma (segment
->p_paddr
, FULL_HEX
);
4896 print_vma (segment
->p_filesz
, FULL_HEX
);
4898 print_vma (segment
->p_memsz
, FULL_HEX
);
4900 (segment
->p_flags
& PF_R
? 'R' : ' '),
4901 (segment
->p_flags
& PF_W
? 'W' : ' '),
4902 (segment
->p_flags
& PF_X
? 'E' : ' '));
4903 print_vma (segment
->p_align
, HEX
);
4906 putc ('\n', stdout
);
4909 switch (segment
->p_type
)
4913 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4914 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4915 if (segment
->p_memsz
< segment
->p_filesz
)
4916 error (_("the segment's file size is larger than its memory size\n"));
4917 previous_load
= segment
;
4921 /* PR 20815 - Verify that the program header is loaded into memory. */
4922 if (i
> 0 && previous_load
!= NULL
)
4923 error (_("the PHDR segment must occur before any LOAD segment\n"));
4924 if (elf_header
.e_machine
!= EM_PARISC
)
4928 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4929 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4930 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4931 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4933 if (j
== elf_header
.e_phnum
)
4934 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4940 error (_("more than one dynamic segment\n"));
4942 /* By default, assume that the .dynamic section is the first
4943 section in the DYNAMIC segment. */
4944 dynamic_addr
= segment
->p_offset
;
4945 dynamic_size
= segment
->p_filesz
;
4946 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4947 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4949 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4950 dynamic_addr
= dynamic_size
= 0;
4953 /* Try to locate the .dynamic section. If there is
4954 a section header table, we can easily locate it. */
4955 if (section_headers
!= NULL
)
4957 Elf_Internal_Shdr
* sec
;
4959 sec
= find_section (".dynamic");
4960 if (sec
== NULL
|| sec
->sh_size
== 0)
4962 /* A corresponding .dynamic section is expected, but on
4963 IA-64/OpenVMS it is OK for it to be missing. */
4964 if (!is_ia64_vms ())
4965 error (_("no .dynamic section in the dynamic segment\n"));
4969 if (sec
->sh_type
== SHT_NOBITS
)
4975 dynamic_addr
= sec
->sh_offset
;
4976 dynamic_size
= sec
->sh_size
;
4978 if (dynamic_addr
< segment
->p_offset
4979 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4980 warn (_("the .dynamic section is not contained"
4981 " within the dynamic segment\n"));
4982 else if (dynamic_addr
> segment
->p_offset
)
4983 warn (_("the .dynamic section is not the first section"
4984 " in the dynamic segment.\n"));
4989 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4991 error (_("Unable to find program interpreter name\n"));
4995 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4997 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4998 error (_("Internal error: failed to create format string to display program interpreter\n"));
5000 program_interpreter
[0] = 0;
5001 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5002 error (_("Unable to read program interpreter name\n"));
5005 printf (_(" [Requesting program interpreter: %s]\n"),
5006 program_interpreter
);
5012 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5014 printf (_("\n Section to Segment mapping:\n"));
5015 printf (_(" Segment Sections...\n"));
5017 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5020 Elf_Internal_Shdr
* section
;
5022 segment
= program_headers
+ i
;
5023 section
= section_headers
+ 1;
5025 printf (" %2.2d ", i
);
5027 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5029 if (!ELF_TBSS_SPECIAL (section
, segment
)
5030 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5031 printf ("%s ", printable_section_name (section
));
5042 /* Find the file offset corresponding to VMA by using the program headers. */
5045 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5047 Elf_Internal_Phdr
* seg
;
5049 if (! get_program_headers (file
))
5051 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5055 for (seg
= program_headers
;
5056 seg
< program_headers
+ elf_header
.e_phnum
;
5059 if (seg
->p_type
!= PT_LOAD
)
5062 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5063 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5064 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5067 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5068 (unsigned long) vma
);
5073 /* Allocate memory and load the sections headers into the global pointer
5074 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5075 generate any error messages if the load fails. */
5078 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5080 Elf32_External_Shdr
* shdrs
;
5081 Elf_Internal_Shdr
* internal
;
5083 unsigned int size
= elf_header
.e_shentsize
;
5084 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5086 /* PR binutils/17531: Cope with unexpected section header sizes. */
5087 if (size
== 0 || num
== 0)
5089 if (size
< sizeof * shdrs
)
5092 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5095 if (!probe
&& size
> sizeof * shdrs
)
5096 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5098 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5100 probe
? NULL
: _("section headers"));
5104 if (section_headers
!= NULL
)
5105 free (section_headers
);
5106 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5107 sizeof (Elf_Internal_Shdr
));
5108 if (section_headers
== NULL
)
5111 error (_("Out of memory reading %u section headers\n"), num
);
5115 for (i
= 0, internal
= section_headers
;
5119 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5120 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5121 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5122 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5123 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5124 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5125 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5126 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5127 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5128 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5129 if (!probe
&& internal
->sh_link
> num
)
5130 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5131 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5132 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5140 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5142 Elf64_External_Shdr
* shdrs
;
5143 Elf_Internal_Shdr
* internal
;
5145 unsigned int size
= elf_header
.e_shentsize
;
5146 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5148 /* PR binutils/17531: Cope with unexpected section header sizes. */
5149 if (size
== 0 || num
== 0)
5151 if (size
< sizeof * shdrs
)
5154 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5157 if (! probe
&& size
> sizeof * shdrs
)
5158 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5160 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5162 probe
? NULL
: _("section headers"));
5166 if (section_headers
!= NULL
)
5167 free (section_headers
);
5168 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5169 sizeof (Elf_Internal_Shdr
));
5170 if (section_headers
== NULL
)
5173 error (_("Out of memory reading %u section headers\n"), num
);
5177 for (i
= 0, internal
= section_headers
;
5181 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5182 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5183 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5184 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5185 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5186 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5187 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5188 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5189 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5190 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5191 if (!probe
&& internal
->sh_link
> num
)
5192 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5193 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5194 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5201 static Elf_Internal_Sym
*
5202 get_32bit_elf_symbols (FILE * file
,
5203 Elf_Internal_Shdr
* section
,
5204 unsigned long * num_syms_return
)
5206 unsigned long number
= 0;
5207 Elf32_External_Sym
* esyms
= NULL
;
5208 Elf_External_Sym_Shndx
* shndx
= NULL
;
5209 Elf_Internal_Sym
* isyms
= NULL
;
5210 Elf_Internal_Sym
* psym
;
5213 if (section
->sh_size
== 0)
5215 if (num_syms_return
!= NULL
)
5216 * num_syms_return
= 0;
5220 /* Run some sanity checks first. */
5221 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5223 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5224 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5228 if (section
->sh_size
> current_file_size
)
5230 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5231 printable_section_name (section
), (unsigned long) section
->sh_size
);
5235 number
= section
->sh_size
/ section
->sh_entsize
;
5237 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5239 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5240 (unsigned long) section
->sh_size
,
5241 printable_section_name (section
),
5242 (unsigned long) section
->sh_entsize
);
5246 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5247 section
->sh_size
, _("symbols"));
5252 elf_section_list
* entry
;
5255 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5256 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5258 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5259 entry
->hdr
->sh_offset
,
5260 1, entry
->hdr
->sh_size
,
5261 _("symbol table section indicies"));
5264 /* PR17531: file: heap-buffer-overflow */
5265 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5267 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5268 printable_section_name (entry
->hdr
),
5269 (unsigned long) entry
->hdr
->sh_size
,
5270 (unsigned long) section
->sh_size
);
5276 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5280 error (_("Out of memory reading %lu symbols\n"),
5281 (unsigned long) number
);
5285 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5287 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5288 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5289 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5290 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5291 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5293 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5294 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5295 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5296 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5297 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5306 if (num_syms_return
!= NULL
)
5307 * num_syms_return
= isyms
== NULL
? 0 : number
;
5312 static Elf_Internal_Sym
*
5313 get_64bit_elf_symbols (FILE * file
,
5314 Elf_Internal_Shdr
* section
,
5315 unsigned long * num_syms_return
)
5317 unsigned long number
= 0;
5318 Elf64_External_Sym
* esyms
= NULL
;
5319 Elf_External_Sym_Shndx
* shndx
= NULL
;
5320 Elf_Internal_Sym
* isyms
= NULL
;
5321 Elf_Internal_Sym
* psym
;
5324 if (section
->sh_size
== 0)
5326 if (num_syms_return
!= NULL
)
5327 * num_syms_return
= 0;
5331 /* Run some sanity checks first. */
5332 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5334 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5335 printable_section_name (section
),
5336 (unsigned long) section
->sh_entsize
);
5340 if (section
->sh_size
> current_file_size
)
5342 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5343 printable_section_name (section
),
5344 (unsigned long) section
->sh_size
);
5348 number
= section
->sh_size
/ section
->sh_entsize
;
5350 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5352 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5353 (unsigned long) section
->sh_size
,
5354 printable_section_name (section
),
5355 (unsigned long) section
->sh_entsize
);
5359 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5360 section
->sh_size
, _("symbols"));
5365 elf_section_list
* entry
;
5368 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5369 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5371 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5372 entry
->hdr
->sh_offset
,
5373 1, entry
->hdr
->sh_size
,
5374 _("symbol table section indicies"));
5377 /* PR17531: file: heap-buffer-overflow */
5378 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5380 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5381 printable_section_name (entry
->hdr
),
5382 (unsigned long) entry
->hdr
->sh_size
,
5383 (unsigned long) section
->sh_size
);
5389 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5393 error (_("Out of memory reading %lu symbols\n"),
5394 (unsigned long) number
);
5398 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5400 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5401 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5402 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5403 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5405 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5407 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5408 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5409 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5411 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5412 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5421 if (num_syms_return
!= NULL
)
5422 * num_syms_return
= isyms
== NULL
? 0 : number
;
5428 get_elf_section_flags (bfd_vma sh_flags
)
5430 static char buff
[1024];
5432 int field_size
= is_32bit_elf
? 8 : 16;
5434 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5435 bfd_vma os_flags
= 0;
5436 bfd_vma proc_flags
= 0;
5437 bfd_vma unknown_flags
= 0;
5445 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5446 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5447 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5448 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5449 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5450 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5451 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5452 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5453 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5454 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5455 /* IA-64 specific. */
5456 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5457 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5458 /* IA-64 OpenVMS specific. */
5459 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5460 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5461 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5462 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5463 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5464 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5466 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5467 /* SPARC specific. */
5468 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5469 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5471 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5472 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5473 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5476 if (do_section_details
)
5478 sprintf (buff
, "[%*.*lx]: ",
5479 field_size
, field_size
, (unsigned long) sh_flags
);
5480 p
+= field_size
+ 4;
5487 flag
= sh_flags
& - sh_flags
;
5490 if (do_section_details
)
5494 case SHF_WRITE
: sindex
= 0; break;
5495 case SHF_ALLOC
: sindex
= 1; break;
5496 case SHF_EXECINSTR
: sindex
= 2; break;
5497 case SHF_MERGE
: sindex
= 3; break;
5498 case SHF_STRINGS
: sindex
= 4; break;
5499 case SHF_INFO_LINK
: sindex
= 5; break;
5500 case SHF_LINK_ORDER
: sindex
= 6; break;
5501 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5502 case SHF_GROUP
: sindex
= 8; break;
5503 case SHF_TLS
: sindex
= 9; break;
5504 case SHF_EXCLUDE
: sindex
= 18; break;
5505 case SHF_COMPRESSED
: sindex
= 20; break;
5509 switch (elf_header
.e_machine
)
5512 if (flag
== SHF_IA_64_SHORT
)
5514 else if (flag
== SHF_IA_64_NORECOV
)
5517 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5520 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5521 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5522 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5523 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5524 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5525 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5536 case EM_OLD_SPARCV9
:
5537 case EM_SPARC32PLUS
:
5540 if (flag
== SHF_ORDERED
)
5547 case SHF_ENTRYSECT
: sindex
= 21; break;
5548 case SHF_ARM_PURECODE
: sindex
= 22; break;
5549 case SHF_COMDEF
: sindex
= 23; break;
5561 if (p
!= buff
+ field_size
+ 4)
5563 if (size
< (10 + 2))
5565 warn (_("Internal error: not enough buffer room for section flag info"));
5566 return _("<unknown>");
5573 size
-= flags
[sindex
].len
;
5574 p
= stpcpy (p
, flags
[sindex
].str
);
5576 else if (flag
& SHF_MASKOS
)
5578 else if (flag
& SHF_MASKPROC
)
5581 unknown_flags
|= flag
;
5587 case SHF_WRITE
: *p
= 'W'; break;
5588 case SHF_ALLOC
: *p
= 'A'; break;
5589 case SHF_EXECINSTR
: *p
= 'X'; break;
5590 case SHF_MERGE
: *p
= 'M'; break;
5591 case SHF_STRINGS
: *p
= 'S'; break;
5592 case SHF_INFO_LINK
: *p
= 'I'; break;
5593 case SHF_LINK_ORDER
: *p
= 'L'; break;
5594 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5595 case SHF_GROUP
: *p
= 'G'; break;
5596 case SHF_TLS
: *p
= 'T'; break;
5597 case SHF_EXCLUDE
: *p
= 'E'; break;
5598 case SHF_COMPRESSED
: *p
= 'C'; break;
5601 if ((elf_header
.e_machine
== EM_X86_64
5602 || elf_header
.e_machine
== EM_L1OM
5603 || elf_header
.e_machine
== EM_K1OM
)
5604 && flag
== SHF_X86_64_LARGE
)
5606 else if (elf_header
.e_machine
== EM_ARM
5607 && flag
== SHF_ARM_PURECODE
)
5609 else if (flag
& SHF_MASKOS
)
5612 sh_flags
&= ~ SHF_MASKOS
;
5614 else if (flag
& SHF_MASKPROC
)
5617 sh_flags
&= ~ SHF_MASKPROC
;
5627 if (do_section_details
)
5631 size
-= 5 + field_size
;
5632 if (p
!= buff
+ field_size
+ 4)
5636 warn (_("Internal error: not enough buffer room for section flag info"));
5637 return _("<unknown>");
5643 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5644 (unsigned long) os_flags
);
5645 p
+= 5 + field_size
;
5649 size
-= 7 + field_size
;
5650 if (p
!= buff
+ field_size
+ 4)
5654 warn (_("Internal error: not enough buffer room for section flag info"));
5655 return _("<unknown>");
5661 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5662 (unsigned long) proc_flags
);
5663 p
+= 7 + field_size
;
5667 size
-= 10 + field_size
;
5668 if (p
!= buff
+ field_size
+ 4)
5672 warn (_("Internal error: not enough buffer room for section flag info"));
5673 return _("<unknown>");
5679 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5680 (unsigned long) unknown_flags
);
5681 p
+= 10 + field_size
;
5690 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5694 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5696 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5697 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5698 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5699 return sizeof (*echdr
);
5703 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5705 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5706 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5707 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5708 return sizeof (*echdr
);
5713 process_section_headers (FILE * file
)
5715 Elf_Internal_Shdr
* section
;
5718 section_headers
= NULL
;
5720 if (elf_header
.e_shnum
== 0)
5722 /* PR binutils/12467. */
5723 if (elf_header
.e_shoff
!= 0)
5724 warn (_("possibly corrupt ELF file header - it has a non-zero"
5725 " section header offset, but no section headers\n"));
5726 else if (do_sections
)
5727 printf (_("\nThere are no sections in this file.\n"));
5732 if (do_sections
&& !do_header
)
5733 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5734 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5738 if (! get_32bit_section_headers (file
, FALSE
))
5741 else if (! get_64bit_section_headers (file
, FALSE
))
5744 /* Read in the string table, so that we have names to display. */
5745 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5746 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5748 section
= section_headers
+ elf_header
.e_shstrndx
;
5750 if (section
->sh_size
!= 0)
5752 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5753 1, section
->sh_size
,
5756 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5760 /* Scan the sections for the dynamic symbol table
5761 and dynamic string table and debug sections. */
5762 dynamic_symbols
= NULL
;
5763 dynamic_strings
= NULL
;
5764 dynamic_syminfo
= NULL
;
5765 symtab_shndx_list
= NULL
;
5767 eh_addr_size
= is_32bit_elf
? 4 : 8;
5768 switch (elf_header
.e_machine
)
5771 case EM_MIPS_RS3_LE
:
5772 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5773 FDE addresses. However, the ABI also has a semi-official ILP32
5774 variant for which the normal FDE address size rules apply.
5776 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5777 section, where XX is the size of longs in bits. Unfortunately,
5778 earlier compilers provided no way of distinguishing ILP32 objects
5779 from LP64 objects, so if there's any doubt, we should assume that
5780 the official LP64 form is being used. */
5781 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5782 && find_section (".gcc_compiled_long32") == NULL
)
5788 switch (elf_header
.e_flags
& EF_H8_MACH
)
5790 case E_H8_MACH_H8300
:
5791 case E_H8_MACH_H8300HN
:
5792 case E_H8_MACH_H8300SN
:
5793 case E_H8_MACH_H8300SXN
:
5796 case E_H8_MACH_H8300H
:
5797 case E_H8_MACH_H8300S
:
5798 case E_H8_MACH_H8300SX
:
5806 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5808 case EF_M32C_CPU_M16C
:
5815 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5818 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5819 if (section->sh_entsize != expected_entsize) \
5822 sprintf_vma (buf, section->sh_entsize); \
5823 /* Note: coded this way so that there is a single string for \
5825 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5826 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5827 (unsigned) expected_entsize); \
5828 section->sh_entsize = expected_entsize; \
5833 #define CHECK_ENTSIZE(section, i, type) \
5834 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5835 sizeof (Elf64_External_##type))
5837 for (i
= 0, section
= section_headers
;
5838 i
< elf_header
.e_shnum
;
5841 char * name
= SECTION_NAME (section
);
5843 if (section
->sh_type
== SHT_DYNSYM
)
5845 if (dynamic_symbols
!= NULL
)
5847 error (_("File contains multiple dynamic symbol tables\n"));
5851 CHECK_ENTSIZE (section
, i
, Sym
);
5852 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5854 else if (section
->sh_type
== SHT_STRTAB
5855 && streq (name
, ".dynstr"))
5857 if (dynamic_strings
!= NULL
)
5859 error (_("File contains multiple dynamic string tables\n"));
5863 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5864 1, section
->sh_size
,
5865 _("dynamic strings"));
5866 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5868 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5870 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5871 entry
->hdr
= section
;
5872 entry
->next
= symtab_shndx_list
;
5873 symtab_shndx_list
= entry
;
5875 else if (section
->sh_type
== SHT_SYMTAB
)
5876 CHECK_ENTSIZE (section
, i
, Sym
);
5877 else if (section
->sh_type
== SHT_GROUP
)
5878 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5879 else if (section
->sh_type
== SHT_REL
)
5880 CHECK_ENTSIZE (section
, i
, Rel
);
5881 else if (section
->sh_type
== SHT_RELA
)
5882 CHECK_ENTSIZE (section
, i
, Rela
);
5883 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5884 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5885 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5886 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5887 || do_debug_addr
|| do_debug_cu_index
)
5888 && (const_strneq (name
, ".debug_")
5889 || const_strneq (name
, ".zdebug_")))
5892 name
+= sizeof (".zdebug_") - 1;
5894 name
+= sizeof (".debug_") - 1;
5897 || (do_debug_info
&& const_strneq (name
, "info"))
5898 || (do_debug_info
&& const_strneq (name
, "types"))
5899 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5900 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5901 || (do_debug_lines
&& const_strneq (name
, "line."))
5902 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5903 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5904 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5905 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5906 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5907 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5908 || (do_debug_frames
&& const_strneq (name
, "frame"))
5909 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5910 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5911 || (do_debug_str
&& const_strneq (name
, "str"))
5912 || (do_debug_loc
&& const_strneq (name
, "loc"))
5913 || (do_debug_addr
&& const_strneq (name
, "addr"))
5914 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5915 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5917 request_dump_bynumber (i
, DEBUG_DUMP
);
5919 /* Linkonce section to be combined with .debug_info at link time. */
5920 else if ((do_debugging
|| do_debug_info
)
5921 && const_strneq (name
, ".gnu.linkonce.wi."))
5922 request_dump_bynumber (i
, DEBUG_DUMP
);
5923 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5924 request_dump_bynumber (i
, DEBUG_DUMP
);
5925 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5926 request_dump_bynumber (i
, DEBUG_DUMP
);
5927 /* Trace sections for Itanium VMS. */
5928 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5929 || do_trace_aranges
)
5930 && const_strneq (name
, ".trace_"))
5932 name
+= sizeof (".trace_") - 1;
5935 || (do_trace_info
&& streq (name
, "info"))
5936 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5937 || (do_trace_aranges
&& streq (name
, "aranges"))
5939 request_dump_bynumber (i
, DEBUG_DUMP
);
5946 if (elf_header
.e_shnum
> 1)
5947 printf (_("\nSection Headers:\n"));
5949 printf (_("\nSection Header:\n"));
5953 if (do_section_details
)
5955 printf (_(" [Nr] Name\n"));
5956 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5960 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5964 if (do_section_details
)
5966 printf (_(" [Nr] Name\n"));
5967 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5971 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5975 if (do_section_details
)
5977 printf (_(" [Nr] Name\n"));
5978 printf (_(" Type Address Offset Link\n"));
5979 printf (_(" Size EntSize Info Align\n"));
5983 printf (_(" [Nr] Name Type Address Offset\n"));
5984 printf (_(" Size EntSize Flags Link Info Align\n"));
5988 if (do_section_details
)
5989 printf (_(" Flags\n"));
5991 for (i
= 0, section
= section_headers
;
5992 i
< elf_header
.e_shnum
;
5995 /* Run some sanity checks on the section header. */
5997 /* Check the sh_link field. */
5998 switch (section
->sh_type
)
6000 case SHT_SYMTAB_SHNDX
:
6004 case SHT_GNU_versym
:
6007 if (section
->sh_link
< 1
6008 || section
->sh_link
>= elf_header
.e_shnum
6009 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6010 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6011 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6012 i
, section
->sh_link
);
6018 case SHT_GNU_verneed
:
6019 case SHT_GNU_verdef
:
6020 case SHT_GNU_LIBLIST
:
6021 if (section
->sh_link
< 1
6022 || section
->sh_link
>= elf_header
.e_shnum
6023 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6024 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6025 i
, section
->sh_link
);
6028 case SHT_INIT_ARRAY
:
6029 case SHT_FINI_ARRAY
:
6030 case SHT_PREINIT_ARRAY
:
6031 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6032 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6033 i
, section
->sh_link
);
6037 /* FIXME: Add support for target specific section types. */
6038 #if 0 /* Currently we do not check other section types as there are too
6039 many special cases. Stab sections for example have a type
6040 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6042 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6043 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6044 i
, section
->sh_link
);
6049 /* Check the sh_info field. */
6050 switch (section
->sh_type
)
6054 if (section
->sh_info
< 1
6055 || section
->sh_info
>= elf_header
.e_shnum
6056 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6057 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6058 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6059 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6060 /* FIXME: Are other section types valid ? */
6061 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6063 if (section
->sh_info
== 0
6064 && (streq (SECTION_NAME (section
), ".rel.dyn")
6065 || streq (SECTION_NAME (section
), ".rela.dyn")))
6066 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6067 of zero. No idea why. I would have expected the index
6068 of the .plt section. */
6071 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6072 i
, section
->sh_info
);
6078 case SHT_SYMTAB_SHNDX
:
6079 case SHT_INIT_ARRAY
:
6080 case SHT_FINI_ARRAY
:
6081 case SHT_PREINIT_ARRAY
:
6082 if (section
->sh_info
!= 0)
6083 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6084 i
, section
->sh_info
);
6090 /* A symbol index - we assume that it is valid. */
6094 /* FIXME: Add support for target specific section types. */
6095 if (section
->sh_type
== SHT_NOBITS
)
6096 /* NOBITS section headers with non-zero sh_info fields can be
6097 created when a binary is stripped of everything but its debug
6098 information. The stripped sections have their headers
6099 preserved but their types set to SHT_NOBITS. So do not check
6100 this type of section. */
6102 else if (section
->sh_flags
& SHF_INFO_LINK
)
6104 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6105 warn (_("[%2u]: Expected link to another section in info field"), i
);
6107 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6108 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6109 i
, section
->sh_info
);
6113 printf (" [%2u] ", i
);
6114 if (do_section_details
)
6115 printf ("%s\n ", printable_section_name (section
));
6117 print_symbol (-17, SECTION_NAME (section
));
6119 printf (do_wide
? " %-15s " : " %-15.15s ",
6120 get_section_type_name (section
->sh_type
));
6124 const char * link_too_big
= NULL
;
6126 print_vma (section
->sh_addr
, LONG_HEX
);
6128 printf ( " %6.6lx %6.6lx %2.2lx",
6129 (unsigned long) section
->sh_offset
,
6130 (unsigned long) section
->sh_size
,
6131 (unsigned long) section
->sh_entsize
);
6133 if (do_section_details
)
6134 fputs (" ", stdout
);
6136 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6138 if (section
->sh_link
>= elf_header
.e_shnum
)
6141 /* The sh_link value is out of range. Normally this indicates
6142 an error but it can have special values in Solaris binaries. */
6143 switch (elf_header
.e_machine
)
6150 case EM_OLD_SPARCV9
:
6151 case EM_SPARC32PLUS
:
6154 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6155 link_too_big
= "BEFORE";
6156 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6157 link_too_big
= "AFTER";
6164 if (do_section_details
)
6166 if (link_too_big
!= NULL
&& * link_too_big
)
6167 printf ("<%s> ", link_too_big
);
6169 printf ("%2u ", section
->sh_link
);
6170 printf ("%3u %2lu\n", section
->sh_info
,
6171 (unsigned long) section
->sh_addralign
);
6174 printf ("%2u %3u %2lu\n",
6177 (unsigned long) section
->sh_addralign
);
6179 if (link_too_big
&& ! * link_too_big
)
6180 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6181 i
, section
->sh_link
);
6185 print_vma (section
->sh_addr
, LONG_HEX
);
6187 if ((long) section
->sh_offset
== section
->sh_offset
)
6188 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6192 print_vma (section
->sh_offset
, LONG_HEX
);
6195 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6196 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6200 print_vma (section
->sh_size
, LONG_HEX
);
6203 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6204 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6208 print_vma (section
->sh_entsize
, LONG_HEX
);
6211 if (do_section_details
)
6212 fputs (" ", stdout
);
6214 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6216 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6218 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6219 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6222 print_vma (section
->sh_addralign
, DEC
);
6226 else if (do_section_details
)
6228 printf (" %-15.15s ",
6229 get_section_type_name (section
->sh_type
));
6230 print_vma (section
->sh_addr
, LONG_HEX
);
6231 if ((long) section
->sh_offset
== section
->sh_offset
)
6232 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6236 print_vma (section
->sh_offset
, LONG_HEX
);
6238 printf (" %u\n ", section
->sh_link
);
6239 print_vma (section
->sh_size
, LONG_HEX
);
6241 print_vma (section
->sh_entsize
, LONG_HEX
);
6243 printf (" %-16u %lu\n",
6245 (unsigned long) section
->sh_addralign
);
6250 print_vma (section
->sh_addr
, LONG_HEX
);
6251 if ((long) section
->sh_offset
== section
->sh_offset
)
6252 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6256 print_vma (section
->sh_offset
, LONG_HEX
);
6259 print_vma (section
->sh_size
, LONG_HEX
);
6261 print_vma (section
->sh_entsize
, LONG_HEX
);
6263 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6265 printf (" %2u %3u %lu\n",
6268 (unsigned long) section
->sh_addralign
);
6271 if (do_section_details
)
6273 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6274 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6276 /* Minimum section size is 12 bytes for 32-bit compression
6277 header + 12 bytes for compressed data header. */
6278 unsigned char buf
[24];
6280 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6281 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6282 sizeof (buf
), _("compression header")))
6284 Elf_Internal_Chdr chdr
;
6286 (void) get_compression_header (&chdr
, buf
);
6288 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6291 printf (_(" [<unknown>: 0x%x], "),
6293 print_vma (chdr
.ch_size
, LONG_HEX
);
6294 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6300 if (!do_section_details
)
6302 /* The ordering of the letters shown here matches the ordering of the
6303 corresponding SHF_xxx values, and hence the order in which these
6304 letters will be displayed to the user. */
6305 printf (_("Key to Flags:\n\
6306 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6307 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6308 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6309 if (elf_header
.e_machine
== EM_X86_64
6310 || elf_header
.e_machine
== EM_L1OM
6311 || elf_header
.e_machine
== EM_K1OM
)
6312 printf (_("l (large), "));
6313 else if (elf_header
.e_machine
== EM_ARM
)
6314 printf (_("y (purecode), "));
6315 printf ("p (processor specific)\n");
6322 get_group_flags (unsigned int flags
)
6324 static char buff
[128];
6328 else if (flags
== GRP_COMDAT
)
6331 snprintf (buff
, 14, _("[0x%x: "), flags
);
6333 flags
&= ~ GRP_COMDAT
;
6334 if (flags
& GRP_MASKOS
)
6336 strcat (buff
, "<OS specific>");
6337 flags
&= ~ GRP_MASKOS
;
6340 if (flags
& GRP_MASKPROC
)
6342 strcat (buff
, "<PROC specific>");
6343 flags
&= ~ GRP_MASKPROC
;
6347 strcat (buff
, "<unknown>");
6354 process_section_groups (FILE * file
)
6356 Elf_Internal_Shdr
* section
;
6358 struct group
* group
;
6359 Elf_Internal_Shdr
* symtab_sec
;
6360 Elf_Internal_Shdr
* strtab_sec
;
6361 Elf_Internal_Sym
* symtab
;
6362 unsigned long num_syms
;
6366 /* Don't process section groups unless needed. */
6367 if (!do_unwind
&& !do_section_groups
)
6370 if (elf_header
.e_shnum
== 0)
6372 if (do_section_groups
)
6373 printf (_("\nThere are no sections to group in this file.\n"));
6378 if (section_headers
== NULL
)
6380 error (_("Section headers are not available!\n"));
6381 /* PR 13622: This can happen with a corrupt ELF header. */
6385 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6386 sizeof (struct group
*));
6388 if (section_headers_groups
== NULL
)
6390 error (_("Out of memory reading %u section group headers\n"),
6391 elf_header
.e_shnum
);
6395 /* Scan the sections for the group section. */
6397 for (i
= 0, section
= section_headers
;
6398 i
< elf_header
.e_shnum
;
6400 if (section
->sh_type
== SHT_GROUP
)
6403 if (group_count
== 0)
6405 if (do_section_groups
)
6406 printf (_("\nThere are no section groups in this file.\n"));
6411 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6413 if (section_groups
== NULL
)
6415 error (_("Out of memory reading %lu groups\n"),
6416 (unsigned long) group_count
);
6426 for (i
= 0, section
= section_headers
, group
= section_groups
;
6427 i
< elf_header
.e_shnum
;
6430 if (section
->sh_type
== SHT_GROUP
)
6432 const char * name
= printable_section_name (section
);
6433 const char * group_name
;
6434 unsigned char * start
;
6435 unsigned char * indices
;
6436 unsigned int entry
, j
, size
;
6437 Elf_Internal_Shdr
* sec
;
6438 Elf_Internal_Sym
* sym
;
6440 /* Get the symbol table. */
6441 if (section
->sh_link
>= elf_header
.e_shnum
6442 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6445 error (_("Bad sh_link in group section `%s'\n"), name
);
6449 if (symtab_sec
!= sec
)
6454 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6459 error (_("Corrupt header in group section `%s'\n"), name
);
6463 if (section
->sh_info
>= num_syms
)
6465 error (_("Bad sh_info in group section `%s'\n"), name
);
6469 sym
= symtab
+ section
->sh_info
;
6471 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6473 if (sym
->st_shndx
== 0
6474 || sym
->st_shndx
>= elf_header
.e_shnum
)
6476 error (_("Bad sh_info in group section `%s'\n"), name
);
6480 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6489 /* Get the string table. */
6490 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6499 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6505 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6506 1, strtab_sec
->sh_size
,
6508 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6510 group_name
= sym
->st_name
< strtab_size
6511 ? strtab
+ sym
->st_name
: _("<corrupt>");
6514 /* PR 17531: file: loop. */
6515 if (section
->sh_entsize
> section
->sh_size
)
6517 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6518 printable_section_name (section
),
6519 (unsigned long) section
->sh_entsize
,
6520 (unsigned long) section
->sh_size
);
6524 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6525 1, section
->sh_size
,
6531 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6532 entry
= byte_get (indices
, 4);
6535 if (do_section_groups
)
6537 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6538 get_group_flags (entry
), i
, name
, group_name
, size
);
6540 printf (_(" [Index] Name\n"));
6543 group
->group_index
= i
;
6545 for (j
= 0; j
< size
; j
++)
6547 struct group_list
* g
;
6549 entry
= byte_get (indices
, 4);
6552 if (entry
>= elf_header
.e_shnum
)
6554 static unsigned num_group_errors
= 0;
6556 if (num_group_errors
++ < 10)
6558 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6559 entry
, i
, elf_header
.e_shnum
- 1);
6560 if (num_group_errors
== 10)
6561 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6566 if (section_headers_groups
[entry
] != NULL
)
6570 static unsigned num_errs
= 0;
6572 if (num_errs
++ < 10)
6574 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6576 section_headers_groups
[entry
]->group_index
);
6578 warn (_("Further error messages about already contained group sections suppressed\n"));
6584 /* Intel C/C++ compiler may put section 0 in a
6585 section group. We just warn it the first time
6586 and ignore it afterwards. */
6587 static int warned
= 0;
6590 error (_("section 0 in group section [%5u]\n"),
6591 section_headers_groups
[entry
]->group_index
);
6597 section_headers_groups
[entry
] = group
;
6599 if (do_section_groups
)
6601 sec
= section_headers
+ entry
;
6602 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6605 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6606 g
->section_index
= entry
;
6607 g
->next
= group
->root
;
6625 /* Data used to display dynamic fixups. */
6627 struct ia64_vms_dynfixup
6629 bfd_vma needed_ident
; /* Library ident number. */
6630 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6631 bfd_vma fixup_needed
; /* Index of the library. */
6632 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6633 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6636 /* Data used to display dynamic relocations. */
6638 struct ia64_vms_dynimgrela
6640 bfd_vma img_rela_cnt
; /* Number of relocations. */
6641 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6644 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6648 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6649 const char *strtab
, unsigned int strtab_sz
)
6651 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6653 const char *lib_name
;
6655 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6656 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6657 _("dynamic section image fixups"));
6661 if (fixup
->needed
< strtab_sz
)
6662 lib_name
= strtab
+ fixup
->needed
;
6665 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6666 (unsigned long) fixup
->needed
);
6669 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6670 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6672 (_("Seg Offset Type SymVec DataType\n"));
6674 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6679 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6680 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6681 type
= BYTE_GET (imfs
[i
].type
);
6682 rtype
= elf_ia64_reloc_type (type
);
6684 printf (" 0x%08x ", type
);
6686 printf (" %-32s ", rtype
);
6687 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6688 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6694 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6697 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6699 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6702 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6703 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6704 _("dynamic section image relocations"));
6708 printf (_("\nImage relocs\n"));
6710 (_("Seg Offset Type Addend Seg Sym Off\n"));
6712 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6717 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6718 printf ("%08" BFD_VMA_FMT
"x ",
6719 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6720 type
= BYTE_GET (imrs
[i
].type
);
6721 rtype
= elf_ia64_reloc_type (type
);
6723 printf ("0x%08x ", type
);
6725 printf ("%-31s ", rtype
);
6726 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6727 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6728 printf ("%08" BFD_VMA_FMT
"x\n",
6729 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6735 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6738 process_ia64_vms_dynamic_relocs (FILE *file
)
6740 struct ia64_vms_dynfixup fixup
;
6741 struct ia64_vms_dynimgrela imgrela
;
6742 Elf_Internal_Dyn
*entry
;
6744 bfd_vma strtab_off
= 0;
6745 bfd_vma strtab_sz
= 0;
6746 char *strtab
= NULL
;
6748 memset (&fixup
, 0, sizeof (fixup
));
6749 memset (&imgrela
, 0, sizeof (imgrela
));
6751 /* Note: the order of the entries is specified by the OpenVMS specs. */
6752 for (entry
= dynamic_section
;
6753 entry
< dynamic_section
+ dynamic_nent
;
6756 switch (entry
->d_tag
)
6758 case DT_IA_64_VMS_STRTAB_OFFSET
:
6759 strtab_off
= entry
->d_un
.d_val
;
6762 strtab_sz
= entry
->d_un
.d_val
;
6764 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6765 1, strtab_sz
, _("dynamic string section"));
6768 case DT_IA_64_VMS_NEEDED_IDENT
:
6769 fixup
.needed_ident
= entry
->d_un
.d_val
;
6772 fixup
.needed
= entry
->d_un
.d_val
;
6774 case DT_IA_64_VMS_FIXUP_NEEDED
:
6775 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6777 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6778 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6780 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6781 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6783 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6786 case DT_IA_64_VMS_IMG_RELA_CNT
:
6787 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6789 case DT_IA_64_VMS_IMG_RELA_OFF
:
6790 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6792 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6812 } dynamic_relocations
[] =
6814 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6815 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6816 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6819 /* Process the reloc section. */
6822 process_relocs (FILE * file
)
6824 unsigned long rel_size
;
6825 unsigned long rel_offset
;
6831 if (do_using_dynamic
)
6835 int has_dynamic_reloc
;
6838 has_dynamic_reloc
= 0;
6840 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6842 is_rela
= dynamic_relocations
[i
].rela
;
6843 name
= dynamic_relocations
[i
].name
;
6844 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6845 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6847 has_dynamic_reloc
|= rel_size
;
6849 if (is_rela
== UNKNOWN
)
6851 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6852 switch (dynamic_info
[DT_PLTREL
])
6866 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6867 name
, rel_offset
, rel_size
);
6869 dump_relocations (file
,
6870 offset_from_vma (file
, rel_offset
, rel_size
),
6872 dynamic_symbols
, num_dynamic_syms
,
6873 dynamic_strings
, dynamic_strings_length
,
6879 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6881 if (! has_dynamic_reloc
)
6882 printf (_("\nThere are no dynamic relocations in this file.\n"));
6886 Elf_Internal_Shdr
* section
;
6890 for (i
= 0, section
= section_headers
;
6891 i
< elf_header
.e_shnum
;
6894 if ( section
->sh_type
!= SHT_RELA
6895 && section
->sh_type
!= SHT_REL
)
6898 rel_offset
= section
->sh_offset
;
6899 rel_size
= section
->sh_size
;
6903 Elf_Internal_Shdr
* strsec
;
6906 printf (_("\nRelocation section "));
6908 if (string_table
== NULL
)
6909 printf ("%d", section
->sh_name
);
6911 printf ("'%s'", printable_section_name (section
));
6913 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6914 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6916 is_rela
= section
->sh_type
== SHT_RELA
;
6918 if (section
->sh_link
!= 0
6919 && section
->sh_link
< elf_header
.e_shnum
)
6921 Elf_Internal_Shdr
* symsec
;
6922 Elf_Internal_Sym
* symtab
;
6923 unsigned long nsyms
;
6924 unsigned long strtablen
= 0;
6925 char * strtab
= NULL
;
6927 symsec
= section_headers
+ section
->sh_link
;
6928 if (symsec
->sh_type
!= SHT_SYMTAB
6929 && symsec
->sh_type
!= SHT_DYNSYM
)
6932 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6937 if (symsec
->sh_link
!= 0
6938 && symsec
->sh_link
< elf_header
.e_shnum
)
6940 strsec
= section_headers
+ symsec
->sh_link
;
6942 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6945 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6948 dump_relocations (file
, rel_offset
, rel_size
,
6949 symtab
, nsyms
, strtab
, strtablen
,
6951 symsec
->sh_type
== SHT_DYNSYM
);
6957 dump_relocations (file
, rel_offset
, rel_size
,
6958 NULL
, 0, NULL
, 0, is_rela
, 0);
6965 printf (_("\nThere are no relocations in this file.\n"));
6971 /* An absolute address consists of a section and an offset. If the
6972 section is NULL, the offset itself is the address, otherwise, the
6973 address equals to LOAD_ADDRESS(section) + offset. */
6977 unsigned short section
;
6981 #define ABSADDR(a) \
6983 ? section_headers [(a).section].sh_addr + (a).offset \
6986 /* Find the nearest symbol at or below ADDR. Returns the symbol
6987 name, if found, and the offset from the symbol to ADDR. */
6990 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6991 unsigned long nsyms
,
6992 const char * strtab
,
6993 unsigned long strtab_size
,
6994 struct absaddr addr
,
6995 const char ** symname
,
6998 bfd_vma dist
= 0x100000;
6999 Elf_Internal_Sym
* sym
;
7000 Elf_Internal_Sym
* beg
;
7001 Elf_Internal_Sym
* end
;
7002 Elf_Internal_Sym
* best
= NULL
;
7004 REMOVE_ARCH_BITS (addr
.offset
);
7006 end
= symtab
+ nsyms
;
7012 sym
= beg
+ (end
- beg
) / 2;
7014 value
= sym
->st_value
;
7015 REMOVE_ARCH_BITS (value
);
7017 if (sym
->st_name
!= 0
7018 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7019 && addr
.offset
>= value
7020 && addr
.offset
- value
< dist
)
7023 dist
= addr
.offset
- value
;
7028 if (addr
.offset
< value
)
7036 *symname
= (best
->st_name
>= strtab_size
7037 ? _("<corrupt>") : strtab
+ best
->st_name
);
7043 *offset
= addr
.offset
;
7047 symcmp (const void *p
, const void *q
)
7049 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7050 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7052 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7055 /* Process the unwind section. */
7057 #include "unwind-ia64.h"
7059 struct ia64_unw_table_entry
7061 struct absaddr start
;
7063 struct absaddr info
;
7066 struct ia64_unw_aux_info
7068 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7069 unsigned long table_len
; /* Length of unwind table. */
7070 unsigned char * info
; /* Unwind info. */
7071 unsigned long info_size
; /* Size of unwind info. */
7072 bfd_vma info_addr
; /* Starting address of unwind info. */
7073 bfd_vma seg_base
; /* Starting address of segment. */
7074 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7075 unsigned long nsyms
; /* Number of symbols. */
7076 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7077 unsigned long nfuns
; /* Number of entries in funtab. */
7078 char * strtab
; /* The string table. */
7079 unsigned long strtab_size
; /* Size of string table. */
7083 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7085 struct ia64_unw_table_entry
* tp
;
7086 unsigned long j
, nfuns
;
7089 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7090 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7091 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7092 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7094 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7096 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7100 const unsigned char * dp
;
7101 const unsigned char * head
;
7102 const unsigned char * end
;
7103 const char * procname
;
7105 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7106 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7108 fputs ("\n<", stdout
);
7112 fputs (procname
, stdout
);
7115 printf ("+%lx", (unsigned long) offset
);
7118 fputs (">: [", stdout
);
7119 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7120 fputc ('-', stdout
);
7121 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7122 printf ("], info at +0x%lx\n",
7123 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7125 /* PR 17531: file: 86232b32. */
7126 if (aux
->info
== NULL
)
7129 /* PR 17531: file: 0997b4d1. */
7130 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7132 warn (_("Invalid offset %lx in table entry %ld\n"),
7133 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7137 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7138 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7140 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7141 (unsigned) UNW_VER (stamp
),
7142 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7143 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7144 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7145 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7147 if (UNW_VER (stamp
) != 1)
7149 printf (_("\tUnknown version.\n"));
7154 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7155 /* PR 17531: file: 16ceda89. */
7156 if (end
> aux
->info
+ aux
->info_size
)
7157 end
= aux
->info
+ aux
->info_size
;
7158 for (dp
= head
+ 8; dp
< end
;)
7159 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7166 slurp_ia64_unwind_table (FILE * file
,
7167 struct ia64_unw_aux_info
* aux
,
7168 Elf_Internal_Shdr
* sec
)
7170 unsigned long size
, nrelas
, i
;
7171 Elf_Internal_Phdr
* seg
;
7172 struct ia64_unw_table_entry
* tep
;
7173 Elf_Internal_Shdr
* relsec
;
7174 Elf_Internal_Rela
* rela
;
7175 Elf_Internal_Rela
* rp
;
7176 unsigned char * table
;
7178 Elf_Internal_Sym
* sym
;
7179 const char * relname
;
7183 /* First, find the starting address of the segment that includes
7186 if (elf_header
.e_phnum
)
7188 if (! get_program_headers (file
))
7191 for (seg
= program_headers
;
7192 seg
< program_headers
+ elf_header
.e_phnum
;
7195 if (seg
->p_type
!= PT_LOAD
)
7198 if (sec
->sh_addr
>= seg
->p_vaddr
7199 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7201 aux
->seg_base
= seg
->p_vaddr
;
7207 /* Second, build the unwind table from the contents of the unwind section: */
7208 size
= sec
->sh_size
;
7209 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7214 aux
->table_len
= size
/ (3 * eh_addr_size
);
7215 aux
->table
= (struct ia64_unw_table_entry
*)
7216 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7219 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7221 tep
->start
.section
= SHN_UNDEF
;
7222 tep
->end
.section
= SHN_UNDEF
;
7223 tep
->info
.section
= SHN_UNDEF
;
7224 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7225 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7226 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7227 tep
->start
.offset
+= aux
->seg_base
;
7228 tep
->end
.offset
+= aux
->seg_base
;
7229 tep
->info
.offset
+= aux
->seg_base
;
7233 /* Third, apply any relocations to the unwind table: */
7234 for (relsec
= section_headers
;
7235 relsec
< section_headers
+ elf_header
.e_shnum
;
7238 if (relsec
->sh_type
!= SHT_RELA
7239 || relsec
->sh_info
>= elf_header
.e_shnum
7240 || section_headers
+ relsec
->sh_info
!= sec
)
7243 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7252 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7254 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7255 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7257 /* PR 17531: file: 9fa67536. */
7258 if (relname
== NULL
)
7260 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7264 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7266 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7270 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7272 /* PR 17531: file: 5bc8d9bf. */
7273 if (i
>= aux
->table_len
)
7275 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7279 switch (rp
->r_offset
/ eh_addr_size
% 3)
7282 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7283 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7286 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7287 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7290 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7291 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7305 ia64_process_unwind (FILE * file
)
7307 Elf_Internal_Shdr
* sec
;
7308 Elf_Internal_Shdr
* unwsec
= NULL
;
7309 Elf_Internal_Shdr
* strsec
;
7310 unsigned long i
, unwcount
= 0, unwstart
= 0;
7311 struct ia64_unw_aux_info aux
;
7313 memset (& aux
, 0, sizeof (aux
));
7315 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7317 if (sec
->sh_type
== SHT_SYMTAB
7318 && sec
->sh_link
< elf_header
.e_shnum
)
7320 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7322 strsec
= section_headers
+ sec
->sh_link
;
7323 if (aux
.strtab
!= NULL
)
7325 error (_("Multiple auxillary string tables encountered\n"));
7328 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7331 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7333 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7338 printf (_("\nThere are no unwind sections in this file.\n"));
7340 while (unwcount
-- > 0)
7345 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7346 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7347 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7352 /* We have already counted the number of SHT_IA64_UNWIND
7353 sections so the loop above should never fail. */
7354 assert (unwsec
!= NULL
);
7357 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7359 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7361 /* We need to find which section group it is in. */
7362 struct group_list
* g
;
7364 if (section_headers_groups
== NULL
7365 || section_headers_groups
[i
] == NULL
)
7366 i
= elf_header
.e_shnum
;
7369 g
= section_headers_groups
[i
]->root
;
7371 for (; g
!= NULL
; g
= g
->next
)
7373 sec
= section_headers
+ g
->section_index
;
7375 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7380 i
= elf_header
.e_shnum
;
7383 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7385 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7386 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7387 suffix
= SECTION_NAME (unwsec
) + len
;
7388 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7390 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7391 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7396 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7397 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7398 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7399 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7401 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7402 suffix
= SECTION_NAME (unwsec
) + len
;
7403 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7405 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7406 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7410 if (i
== elf_header
.e_shnum
)
7412 printf (_("\nCould not find unwind info section for "));
7414 if (string_table
== NULL
)
7415 printf ("%d", unwsec
->sh_name
);
7417 printf ("'%s'", printable_section_name (unwsec
));
7421 aux
.info_addr
= sec
->sh_addr
;
7422 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7425 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7427 printf (_("\nUnwind section "));
7429 if (string_table
== NULL
)
7430 printf ("%d", unwsec
->sh_name
);
7432 printf ("'%s'", printable_section_name (unwsec
));
7434 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7435 (unsigned long) unwsec
->sh_offset
,
7436 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7438 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7439 && aux
.table_len
> 0)
7440 dump_ia64_unwind (& aux
);
7443 free ((char *) aux
.table
);
7445 free ((char *) aux
.info
);
7454 free ((char *) aux
.strtab
);
7457 struct hppa_unw_table_entry
7459 struct absaddr start
;
7461 unsigned int Cannot_unwind
:1; /* 0 */
7462 unsigned int Millicode
:1; /* 1 */
7463 unsigned int Millicode_save_sr0
:1; /* 2 */
7464 unsigned int Region_description
:2; /* 3..4 */
7465 unsigned int reserved1
:1; /* 5 */
7466 unsigned int Entry_SR
:1; /* 6 */
7467 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7468 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7469 unsigned int Args_stored
:1; /* 16 */
7470 unsigned int Variable_Frame
:1; /* 17 */
7471 unsigned int Separate_Package_Body
:1; /* 18 */
7472 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7473 unsigned int Stack_Overflow_Check
:1; /* 20 */
7474 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7475 unsigned int Ada_Region
:1; /* 22 */
7476 unsigned int cxx_info
:1; /* 23 */
7477 unsigned int cxx_try_catch
:1; /* 24 */
7478 unsigned int sched_entry_seq
:1; /* 25 */
7479 unsigned int reserved2
:1; /* 26 */
7480 unsigned int Save_SP
:1; /* 27 */
7481 unsigned int Save_RP
:1; /* 28 */
7482 unsigned int Save_MRP_in_frame
:1; /* 29 */
7483 unsigned int extn_ptr_defined
:1; /* 30 */
7484 unsigned int Cleanup_defined
:1; /* 31 */
7486 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7487 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7488 unsigned int Large_frame
:1; /* 2 */
7489 unsigned int Pseudo_SP_Set
:1; /* 3 */
7490 unsigned int reserved4
:1; /* 4 */
7491 unsigned int Total_frame_size
:27; /* 5..31 */
7494 struct hppa_unw_aux_info
7496 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7497 unsigned long table_len
; /* Length of unwind table. */
7498 bfd_vma seg_base
; /* Starting address of segment. */
7499 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7500 unsigned long nsyms
; /* Number of symbols. */
7501 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7502 unsigned long nfuns
; /* Number of entries in funtab. */
7503 char * strtab
; /* The string table. */
7504 unsigned long strtab_size
; /* Size of string table. */
7508 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7510 struct hppa_unw_table_entry
* tp
;
7511 unsigned long j
, nfuns
;
7513 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7514 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7515 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7516 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7518 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7520 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7523 const char * procname
;
7525 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7526 aux
->strtab_size
, tp
->start
, &procname
,
7529 fputs ("\n<", stdout
);
7533 fputs (procname
, stdout
);
7536 printf ("+%lx", (unsigned long) offset
);
7539 fputs (">: [", stdout
);
7540 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7541 fputc ('-', stdout
);
7542 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7545 #define PF(_m) if (tp->_m) printf (#_m " ");
7546 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7549 PF(Millicode_save_sr0
);
7550 /* PV(Region_description); */
7556 PF(Separate_Package_Body
);
7557 PF(Frame_Extension_Millicode
);
7558 PF(Stack_Overflow_Check
);
7559 PF(Two_Instruction_SP_Increment
);
7563 PF(sched_entry_seq
);
7566 PF(Save_MRP_in_frame
);
7567 PF(extn_ptr_defined
);
7568 PF(Cleanup_defined
);
7569 PF(MPE_XL_interrupt_marker
);
7570 PF(HP_UX_interrupt_marker
);
7573 PV(Total_frame_size
);
7584 slurp_hppa_unwind_table (FILE * file
,
7585 struct hppa_unw_aux_info
* aux
,
7586 Elf_Internal_Shdr
* sec
)
7588 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7589 Elf_Internal_Phdr
* seg
;
7590 struct hppa_unw_table_entry
* tep
;
7591 Elf_Internal_Shdr
* relsec
;
7592 Elf_Internal_Rela
* rela
;
7593 Elf_Internal_Rela
* rp
;
7594 unsigned char * table
;
7596 Elf_Internal_Sym
* sym
;
7597 const char * relname
;
7599 /* First, find the starting address of the segment that includes
7602 if (elf_header
.e_phnum
)
7604 if (! get_program_headers (file
))
7607 for (seg
= program_headers
;
7608 seg
< program_headers
+ elf_header
.e_phnum
;
7611 if (seg
->p_type
!= PT_LOAD
)
7614 if (sec
->sh_addr
>= seg
->p_vaddr
7615 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7617 aux
->seg_base
= seg
->p_vaddr
;
7623 /* Second, build the unwind table from the contents of the unwind
7625 size
= sec
->sh_size
;
7626 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7632 nentries
= size
/ unw_ent_size
;
7633 size
= unw_ent_size
* nentries
;
7635 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7636 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7638 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7640 unsigned int tmp1
, tmp2
;
7642 tep
->start
.section
= SHN_UNDEF
;
7643 tep
->end
.section
= SHN_UNDEF
;
7645 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7646 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7647 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7648 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7650 tep
->start
.offset
+= aux
->seg_base
;
7651 tep
->end
.offset
+= aux
->seg_base
;
7653 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7654 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7655 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7656 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7657 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7658 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7659 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7660 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7661 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7662 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7663 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7664 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7665 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7666 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7667 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7668 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7669 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7670 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7671 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7672 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7673 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7674 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7675 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7676 tep
->Cleanup_defined
= tmp1
& 0x1;
7678 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7679 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7680 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7681 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7682 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7683 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7687 /* Third, apply any relocations to the unwind table. */
7688 for (relsec
= section_headers
;
7689 relsec
< section_headers
+ elf_header
.e_shnum
;
7692 if (relsec
->sh_type
!= SHT_RELA
7693 || relsec
->sh_info
>= elf_header
.e_shnum
7694 || section_headers
+ relsec
->sh_info
!= sec
)
7697 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7701 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7703 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7704 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7706 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7707 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7709 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7713 i
= rp
->r_offset
/ unw_ent_size
;
7715 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7718 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7719 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7722 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7723 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7733 aux
->table_len
= nentries
;
7739 hppa_process_unwind (FILE * file
)
7741 struct hppa_unw_aux_info aux
;
7742 Elf_Internal_Shdr
* unwsec
= NULL
;
7743 Elf_Internal_Shdr
* strsec
;
7744 Elf_Internal_Shdr
* sec
;
7747 if (string_table
== NULL
)
7750 memset (& aux
, 0, sizeof (aux
));
7752 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7754 if (sec
->sh_type
== SHT_SYMTAB
7755 && sec
->sh_link
< elf_header
.e_shnum
)
7757 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7759 strsec
= section_headers
+ sec
->sh_link
;
7760 if (aux
.strtab
!= NULL
)
7762 error (_("Multiple auxillary string tables encountered\n"));
7765 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7768 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7770 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7775 printf (_("\nThere are no unwind sections in this file.\n"));
7777 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7779 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7781 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7782 printable_section_name (sec
),
7783 (unsigned long) sec
->sh_offset
,
7784 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7786 slurp_hppa_unwind_table (file
, &aux
, sec
);
7787 if (aux
.table_len
> 0)
7788 dump_hppa_unwind (&aux
);
7791 free ((char *) aux
.table
);
7799 free ((char *) aux
.strtab
);
7804 unsigned char * data
; /* The unwind data. */
7805 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7806 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7807 unsigned long nrelas
; /* The number of relocations. */
7808 unsigned int rel_type
; /* REL or RELA ? */
7809 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7812 struct arm_unw_aux_info
7814 FILE * file
; /* The file containing the unwind sections. */
7815 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7816 unsigned long nsyms
; /* Number of symbols. */
7817 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7818 unsigned long nfuns
; /* Number of these symbols. */
7819 char * strtab
; /* The file's string table. */
7820 unsigned long strtab_size
; /* Size of string table. */
7824 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7825 bfd_vma fn
, struct absaddr addr
)
7827 const char *procname
;
7830 if (addr
.section
== SHN_UNDEF
)
7833 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7834 aux
->strtab_size
, addr
, &procname
,
7837 print_vma (fn
, PREFIX_HEX
);
7841 fputs (" <", stdout
);
7842 fputs (procname
, stdout
);
7845 printf ("+0x%lx", (unsigned long) sym_offset
);
7846 fputc ('>', stdout
);
7853 arm_free_section (struct arm_section
*arm_sec
)
7855 if (arm_sec
->data
!= NULL
)
7856 free (arm_sec
->data
);
7858 if (arm_sec
->rela
!= NULL
)
7859 free (arm_sec
->rela
);
7862 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7863 cached section and install SEC instead.
7864 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7865 and return its valued in * WORDP, relocating if necessary.
7866 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7867 relocation's offset in ADDR.
7868 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7869 into the string table of the symbol associated with the reloc. If no
7870 reloc was applied store -1 there.
7871 5) Return TRUE upon success, FALSE otherwise. */
7874 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7875 struct arm_section
* arm_sec
,
7876 Elf_Internal_Shdr
* sec
,
7877 bfd_vma word_offset
,
7878 unsigned int * wordp
,
7879 struct absaddr
* addr
,
7882 Elf_Internal_Rela
*rp
;
7883 Elf_Internal_Sym
*sym
;
7884 const char * relname
;
7886 bfd_boolean wrapped
;
7888 if (sec
== NULL
|| arm_sec
== NULL
)
7891 addr
->section
= SHN_UNDEF
;
7894 if (sym_name
!= NULL
)
7895 *sym_name
= (bfd_vma
) -1;
7897 /* If necessary, update the section cache. */
7898 if (sec
!= arm_sec
->sec
)
7900 Elf_Internal_Shdr
*relsec
;
7902 arm_free_section (arm_sec
);
7905 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7906 sec
->sh_size
, _("unwind data"));
7907 arm_sec
->rela
= NULL
;
7908 arm_sec
->nrelas
= 0;
7910 for (relsec
= section_headers
;
7911 relsec
< section_headers
+ elf_header
.e_shnum
;
7914 if (relsec
->sh_info
>= elf_header
.e_shnum
7915 || section_headers
+ relsec
->sh_info
!= sec
7916 /* PR 15745: Check the section type as well. */
7917 || (relsec
->sh_type
!= SHT_REL
7918 && relsec
->sh_type
!= SHT_RELA
))
7921 arm_sec
->rel_type
= relsec
->sh_type
;
7922 if (relsec
->sh_type
== SHT_REL
)
7924 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7926 & arm_sec
->rela
, & arm_sec
->nrelas
))
7929 else /* relsec->sh_type == SHT_RELA */
7931 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7933 & arm_sec
->rela
, & arm_sec
->nrelas
))
7939 arm_sec
->next_rela
= arm_sec
->rela
;
7942 /* If there is no unwind data we can do nothing. */
7943 if (arm_sec
->data
== NULL
)
7946 /* If the offset is invalid then fail. */
7947 if (word_offset
> (sec
->sh_size
- 4)
7949 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7950 || ((bfd_signed_vma
) word_offset
) < 0)
7953 /* Get the word at the required offset. */
7954 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7956 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7957 if (arm_sec
->rela
== NULL
)
7963 /* Look through the relocs to find the one that applies to the provided offset. */
7965 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7967 bfd_vma prelval
, offset
;
7969 if (rp
->r_offset
> word_offset
&& !wrapped
)
7974 if (rp
->r_offset
> word_offset
)
7977 if (rp
->r_offset
& 3)
7979 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7980 (unsigned long) rp
->r_offset
);
7984 if (rp
->r_offset
< word_offset
)
7987 /* PR 17531: file: 027-161405-0.004 */
7988 if (aux
->symtab
== NULL
)
7991 if (arm_sec
->rel_type
== SHT_REL
)
7993 offset
= word
& 0x7fffffff;
7994 if (offset
& 0x40000000)
7995 offset
|= ~ (bfd_vma
) 0x7fffffff;
7997 else if (arm_sec
->rel_type
== SHT_RELA
)
7998 offset
= rp
->r_addend
;
8001 error (_("Unknown section relocation type %d encountered\n"),
8006 /* PR 17531 file: 027-1241568-0.004. */
8007 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8009 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8010 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8014 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8015 offset
+= sym
->st_value
;
8016 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8018 /* Check that we are processing the expected reloc type. */
8019 if (elf_header
.e_machine
== EM_ARM
)
8021 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8022 if (relname
== NULL
)
8024 warn (_("Skipping unknown ARM relocation type: %d\n"),
8025 (int) ELF32_R_TYPE (rp
->r_info
));
8029 if (streq (relname
, "R_ARM_NONE"))
8032 if (! streq (relname
, "R_ARM_PREL31"))
8034 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8038 else if (elf_header
.e_machine
== EM_TI_C6000
)
8040 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8041 if (relname
== NULL
)
8043 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8044 (int) ELF32_R_TYPE (rp
->r_info
));
8048 if (streq (relname
, "R_C6000_NONE"))
8051 if (! streq (relname
, "R_C6000_PREL31"))
8053 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8061 /* This function currently only supports ARM and TI unwinders. */
8062 warn (_("Only TI and ARM unwinders are currently supported\n"));
8066 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8067 addr
->section
= sym
->st_shndx
;
8068 addr
->offset
= offset
;
8071 * sym_name
= sym
->st_name
;
8076 arm_sec
->next_rela
= rp
;
8081 static const char *tic6x_unwind_regnames
[16] =
8083 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8084 "A14", "A13", "A12", "A11", "A10",
8085 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8089 decode_tic6x_unwind_regmask (unsigned int mask
)
8093 for (i
= 12; mask
; mask
>>= 1, i
--)
8097 fputs (tic6x_unwind_regnames
[i
], stdout
);
8099 fputs (", ", stdout
);
8105 if (remaining == 0 && more_words) \
8108 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8109 data_offset, & word, & addr, NULL)) \
8115 #define GET_OP(OP) \
8120 (OP) = word >> 24; \
8125 printf (_("[Truncated opcode]\n")); \
8128 printf ("0x%02x ", OP)
8131 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8133 unsigned int remaining
,
8134 unsigned int more_words
,
8135 bfd_vma data_offset
,
8136 Elf_Internal_Shdr
* data_sec
,
8137 struct arm_section
* data_arm_sec
)
8139 struct absaddr addr
;
8141 /* Decode the unwinding instructions. */
8144 unsigned int op
, op2
;
8153 printf (" 0x%02x ", op
);
8155 if ((op
& 0xc0) == 0x00)
8157 int offset
= ((op
& 0x3f) << 2) + 4;
8159 printf (" vsp = vsp + %d", offset
);
8161 else if ((op
& 0xc0) == 0x40)
8163 int offset
= ((op
& 0x3f) << 2) + 4;
8165 printf (" vsp = vsp - %d", offset
);
8167 else if ((op
& 0xf0) == 0x80)
8170 if (op
== 0x80 && op2
== 0)
8171 printf (_("Refuse to unwind"));
8174 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8179 for (i
= 0; i
< 12; i
++)
8180 if (mask
& (1 << i
))
8186 printf ("r%d", 4 + i
);
8191 else if ((op
& 0xf0) == 0x90)
8193 if (op
== 0x9d || op
== 0x9f)
8194 printf (_(" [Reserved]"));
8196 printf (" vsp = r%d", op
& 0x0f);
8198 else if ((op
& 0xf0) == 0xa0)
8200 int end
= 4 + (op
& 0x07);
8205 for (i
= 4; i
<= end
; i
++)
8221 else if (op
== 0xb0)
8222 printf (_(" finish"));
8223 else if (op
== 0xb1)
8226 if (op2
== 0 || (op2
& 0xf0) != 0)
8227 printf (_("[Spare]"));
8230 unsigned int mask
= op2
& 0x0f;
8235 for (i
= 0; i
< 12; i
++)
8236 if (mask
& (1 << i
))
8247 else if (op
== 0xb2)
8249 unsigned char buf
[9];
8250 unsigned int i
, len
;
8251 unsigned long offset
;
8253 for (i
= 0; i
< sizeof (buf
); i
++)
8256 if ((buf
[i
] & 0x80) == 0)
8259 if (i
== sizeof (buf
))
8260 printf (_("corrupt change to vsp"));
8263 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8264 assert (len
== i
+ 1);
8265 offset
= offset
* 4 + 0x204;
8266 printf ("vsp = vsp + %ld", offset
);
8269 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8271 unsigned int first
, last
;
8278 printf ("pop {D%d", first
);
8280 printf ("-D%d", first
+ last
);
8283 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8285 unsigned int count
= op
& 0x07;
8289 printf ("-D%d", 8 + count
);
8292 else if (op
>= 0xc0 && op
<= 0xc5)
8294 unsigned int count
= op
& 0x07;
8296 printf (" pop {wR10");
8298 printf ("-wR%d", 10 + count
);
8301 else if (op
== 0xc6)
8303 unsigned int first
, last
;
8308 printf ("pop {wR%d", first
);
8310 printf ("-wR%d", first
+ last
);
8313 else if (op
== 0xc7)
8316 if (op2
== 0 || (op2
& 0xf0) != 0)
8317 printf (_("[Spare]"));
8320 unsigned int mask
= op2
& 0x0f;
8325 for (i
= 0; i
< 4; i
++)
8326 if (mask
& (1 << i
))
8332 printf ("wCGR%d", i
);
8338 printf (_(" [unsupported opcode]"));
8344 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8346 unsigned int remaining
,
8347 unsigned int more_words
,
8348 bfd_vma data_offset
,
8349 Elf_Internal_Shdr
* data_sec
,
8350 struct arm_section
* data_arm_sec
)
8352 struct absaddr addr
;
8354 /* Decode the unwinding instructions. */
8357 unsigned int op
, op2
;
8366 printf (" 0x%02x ", op
);
8368 if ((op
& 0xc0) == 0x00)
8370 int offset
= ((op
& 0x3f) << 3) + 8;
8371 printf (" sp = sp + %d", offset
);
8373 else if ((op
& 0xc0) == 0x80)
8376 if (op
== 0x80 && op2
== 0)
8377 printf (_("Refuse to unwind"));
8380 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8382 printf ("pop compact {");
8386 decode_tic6x_unwind_regmask (mask
);
8390 else if ((op
& 0xf0) == 0xc0)
8398 unsigned int offset
;
8402 /* Scan entire instruction first so that GET_OP output is not
8403 interleaved with disassembly. */
8405 for (i
= 0; nregs
< (op
& 0xf); i
++)
8411 regpos
[nregs
].offset
= i
* 2;
8412 regpos
[nregs
].reg
= reg
;
8419 regpos
[nregs
].offset
= i
* 2 + 1;
8420 regpos
[nregs
].reg
= reg
;
8425 printf (_("pop frame {"));
8427 for (i
= i
* 2; i
> 0; i
--)
8429 if (regpos
[reg
].offset
== i
- 1)
8431 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8438 fputs (name
, stdout
);
8445 else if (op
== 0xd0)
8446 printf (" MOV FP, SP");
8447 else if (op
== 0xd1)
8448 printf (" __c6xabi_pop_rts");
8449 else if (op
== 0xd2)
8451 unsigned char buf
[9];
8452 unsigned int i
, len
;
8453 unsigned long offset
;
8455 for (i
= 0; i
< sizeof (buf
); i
++)
8458 if ((buf
[i
] & 0x80) == 0)
8461 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8462 if (i
== sizeof (buf
))
8464 printf ("<corrupt sp adjust>\n");
8465 warn (_("Corrupt stack pointer adjustment detected\n"));
8469 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8470 assert (len
== i
+ 1);
8471 offset
= offset
* 8 + 0x408;
8472 printf (_("sp = sp + %ld"), offset
);
8474 else if ((op
& 0xf0) == 0xe0)
8476 if ((op
& 0x0f) == 7)
8479 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8483 printf (_(" [unsupported opcode]"));
8490 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8494 offset
= word
& 0x7fffffff;
8495 if (offset
& 0x40000000)
8496 offset
|= ~ (bfd_vma
) 0x7fffffff;
8498 if (elf_header
.e_machine
== EM_TI_C6000
)
8501 return offset
+ where
;
8505 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8507 unsigned int remaining
,
8508 bfd_vma data_offset
,
8509 Elf_Internal_Shdr
* data_sec
,
8510 struct arm_section
* data_arm_sec
)
8513 unsigned int more_words
= 0;
8514 struct absaddr addr
;
8515 bfd_vma sym_name
= (bfd_vma
) -1;
8519 /* Fetch the first word.
8520 Note - when decoding an object file the address extracted
8521 here will always be 0. So we also pass in the sym_name
8522 parameter so that we can find the symbol associated with
8523 the personality routine. */
8524 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8525 & word
, & addr
, & sym_name
))
8531 if ((word
& 0x80000000) == 0)
8533 /* Expand prel31 for personality routine. */
8535 const char *procname
;
8537 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8538 printf (_(" Personality routine: "));
8540 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8541 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8543 procname
= aux
->strtab
+ sym_name
;
8544 print_vma (fn
, PREFIX_HEX
);
8547 fputs (" <", stdout
);
8548 fputs (procname
, stdout
);
8549 fputc ('>', stdout
);
8553 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8554 fputc ('\n', stdout
);
8556 /* The GCC personality routines use the standard compact
8557 encoding, starting with one byte giving the number of
8559 if (procname
!= NULL
8560 && (const_strneq (procname
, "__gcc_personality_v0")
8561 || const_strneq (procname
, "__gxx_personality_v0")
8562 || const_strneq (procname
, "__gcj_personality_v0")
8563 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8570 printf (_(" [Truncated data]\n"));
8573 more_words
= word
>> 24;
8583 /* ARM EHABI Section 6.3:
8585 An exception-handling table entry for the compact model looks like:
8589 1 0 index Data for personalityRoutine[index] */
8591 if (elf_header
.e_machine
== EM_ARM
8592 && (word
& 0x70000000))
8593 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8595 per_index
= (word
>> 24) & 0x7f;
8596 printf (_(" Compact model index: %d\n"), per_index
);
8603 else if (per_index
< 3)
8605 more_words
= (word
>> 16) & 0xff;
8611 switch (elf_header
.e_machine
)
8616 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8617 data_offset
, data_sec
, data_arm_sec
);
8621 warn (_("Unknown ARM compact model index encountered\n"));
8622 printf (_(" [reserved]\n"));
8629 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8630 data_offset
, data_sec
, data_arm_sec
);
8632 else if (per_index
< 5)
8634 if (((word
>> 17) & 0x7f) == 0x7f)
8635 printf (_(" Restore stack from frame pointer\n"));
8637 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8638 printf (_(" Registers restored: "));
8640 printf (" (compact) ");
8641 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8643 printf (_(" Return register: %s\n"),
8644 tic6x_unwind_regnames
[word
& 0xf]);
8647 printf (_(" [reserved (%d)]\n"), per_index
);
8651 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8652 elf_header
.e_machine
);
8655 /* Decode the descriptors. Not implemented. */
8659 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8661 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8662 unsigned int i
, exidx_len
;
8663 unsigned long j
, nfuns
;
8665 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8666 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8667 exidx_len
= exidx_sec
->sh_size
/ 8;
8669 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8670 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8671 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8672 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8674 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8676 for (i
= 0; i
< exidx_len
; i
++)
8678 unsigned int exidx_fn
, exidx_entry
;
8679 struct absaddr fn_addr
, entry_addr
;
8682 fputc ('\n', stdout
);
8684 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8685 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8686 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8687 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8690 arm_free_section (& exidx_arm_sec
);
8691 arm_free_section (& extab_arm_sec
);
8695 /* ARM EHABI, Section 5:
8696 An index table entry consists of 2 words.
8697 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8698 if (exidx_fn
& 0x80000000)
8699 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8701 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8703 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8704 fputs (": ", stdout
);
8706 if (exidx_entry
== 1)
8708 print_vma (exidx_entry
, PREFIX_HEX
);
8709 fputs (" [cantunwind]\n", stdout
);
8711 else if (exidx_entry
& 0x80000000)
8713 print_vma (exidx_entry
, PREFIX_HEX
);
8714 fputc ('\n', stdout
);
8715 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8719 bfd_vma table
, table_offset
= 0;
8720 Elf_Internal_Shdr
*table_sec
;
8722 fputs ("@", stdout
);
8723 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8724 print_vma (table
, PREFIX_HEX
);
8727 /* Locate the matching .ARM.extab. */
8728 if (entry_addr
.section
!= SHN_UNDEF
8729 && entry_addr
.section
< elf_header
.e_shnum
)
8731 table_sec
= section_headers
+ entry_addr
.section
;
8732 table_offset
= entry_addr
.offset
;
8734 if (table_offset
> table_sec
->sh_size
8735 || ((bfd_signed_vma
) table_offset
) < 0)
8737 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8738 (unsigned long) table_offset
,
8739 printable_section_name (table_sec
));
8745 table_sec
= find_section_by_address (table
);
8746 if (table_sec
!= NULL
)
8747 table_offset
= table
- table_sec
->sh_addr
;
8749 if (table_sec
== NULL
)
8751 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8752 (unsigned long) table
);
8755 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8763 arm_free_section (&exidx_arm_sec
);
8764 arm_free_section (&extab_arm_sec
);
8767 /* Used for both ARM and C6X unwinding tables. */
8770 arm_process_unwind (FILE *file
)
8772 struct arm_unw_aux_info aux
;
8773 Elf_Internal_Shdr
*unwsec
= NULL
;
8774 Elf_Internal_Shdr
*strsec
;
8775 Elf_Internal_Shdr
*sec
;
8777 unsigned int sec_type
;
8779 switch (elf_header
.e_machine
)
8782 sec_type
= SHT_ARM_EXIDX
;
8786 sec_type
= SHT_C6000_UNWIND
;
8790 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8791 elf_header
.e_machine
);
8795 if (string_table
== NULL
)
8798 memset (& aux
, 0, sizeof (aux
));
8801 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8803 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8805 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8807 strsec
= section_headers
+ sec
->sh_link
;
8809 /* PR binutils/17531 file: 011-12666-0.004. */
8810 if (aux
.strtab
!= NULL
)
8812 error (_("Multiple string tables found in file.\n"));
8815 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8816 1, strsec
->sh_size
, _("string table"));
8817 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8819 else if (sec
->sh_type
== sec_type
)
8824 printf (_("\nThere are no unwind sections in this file.\n"));
8826 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8828 if (sec
->sh_type
== sec_type
)
8830 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8831 printable_section_name (sec
),
8832 (unsigned long) sec
->sh_offset
,
8833 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8835 dump_arm_unwind (&aux
, sec
);
8842 free ((char *) aux
.strtab
);
8846 process_unwind (FILE * file
)
8848 struct unwind_handler
8851 void (* handler
)(FILE *);
8854 { EM_ARM
, arm_process_unwind
},
8855 { EM_IA_64
, ia64_process_unwind
},
8856 { EM_PARISC
, hppa_process_unwind
},
8857 { EM_TI_C6000
, arm_process_unwind
},
8865 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8866 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8868 handlers
[i
].handler (file
);
8872 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8873 get_machine_name (elf_header
.e_machine
));
8877 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8879 switch (entry
->d_tag
)
8882 if (entry
->d_un
.d_val
== 0)
8886 static const char * opts
[] =
8888 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8889 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8890 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8891 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8897 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8898 if (entry
->d_un
.d_val
& (1 << cnt
))
8900 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8906 case DT_MIPS_IVERSION
:
8907 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8908 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8912 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8913 /* Note: coded this way so that there is a single string for translation. */
8914 printf (_("<corrupt: %s>"), buf
);
8918 case DT_MIPS_TIME_STAMP
:
8922 time_t atime
= entry
->d_un
.d_val
;
8924 tmp
= gmtime (&atime
);
8925 /* PR 17531: file: 6accc532. */
8927 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8929 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8930 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8931 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8932 printf (_("Time Stamp: %s"), timebuf
);
8936 case DT_MIPS_RLD_VERSION
:
8937 case DT_MIPS_LOCAL_GOTNO
:
8938 case DT_MIPS_CONFLICTNO
:
8939 case DT_MIPS_LIBLISTNO
:
8940 case DT_MIPS_SYMTABNO
:
8941 case DT_MIPS_UNREFEXTNO
:
8942 case DT_MIPS_HIPAGENO
:
8943 case DT_MIPS_DELTA_CLASS_NO
:
8944 case DT_MIPS_DELTA_INSTANCE_NO
:
8945 case DT_MIPS_DELTA_RELOC_NO
:
8946 case DT_MIPS_DELTA_SYM_NO
:
8947 case DT_MIPS_DELTA_CLASSSYM_NO
:
8948 case DT_MIPS_COMPACT_SIZE
:
8949 print_vma (entry
->d_un
.d_val
, DEC
);
8953 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8959 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8961 switch (entry
->d_tag
)
8963 case DT_HP_DLD_FLAGS
:
8972 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8973 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8974 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8975 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8976 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8977 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8978 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8979 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8980 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8981 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8982 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8983 { DT_HP_GST
, "HP_GST" },
8984 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8985 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8986 { DT_HP_NODELETE
, "HP_NODELETE" },
8987 { DT_HP_GROUP
, "HP_GROUP" },
8988 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8992 bfd_vma val
= entry
->d_un
.d_val
;
8994 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8995 if (val
& flags
[cnt
].bit
)
8999 fputs (flags
[cnt
].str
, stdout
);
9001 val
^= flags
[cnt
].bit
;
9004 if (val
!= 0 || first
)
9008 print_vma (val
, HEX
);
9014 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9022 /* VMS vs Unix time offset and factor. */
9024 #define VMS_EPOCH_OFFSET 35067168000000000LL
9025 #define VMS_GRANULARITY_FACTOR 10000000
9027 /* Display a VMS time in a human readable format. */
9030 print_vms_time (bfd_int64_t vmstime
)
9035 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9036 tm
= gmtime (&unxtime
);
9037 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9038 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9039 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9044 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9046 switch (entry
->d_tag
)
9048 case DT_IA_64_PLT_RESERVE
:
9049 /* First 3 slots reserved. */
9050 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9052 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9055 case DT_IA_64_VMS_LINKTIME
:
9057 print_vms_time (entry
->d_un
.d_val
);
9061 case DT_IA_64_VMS_LNKFLAGS
:
9062 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9063 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9064 printf (" CALL_DEBUG");
9065 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9066 printf (" NOP0BUFS");
9067 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9068 printf (" P0IMAGE");
9069 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9070 printf (" MKTHREADS");
9071 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9072 printf (" UPCALLS");
9073 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9075 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9076 printf (" INITIALIZE");
9077 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9079 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9080 printf (" EXE_INIT");
9081 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9082 printf (" TBK_IN_IMG");
9083 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9084 printf (" DBG_IN_IMG");
9085 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9086 printf (" TBK_IN_DSF");
9087 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9088 printf (" DBG_IN_DSF");
9089 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9090 printf (" SIGNATURES");
9091 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9092 printf (" REL_SEG_OFF");
9096 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9103 get_32bit_dynamic_section (FILE * file
)
9105 Elf32_External_Dyn
* edyn
;
9106 Elf32_External_Dyn
* ext
;
9107 Elf_Internal_Dyn
* entry
;
9109 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9110 dynamic_size
, _("dynamic section"));
9114 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9115 might not have the luxury of section headers. Look for the DT_NULL
9116 terminator to determine the number of entries. */
9117 for (ext
= edyn
, dynamic_nent
= 0;
9118 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9122 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9126 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9128 if (dynamic_section
== NULL
)
9130 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9131 (unsigned long) dynamic_nent
);
9136 for (ext
= edyn
, entry
= dynamic_section
;
9137 entry
< dynamic_section
+ dynamic_nent
;
9140 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9141 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9150 get_64bit_dynamic_section (FILE * file
)
9152 Elf64_External_Dyn
* edyn
;
9153 Elf64_External_Dyn
* ext
;
9154 Elf_Internal_Dyn
* entry
;
9156 /* Read in the data. */
9157 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9158 dynamic_size
, _("dynamic section"));
9162 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9163 might not have the luxury of section headers. Look for the DT_NULL
9164 terminator to determine the number of entries. */
9165 for (ext
= edyn
, dynamic_nent
= 0;
9166 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9167 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9171 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9175 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9177 if (dynamic_section
== NULL
)
9179 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9180 (unsigned long) dynamic_nent
);
9185 /* Convert from external to internal formats. */
9186 for (ext
= edyn
, entry
= dynamic_section
;
9187 entry
< dynamic_section
+ dynamic_nent
;
9190 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9191 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9200 print_dynamic_flags (bfd_vma flags
)
9208 flag
= flags
& - flags
;
9218 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9219 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9220 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9221 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9222 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9223 default: fputs (_("unknown"), stdout
); break;
9229 /* Parse and display the contents of the dynamic section. */
9232 process_dynamic_section (FILE * file
)
9234 Elf_Internal_Dyn
* entry
;
9236 if (dynamic_size
== 0)
9239 printf (_("\nThere is no dynamic section in this file.\n"));
9246 if (! get_32bit_dynamic_section (file
))
9249 else if (! get_64bit_dynamic_section (file
))
9252 /* Find the appropriate symbol table. */
9253 if (dynamic_symbols
== NULL
)
9255 for (entry
= dynamic_section
;
9256 entry
< dynamic_section
+ dynamic_nent
;
9259 Elf_Internal_Shdr section
;
9261 if (entry
->d_tag
!= DT_SYMTAB
)
9264 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9266 /* Since we do not know how big the symbol table is,
9267 we default to reading in the entire file (!) and
9268 processing that. This is overkill, I know, but it
9270 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9272 if (archive_file_offset
!= 0)
9273 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9276 if (fseek (file
, 0, SEEK_END
))
9277 error (_("Unable to seek to end of file!\n"));
9279 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9283 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9285 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9286 section
.sh_name
= string_table_length
;
9288 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9289 if (num_dynamic_syms
< 1)
9291 error (_("Unable to determine the number of symbols to load\n"));
9297 /* Similarly find a string table. */
9298 if (dynamic_strings
== NULL
)
9300 for (entry
= dynamic_section
;
9301 entry
< dynamic_section
+ dynamic_nent
;
9304 unsigned long offset
;
9307 if (entry
->d_tag
!= DT_STRTAB
)
9310 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9312 /* Since we do not know how big the string table is,
9313 we default to reading in the entire file (!) and
9314 processing that. This is overkill, I know, but it
9317 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9319 if (archive_file_offset
!= 0)
9320 str_tab_len
= archive_file_size
- offset
;
9323 if (fseek (file
, 0, SEEK_END
))
9324 error (_("Unable to seek to end of file\n"));
9325 str_tab_len
= ftell (file
) - offset
;
9328 if (str_tab_len
< 1)
9331 (_("Unable to determine the length of the dynamic string table\n"));
9335 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9337 _("dynamic string table"));
9338 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9343 /* And find the syminfo section if available. */
9344 if (dynamic_syminfo
== NULL
)
9346 unsigned long syminsz
= 0;
9348 for (entry
= dynamic_section
;
9349 entry
< dynamic_section
+ dynamic_nent
;
9352 if (entry
->d_tag
== DT_SYMINENT
)
9354 /* Note: these braces are necessary to avoid a syntax
9355 error from the SunOS4 C compiler. */
9356 /* PR binutils/17531: A corrupt file can trigger this test.
9357 So do not use an assert, instead generate an error message. */
9358 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9359 error (_("Bad value (%d) for SYMINENT entry\n"),
9360 (int) entry
->d_un
.d_val
);
9362 else if (entry
->d_tag
== DT_SYMINSZ
)
9363 syminsz
= entry
->d_un
.d_val
;
9364 else if (entry
->d_tag
== DT_SYMINFO
)
9365 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9369 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9371 Elf_External_Syminfo
* extsyminfo
;
9372 Elf_External_Syminfo
* extsym
;
9373 Elf_Internal_Syminfo
* syminfo
;
9375 /* There is a syminfo section. Read the data. */
9376 extsyminfo
= (Elf_External_Syminfo
*)
9377 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9378 _("symbol information"));
9382 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9383 if (dynamic_syminfo
== NULL
)
9385 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9386 (unsigned long) syminsz
);
9390 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9391 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9392 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9393 ++syminfo
, ++extsym
)
9395 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9396 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9403 if (do_dynamic
&& dynamic_addr
)
9404 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9405 dynamic_addr
, (unsigned long) dynamic_nent
);
9407 printf (_(" Tag Type Name/Value\n"));
9409 for (entry
= dynamic_section
;
9410 entry
< dynamic_section
+ dynamic_nent
;
9418 print_vma (entry
->d_tag
, FULL_HEX
);
9419 dtype
= get_dynamic_type (entry
->d_tag
);
9420 printf (" (%s)%*s", dtype
,
9421 ((is_32bit_elf
? 27 : 19)
9422 - (int) strlen (dtype
)),
9426 switch (entry
->d_tag
)
9430 print_dynamic_flags (entry
->d_un
.d_val
);
9440 switch (entry
->d_tag
)
9443 printf (_("Auxiliary library"));
9447 printf (_("Filter library"));
9451 printf (_("Configuration file"));
9455 printf (_("Dependency audit library"));
9459 printf (_("Audit library"));
9463 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9464 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9468 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9477 printf (_("Flags:"));
9479 if (entry
->d_un
.d_val
== 0)
9480 printf (_(" None\n"));
9483 unsigned long int val
= entry
->d_un
.d_val
;
9485 if (val
& DTF_1_PARINIT
)
9487 printf (" PARINIT");
9488 val
^= DTF_1_PARINIT
;
9490 if (val
& DTF_1_CONFEXP
)
9492 printf (" CONFEXP");
9493 val
^= DTF_1_CONFEXP
;
9496 printf (" %lx", val
);
9505 printf (_("Flags:"));
9507 if (entry
->d_un
.d_val
== 0)
9508 printf (_(" None\n"));
9511 unsigned long int val
= entry
->d_un
.d_val
;
9513 if (val
& DF_P1_LAZYLOAD
)
9515 printf (" LAZYLOAD");
9516 val
^= DF_P1_LAZYLOAD
;
9518 if (val
& DF_P1_GROUPPERM
)
9520 printf (" GROUPPERM");
9521 val
^= DF_P1_GROUPPERM
;
9524 printf (" %lx", val
);
9533 printf (_("Flags:"));
9534 if (entry
->d_un
.d_val
== 0)
9535 printf (_(" None\n"));
9538 unsigned long int val
= entry
->d_un
.d_val
;
9545 if (val
& DF_1_GLOBAL
)
9550 if (val
& DF_1_GROUP
)
9555 if (val
& DF_1_NODELETE
)
9557 printf (" NODELETE");
9558 val
^= DF_1_NODELETE
;
9560 if (val
& DF_1_LOADFLTR
)
9562 printf (" LOADFLTR");
9563 val
^= DF_1_LOADFLTR
;
9565 if (val
& DF_1_INITFIRST
)
9567 printf (" INITFIRST");
9568 val
^= DF_1_INITFIRST
;
9570 if (val
& DF_1_NOOPEN
)
9575 if (val
& DF_1_ORIGIN
)
9580 if (val
& DF_1_DIRECT
)
9585 if (val
& DF_1_TRANS
)
9590 if (val
& DF_1_INTERPOSE
)
9592 printf (" INTERPOSE");
9593 val
^= DF_1_INTERPOSE
;
9595 if (val
& DF_1_NODEFLIB
)
9597 printf (" NODEFLIB");
9598 val
^= DF_1_NODEFLIB
;
9600 if (val
& DF_1_NODUMP
)
9605 if (val
& DF_1_CONFALT
)
9607 printf (" CONFALT");
9608 val
^= DF_1_CONFALT
;
9610 if (val
& DF_1_ENDFILTEE
)
9612 printf (" ENDFILTEE");
9613 val
^= DF_1_ENDFILTEE
;
9615 if (val
& DF_1_DISPRELDNE
)
9617 printf (" DISPRELDNE");
9618 val
^= DF_1_DISPRELDNE
;
9620 if (val
& DF_1_DISPRELPND
)
9622 printf (" DISPRELPND");
9623 val
^= DF_1_DISPRELPND
;
9625 if (val
& DF_1_NODIRECT
)
9627 printf (" NODIRECT");
9628 val
^= DF_1_NODIRECT
;
9630 if (val
& DF_1_IGNMULDEF
)
9632 printf (" IGNMULDEF");
9633 val
^= DF_1_IGNMULDEF
;
9635 if (val
& DF_1_NOKSYMS
)
9637 printf (" NOKSYMS");
9638 val
^= DF_1_NOKSYMS
;
9640 if (val
& DF_1_NOHDR
)
9645 if (val
& DF_1_EDITED
)
9650 if (val
& DF_1_NORELOC
)
9652 printf (" NORELOC");
9653 val
^= DF_1_NORELOC
;
9655 if (val
& DF_1_SYMINTPOSE
)
9657 printf (" SYMINTPOSE");
9658 val
^= DF_1_SYMINTPOSE
;
9660 if (val
& DF_1_GLOBAUDIT
)
9662 printf (" GLOBAUDIT");
9663 val
^= DF_1_GLOBAUDIT
;
9665 if (val
& DF_1_SINGLETON
)
9667 printf (" SINGLETON");
9668 val
^= DF_1_SINGLETON
;
9670 if (val
& DF_1_STUB
)
9681 printf (" %lx", val
);
9688 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9690 puts (get_dynamic_type (entry
->d_un
.d_val
));
9710 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9716 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9717 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9723 switch (entry
->d_tag
)
9726 printf (_("Shared library: [%s]"), name
);
9728 if (streq (name
, program_interpreter
))
9729 printf (_(" program interpreter"));
9733 printf (_("Library soname: [%s]"), name
);
9737 printf (_("Library rpath: [%s]"), name
);
9741 printf (_("Library runpath: [%s]"), name
);
9745 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9750 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9763 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9768 case DT_INIT_ARRAYSZ
:
9769 case DT_FINI_ARRAYSZ
:
9770 case DT_GNU_CONFLICTSZ
:
9771 case DT_GNU_LIBLISTSZ
:
9774 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9775 printf (_(" (bytes)\n"));
9785 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9798 if (entry
->d_tag
== DT_USED
9799 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9801 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9805 printf (_("Not needed object: [%s]\n"), name
);
9810 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9816 /* The value of this entry is ignored. */
9821 case DT_GNU_PRELINKED
:
9825 time_t atime
= entry
->d_un
.d_val
;
9827 tmp
= gmtime (&atime
);
9828 /* PR 17533 file: 041-1244816-0.004. */
9830 printf (_("<corrupt time val: %lx"),
9831 (unsigned long) atime
);
9833 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9834 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9835 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9841 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9844 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9850 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9851 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9856 switch (elf_header
.e_machine
)
9859 case EM_MIPS_RS3_LE
:
9860 dynamic_section_mips_val (entry
);
9863 dynamic_section_parisc_val (entry
);
9866 dynamic_section_ia64_val (entry
);
9869 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9881 get_ver_flags (unsigned int flags
)
9883 static char buff
[32];
9890 if (flags
& VER_FLG_BASE
)
9891 strcat (buff
, "BASE ");
9893 if (flags
& VER_FLG_WEAK
)
9895 if (flags
& VER_FLG_BASE
)
9896 strcat (buff
, "| ");
9898 strcat (buff
, "WEAK ");
9901 if (flags
& VER_FLG_INFO
)
9903 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9904 strcat (buff
, "| ");
9906 strcat (buff
, "INFO ");
9909 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9910 strcat (buff
, _("| <unknown>"));
9915 /* Display the contents of the version sections. */
9918 process_version_sections (FILE * file
)
9920 Elf_Internal_Shdr
* section
;
9927 for (i
= 0, section
= section_headers
;
9928 i
< elf_header
.e_shnum
;
9931 switch (section
->sh_type
)
9933 case SHT_GNU_verdef
:
9935 Elf_External_Verdef
* edefs
;
9942 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9943 printable_section_name (section
),
9946 printf (_(" Addr: 0x"));
9947 printf_vma (section
->sh_addr
);
9948 printf (_(" Offset: %#08lx Link: %u (%s)"),
9949 (unsigned long) section
->sh_offset
, section
->sh_link
,
9950 printable_section_name_from_index (section
->sh_link
));
9952 edefs
= (Elf_External_Verdef
*)
9953 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9954 _("version definition section"));
9957 endbuf
= (char *) edefs
+ section
->sh_size
;
9959 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9962 Elf_External_Verdef
* edef
;
9963 Elf_Internal_Verdef ent
;
9964 Elf_External_Verdaux
* eaux
;
9965 Elf_Internal_Verdaux aux
;
9969 /* Check for very large indices. */
9970 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9973 vstart
= ((char *) edefs
) + idx
;
9974 if (vstart
+ sizeof (*edef
) > endbuf
)
9977 edef
= (Elf_External_Verdef
*) vstart
;
9979 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9980 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9981 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9982 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9983 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9984 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9985 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9987 printf (_(" %#06x: Rev: %d Flags: %s"),
9988 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9990 printf (_(" Index: %d Cnt: %d "),
9991 ent
.vd_ndx
, ent
.vd_cnt
);
9993 /* Check for overflow. */
9994 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9997 vstart
+= ent
.vd_aux
;
9999 eaux
= (Elf_External_Verdaux
*) vstart
;
10001 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10002 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10004 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10005 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10007 printf (_("Name index: %ld\n"), aux
.vda_name
);
10009 isum
= idx
+ ent
.vd_aux
;
10011 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10013 /* Check for overflow. */
10014 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10017 isum
+= aux
.vda_next
;
10018 vstart
+= aux
.vda_next
;
10020 eaux
= (Elf_External_Verdaux
*) vstart
;
10021 if (vstart
+ sizeof (*eaux
) > endbuf
)
10024 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10025 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10027 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10028 printf (_(" %#06x: Parent %d: %s\n"),
10029 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10031 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10032 isum
, j
, aux
.vda_name
);
10035 if (j
< ent
.vd_cnt
)
10036 printf (_(" Version def aux past end of section\n"));
10038 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10039 if (idx
+ ent
.vd_next
<= idx
)
10042 idx
+= ent
.vd_next
;
10045 if (cnt
< section
->sh_info
)
10046 printf (_(" Version definition past end of section\n"));
10052 case SHT_GNU_verneed
:
10054 Elf_External_Verneed
* eneed
;
10061 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10062 printable_section_name (section
), section
->sh_info
);
10064 printf (_(" Addr: 0x"));
10065 printf_vma (section
->sh_addr
);
10066 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10067 (unsigned long) section
->sh_offset
, section
->sh_link
,
10068 printable_section_name_from_index (section
->sh_link
));
10070 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10071 section
->sh_offset
, 1,
10073 _("Version Needs section"));
10076 endbuf
= (char *) eneed
+ section
->sh_size
;
10078 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10080 Elf_External_Verneed
* entry
;
10081 Elf_Internal_Verneed ent
;
10086 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10089 vstart
= ((char *) eneed
) + idx
;
10090 if (vstart
+ sizeof (*entry
) > endbuf
)
10093 entry
= (Elf_External_Verneed
*) vstart
;
10095 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10096 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10097 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10098 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10099 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10101 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10103 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10104 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10106 printf (_(" File: %lx"), ent
.vn_file
);
10108 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10110 /* Check for overflow. */
10111 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10113 vstart
+= ent
.vn_aux
;
10115 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10117 Elf_External_Vernaux
* eaux
;
10118 Elf_Internal_Vernaux aux
;
10120 if (vstart
+ sizeof (*eaux
) > endbuf
)
10122 eaux
= (Elf_External_Vernaux
*) vstart
;
10124 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10125 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10126 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10127 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10128 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10130 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10131 printf (_(" %#06x: Name: %s"),
10132 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10134 printf (_(" %#06x: Name index: %lx"),
10135 isum
, aux
.vna_name
);
10137 printf (_(" Flags: %s Version: %d\n"),
10138 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10140 /* Check for overflow. */
10141 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10142 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10144 warn (_("Invalid vna_next field of %lx\n"),
10149 isum
+= aux
.vna_next
;
10150 vstart
+= aux
.vna_next
;
10153 if (j
< ent
.vn_cnt
)
10154 warn (_("Missing Version Needs auxillary information\n"));
10156 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10158 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10159 cnt
= section
->sh_info
;
10162 idx
+= ent
.vn_next
;
10165 if (cnt
< section
->sh_info
)
10166 warn (_("Missing Version Needs information\n"));
10172 case SHT_GNU_versym
:
10174 Elf_Internal_Shdr
* link_section
;
10177 unsigned char * edata
;
10178 unsigned short * data
;
10180 Elf_Internal_Sym
* symbols
;
10181 Elf_Internal_Shdr
* string_sec
;
10182 unsigned long num_syms
;
10185 if (section
->sh_link
>= elf_header
.e_shnum
)
10188 link_section
= section_headers
+ section
->sh_link
;
10189 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10191 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10196 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10197 if (symbols
== NULL
)
10200 string_sec
= section_headers
+ link_section
->sh_link
;
10202 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10203 string_sec
->sh_size
,
10204 _("version string table"));
10211 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10212 printable_section_name (section
), (unsigned long) total
);
10214 printf (_(" Addr: "));
10215 printf_vma (section
->sh_addr
);
10216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10217 (unsigned long) section
->sh_offset
, section
->sh_link
,
10218 printable_section_name (link_section
));
10220 off
= offset_from_vma (file
,
10221 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10222 total
* sizeof (short));
10223 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10225 _("version symbol data"));
10233 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10235 for (cnt
= total
; cnt
--;)
10236 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10241 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10245 char *invalid
= _("*invalid*");
10247 printf (" %03x:", cnt
);
10249 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10250 switch (data
[cnt
+ j
])
10253 fputs (_(" 0 (*local*) "), stdout
);
10257 fputs (_(" 1 (*global*) "), stdout
);
10261 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10262 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10264 /* If this index value is greater than the size of the symbols
10265 array, break to avoid an out-of-bounds read. */
10266 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10268 warn (_("invalid index into symbol array\n"));
10273 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10275 Elf_Internal_Verneed ivn
;
10276 unsigned long offset
;
10278 offset
= offset_from_vma
10279 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10280 sizeof (Elf_External_Verneed
));
10284 Elf_Internal_Vernaux ivna
;
10285 Elf_External_Verneed evn
;
10286 Elf_External_Vernaux evna
;
10287 unsigned long a_off
;
10289 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10290 _("version need")) == NULL
)
10293 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10294 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10296 a_off
= offset
+ ivn
.vn_aux
;
10300 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10301 1, _("version need aux (2)")) == NULL
)
10304 ivna
.vna_other
= 0;
10308 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10309 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10312 a_off
+= ivna
.vna_next
;
10314 while (ivna
.vna_other
!= data
[cnt
+ j
]
10315 && ivna
.vna_next
!= 0);
10317 if (ivna
.vna_other
== data
[cnt
+ j
])
10319 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10321 if (ivna
.vna_name
>= string_sec
->sh_size
)
10324 name
= strtab
+ ivna
.vna_name
;
10328 offset
+= ivn
.vn_next
;
10330 while (ivn
.vn_next
);
10333 if (data
[cnt
+ j
] != 0x8001
10334 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10336 Elf_Internal_Verdef ivd
;
10337 Elf_External_Verdef evd
;
10338 unsigned long offset
;
10340 offset
= offset_from_vma
10341 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10346 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10347 _("version def")) == NULL
)
10350 /* PR 17531: file: 046-1082287-0.004. */
10351 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10356 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10357 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10360 offset
+= ivd
.vd_next
;
10362 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10363 && ivd
.vd_next
!= 0);
10365 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10367 Elf_External_Verdaux evda
;
10368 Elf_Internal_Verdaux ivda
;
10370 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10372 if (get_data (&evda
, file
,
10373 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10375 _("version def aux")) == NULL
)
10378 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10380 if (ivda
.vda_name
>= string_sec
->sh_size
)
10382 else if (name
!= NULL
&& name
!= invalid
)
10383 name
= _("*both*");
10385 name
= strtab
+ ivda
.vda_name
;
10389 nn
+= printf ("(%s%-*s",
10391 12 - (int) strlen (name
),
10395 printf ("%*c", 18 - nn
, ' ');
10413 printf (_("\nNo version information found in this file.\n"));
10418 static const char *
10419 get_symbol_binding (unsigned int binding
)
10421 static char buff
[32];
10425 case STB_LOCAL
: return "LOCAL";
10426 case STB_GLOBAL
: return "GLOBAL";
10427 case STB_WEAK
: return "WEAK";
10429 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10430 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10432 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10434 if (binding
== STB_GNU_UNIQUE
10435 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10436 /* GNU is still using the default value 0. */
10437 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10439 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10442 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10447 static const char *
10448 get_symbol_type (unsigned int type
)
10450 static char buff
[32];
10454 case STT_NOTYPE
: return "NOTYPE";
10455 case STT_OBJECT
: return "OBJECT";
10456 case STT_FUNC
: return "FUNC";
10457 case STT_SECTION
: return "SECTION";
10458 case STT_FILE
: return "FILE";
10459 case STT_COMMON
: return "COMMON";
10460 case STT_TLS
: return "TLS";
10461 case STT_RELC
: return "RELC";
10462 case STT_SRELC
: return "SRELC";
10464 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10466 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10467 return "THUMB_FUNC";
10469 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10472 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10473 return "PARISC_MILLI";
10475 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10477 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10479 if (elf_header
.e_machine
== EM_PARISC
)
10481 if (type
== STT_HP_OPAQUE
)
10482 return "HP_OPAQUE";
10483 if (type
== STT_HP_STUB
)
10487 if (type
== STT_GNU_IFUNC
10488 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10489 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10490 /* GNU is still using the default value 0. */
10491 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10494 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10497 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10502 static const char *
10503 get_symbol_visibility (unsigned int visibility
)
10505 switch (visibility
)
10507 case STV_DEFAULT
: return "DEFAULT";
10508 case STV_INTERNAL
: return "INTERNAL";
10509 case STV_HIDDEN
: return "HIDDEN";
10510 case STV_PROTECTED
: return "PROTECTED";
10512 error (_("Unrecognized visibility value: %u"), visibility
);
10513 return _("<unknown>");
10517 static const char *
10518 get_solaris_symbol_visibility (unsigned int visibility
)
10520 switch (visibility
)
10522 case 4: return "EXPORTED";
10523 case 5: return "SINGLETON";
10524 case 6: return "ELIMINATE";
10525 default: return get_symbol_visibility (visibility
);
10529 static const char *
10530 get_mips_symbol_other (unsigned int other
)
10540 case STO_MICROMIPS
:
10541 return "MICROMIPS";
10542 case STO_MICROMIPS
| STO_MIPS_PIC
:
10543 return "MICROMIPS, MIPS PIC";
10551 static const char *
10552 get_ia64_symbol_other (unsigned int other
)
10554 if (is_ia64_vms ())
10556 static char res
[32];
10560 /* Function types is for images and .STB files only. */
10561 switch (elf_header
.e_type
)
10565 switch (VMS_ST_FUNC_TYPE (other
))
10567 case VMS_SFT_CODE_ADDR
:
10568 strcat (res
, " CA");
10570 case VMS_SFT_SYMV_IDX
:
10571 strcat (res
, " VEC");
10574 strcat (res
, " FD");
10576 case VMS_SFT_RESERVE
:
10577 strcat (res
, " RSV");
10580 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10581 VMS_ST_FUNC_TYPE (other
));
10582 strcat (res
, " <unknown>");
10589 switch (VMS_ST_LINKAGE (other
))
10591 case VMS_STL_IGNORE
:
10592 strcat (res
, " IGN");
10594 case VMS_STL_RESERVE
:
10595 strcat (res
, " RSV");
10598 strcat (res
, " STD");
10601 strcat (res
, " LNK");
10604 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10605 VMS_ST_LINKAGE (other
));
10606 strcat (res
, " <unknown>");
10618 static const char *
10619 get_ppc64_symbol_other (unsigned int other
)
10621 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10623 static char buf
[32];
10624 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10625 PPC64_LOCAL_ENTRY_OFFSET (other
));
10631 static const char *
10632 get_symbol_other (unsigned int other
)
10634 const char * result
= NULL
;
10635 static char buff
[32];
10640 switch (elf_header
.e_machine
)
10643 result
= get_mips_symbol_other (other
);
10646 result
= get_ia64_symbol_other (other
);
10649 result
= get_ppc64_symbol_other (other
);
10659 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10663 static const char *
10664 get_symbol_index_type (unsigned int type
)
10666 static char buff
[32];
10670 case SHN_UNDEF
: return "UND";
10671 case SHN_ABS
: return "ABS";
10672 case SHN_COMMON
: return "COM";
10674 if (type
== SHN_IA_64_ANSI_COMMON
10675 && elf_header
.e_machine
== EM_IA_64
10676 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10678 else if ((elf_header
.e_machine
== EM_X86_64
10679 || elf_header
.e_machine
== EM_L1OM
10680 || elf_header
.e_machine
== EM_K1OM
)
10681 && type
== SHN_X86_64_LCOMMON
)
10682 return "LARGE_COM";
10683 else if ((type
== SHN_MIPS_SCOMMON
10684 && elf_header
.e_machine
== EM_MIPS
)
10685 || (type
== SHN_TIC6X_SCOMMON
10686 && elf_header
.e_machine
== EM_TI_C6000
))
10688 else if (type
== SHN_MIPS_SUNDEFINED
10689 && elf_header
.e_machine
== EM_MIPS
)
10691 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10692 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10693 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10694 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10695 else if (type
>= SHN_LORESERVE
)
10696 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10697 else if (type
>= elf_header
.e_shnum
)
10698 sprintf (buff
, _("bad section index[%3d]"), type
);
10700 sprintf (buff
, "%3d", type
);
10708 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10710 unsigned char * e_data
;
10713 /* If the size_t type is smaller than the bfd_size_type, eg because
10714 you are building a 32-bit tool on a 64-bit host, then make sure
10715 that when (number) is cast to (size_t) no information is lost. */
10716 if (sizeof (size_t) < sizeof (bfd_size_type
)
10717 && (bfd_size_type
) ((size_t) number
) != number
)
10719 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10720 " elements of size %u\n"),
10725 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10726 attempting to allocate memory when the read is bound to fail. */
10727 if (ent_size
* number
> current_file_size
)
10729 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10734 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10735 if (e_data
== NULL
)
10737 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10742 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10744 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10745 number
* ent_size
);
10750 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10751 if (i_data
== NULL
)
10753 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10754 " dynamic entries\n"),
10761 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10769 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10771 Elf_Internal_Sym
* psym
;
10774 n
= print_vma (si
, DEC_5
);
10776 fputs (&" "[n
], stdout
);
10777 printf (" %3lu: ", hn
);
10779 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10781 printf (_("<No info available for dynamic symbol number %lu>\n"),
10782 (unsigned long) si
);
10786 psym
= dynamic_symbols
+ si
;
10787 print_vma (psym
->st_value
, LONG_HEX
);
10789 print_vma (psym
->st_size
, DEC_5
);
10791 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10792 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10794 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10795 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10798 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10800 printf (" %-7s", get_symbol_visibility (vis
));
10801 /* Check to see if any other bits in the st_other field are set.
10802 Note - displaying this information disrupts the layout of the
10803 table being generated, but for the moment this case is very
10805 if (psym
->st_other
^ vis
)
10806 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10809 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10810 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10811 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10813 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10817 static const char *
10818 get_symbol_version_string (FILE * file
,
10819 bfd_boolean is_dynsym
,
10820 const char * strtab
,
10821 unsigned long int strtab_size
,
10823 Elf_Internal_Sym
* psym
,
10824 enum versioned_symbol_info
* sym_info
,
10825 unsigned short * vna_other
)
10827 unsigned char data
[2];
10828 unsigned short vers_data
;
10829 unsigned long offset
;
10832 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10835 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10836 sizeof data
+ si
* sizeof (vers_data
));
10838 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10839 sizeof (data
), 1, _("version data")) == NULL
)
10842 vers_data
= byte_get (data
, 2);
10844 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10847 /* Usually we'd only see verdef for defined symbols, and verneed for
10848 undefined symbols. However, symbols defined by the linker in
10849 .dynbss for variables copied from a shared library in order to
10850 avoid text relocations are defined yet have verneed. We could
10851 use a heuristic to detect the special case, for example, check
10852 for verneed first on symbols defined in SHT_NOBITS sections, but
10853 it is simpler and more reliable to just look for both verdef and
10854 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10856 if (psym
->st_shndx
!= SHN_UNDEF
10857 && vers_data
!= 0x8001
10858 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10860 Elf_Internal_Verdef ivd
;
10861 Elf_Internal_Verdaux ivda
;
10862 Elf_External_Verdaux evda
;
10865 off
= offset_from_vma (file
,
10866 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10867 sizeof (Elf_External_Verdef
));
10871 Elf_External_Verdef evd
;
10873 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10874 _("version def")) == NULL
)
10882 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10883 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10884 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10887 off
+= ivd
.vd_next
;
10889 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10891 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10893 off
-= ivd
.vd_next
;
10896 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10897 _("version def aux")) != NULL
)
10899 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10901 if (psym
->st_name
!= ivda
.vda_name
)
10903 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10904 ? symbol_hidden
: symbol_public
);
10905 return (ivda
.vda_name
< strtab_size
10906 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10912 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10914 Elf_External_Verneed evn
;
10915 Elf_Internal_Verneed ivn
;
10916 Elf_Internal_Vernaux ivna
;
10918 offset
= offset_from_vma (file
,
10919 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10923 unsigned long vna_off
;
10925 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10926 _("version need")) == NULL
)
10929 ivna
.vna_other
= 0;
10934 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10935 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10937 vna_off
= offset
+ ivn
.vn_aux
;
10941 Elf_External_Vernaux evna
;
10943 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10944 _("version need aux (3)")) == NULL
)
10947 ivna
.vna_other
= 0;
10952 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10953 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10954 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10957 vna_off
+= ivna
.vna_next
;
10959 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10961 if (ivna
.vna_other
== vers_data
)
10964 offset
+= ivn
.vn_next
;
10966 while (ivn
.vn_next
!= 0);
10968 if (ivna
.vna_other
== vers_data
)
10970 *sym_info
= symbol_undefined
;
10971 *vna_other
= ivna
.vna_other
;
10972 return (ivna
.vna_name
< strtab_size
10973 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10979 /* Dump the symbol table. */
10981 process_symbol_table (FILE * file
)
10983 Elf_Internal_Shdr
* section
;
10984 bfd_size_type nbuckets
= 0;
10985 bfd_size_type nchains
= 0;
10986 bfd_vma
* buckets
= NULL
;
10987 bfd_vma
* chains
= NULL
;
10988 bfd_vma ngnubuckets
= 0;
10989 bfd_vma
* gnubuckets
= NULL
;
10990 bfd_vma
* gnuchains
= NULL
;
10991 bfd_vma gnusymidx
= 0;
10992 bfd_size_type ngnuchains
= 0;
10994 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10997 if (dynamic_info
[DT_HASH
]
10999 || (do_using_dynamic
11001 && dynamic_strings
!= NULL
)))
11003 unsigned char nb
[8];
11004 unsigned char nc
[8];
11005 unsigned int hash_ent_size
= 4;
11007 if ((elf_header
.e_machine
== EM_ALPHA
11008 || elf_header
.e_machine
== EM_S390
11009 || elf_header
.e_machine
== EM_S390_OLD
)
11010 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11014 (archive_file_offset
11015 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11016 sizeof nb
+ sizeof nc
)),
11019 error (_("Unable to seek to start of dynamic information\n"));
11023 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11025 error (_("Failed to read in number of buckets\n"));
11029 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11031 error (_("Failed to read in number of chains\n"));
11035 nbuckets
= byte_get (nb
, hash_ent_size
);
11036 nchains
= byte_get (nc
, hash_ent_size
);
11038 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11039 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11042 if (buckets
== NULL
|| chains
== NULL
)
11044 if (do_using_dynamic
)
11055 if (dynamic_info_DT_GNU_HASH
11057 || (do_using_dynamic
11059 && dynamic_strings
!= NULL
)))
11061 unsigned char nb
[16];
11062 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11063 bfd_vma buckets_vma
;
11066 (archive_file_offset
11067 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11071 error (_("Unable to seek to start of dynamic information\n"));
11075 if (fread (nb
, 16, 1, file
) != 1)
11077 error (_("Failed to read in number of buckets\n"));
11081 ngnubuckets
= byte_get (nb
, 4);
11082 gnusymidx
= byte_get (nb
+ 4, 4);
11083 bitmaskwords
= byte_get (nb
+ 8, 4);
11084 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11086 buckets_vma
+= bitmaskwords
* 4;
11088 buckets_vma
+= bitmaskwords
* 8;
11091 (archive_file_offset
11092 + offset_from_vma (file
, buckets_vma
, 4)),
11095 error (_("Unable to seek to start of dynamic information\n"));
11099 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11101 if (gnubuckets
== NULL
)
11104 for (i
= 0; i
< ngnubuckets
; i
++)
11105 if (gnubuckets
[i
] != 0)
11107 if (gnubuckets
[i
] < gnusymidx
)
11110 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11111 maxchain
= gnubuckets
[i
];
11114 if (maxchain
== 0xffffffff)
11117 maxchain
-= gnusymidx
;
11120 (archive_file_offset
11121 + offset_from_vma (file
, buckets_vma
11122 + 4 * (ngnubuckets
+ maxchain
), 4)),
11125 error (_("Unable to seek to start of dynamic information\n"));
11131 if (fread (nb
, 4, 1, file
) != 1)
11133 error (_("Failed to determine last chain length\n"));
11137 if (maxchain
+ 1 == 0)
11142 while ((byte_get (nb
, 4) & 1) == 0);
11145 (archive_file_offset
11146 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11149 error (_("Unable to seek to start of dynamic information\n"));
11153 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11154 ngnuchains
= maxchain
;
11157 if (gnuchains
== NULL
)
11162 if (do_using_dynamic
)
11167 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11169 && do_using_dynamic
11170 && dynamic_strings
!= NULL
11171 && dynamic_symbols
!= NULL
)
11175 if (dynamic_info
[DT_HASH
])
11179 printf (_("\nSymbol table for image:\n"));
11181 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11183 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11185 for (hn
= 0; hn
< nbuckets
; hn
++)
11190 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11191 print_dynamic_symbol (si
, hn
);
11195 if (dynamic_info_DT_GNU_HASH
)
11197 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11199 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11201 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11203 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11204 if (gnubuckets
[hn
] != 0)
11206 bfd_vma si
= gnubuckets
[hn
];
11207 bfd_vma off
= si
- gnusymidx
;
11211 print_dynamic_symbol (si
, hn
);
11214 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11218 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11219 && section_headers
!= NULL
)
11223 for (i
= 0, section
= section_headers
;
11224 i
< elf_header
.e_shnum
;
11228 char * strtab
= NULL
;
11229 unsigned long int strtab_size
= 0;
11230 Elf_Internal_Sym
* symtab
;
11231 Elf_Internal_Sym
* psym
;
11232 unsigned long num_syms
;
11234 if ((section
->sh_type
!= SHT_SYMTAB
11235 && section
->sh_type
!= SHT_DYNSYM
)
11237 && section
->sh_type
== SHT_SYMTAB
))
11240 if (section
->sh_entsize
== 0)
11242 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11243 printable_section_name (section
));
11247 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11248 printable_section_name (section
),
11249 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11252 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11254 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11256 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11257 if (symtab
== NULL
)
11260 if (section
->sh_link
== elf_header
.e_shstrndx
)
11262 strtab
= string_table
;
11263 strtab_size
= string_table_length
;
11265 else if (section
->sh_link
< elf_header
.e_shnum
)
11267 Elf_Internal_Shdr
* string_sec
;
11269 string_sec
= section_headers
+ section
->sh_link
;
11271 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11272 1, string_sec
->sh_size
,
11273 _("string table"));
11274 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11277 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11279 const char *version_string
;
11280 enum versioned_symbol_info sym_info
;
11281 unsigned short vna_other
;
11283 printf ("%6d: ", si
);
11284 print_vma (psym
->st_value
, LONG_HEX
);
11286 print_vma (psym
->st_size
, DEC_5
);
11287 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11288 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11289 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11290 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11293 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11295 printf (" %-7s", get_symbol_visibility (vis
));
11296 /* Check to see if any other bits in the st_other field are set.
11297 Note - displaying this information disrupts the layout of the
11298 table being generated, but for the moment this case is very rare. */
11299 if (psym
->st_other
^ vis
)
11300 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11302 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11303 print_symbol (25, psym
->st_name
< strtab_size
11304 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11307 = get_symbol_version_string (file
,
11308 section
->sh_type
== SHT_DYNSYM
,
11309 strtab
, strtab_size
, si
,
11310 psym
, &sym_info
, &vna_other
);
11311 if (version_string
)
11313 if (sym_info
== symbol_undefined
)
11314 printf ("@%s (%d)", version_string
, vna_other
);
11316 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11322 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11323 && si
>= section
->sh_info
11324 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11325 && elf_header
.e_machine
!= EM_MIPS
11326 /* Solaris binaries have been found to violate this requirement as
11327 well. Not sure if this is a bug or an ABI requirement. */
11328 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11329 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11330 si
, printable_section_name (section
), section
->sh_info
);
11334 if (strtab
!= string_table
)
11340 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11342 if (do_histogram
&& buckets
!= NULL
)
11344 unsigned long * lengths
;
11345 unsigned long * counts
;
11348 unsigned long maxlength
= 0;
11349 unsigned long nzero_counts
= 0;
11350 unsigned long nsyms
= 0;
11351 unsigned long chained
;
11353 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11354 (unsigned long) nbuckets
);
11356 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11357 if (lengths
== NULL
)
11359 error (_("Out of memory allocating space for histogram buckets\n"));
11363 printf (_(" Length Number %% of total Coverage\n"));
11364 for (hn
= 0; hn
< nbuckets
; ++hn
)
11366 for (si
= buckets
[hn
], chained
= 0;
11367 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11368 si
= chains
[si
], ++chained
)
11371 if (maxlength
< ++lengths
[hn
])
11375 /* PR binutils/17531: A corrupt binary could contain broken
11376 histogram data. Do not go into an infinite loop trying
11378 if (chained
> nchains
)
11380 error (_("histogram chain is corrupt\n"));
11385 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11386 if (counts
== NULL
)
11389 error (_("Out of memory allocating space for histogram counts\n"));
11393 for (hn
= 0; hn
< nbuckets
; ++hn
)
11394 ++counts
[lengths
[hn
]];
11399 printf (" 0 %-10lu (%5.1f%%)\n",
11400 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11401 for (i
= 1; i
<= maxlength
; ++i
)
11403 nzero_counts
+= counts
[i
] * i
;
11404 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11405 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11406 (nzero_counts
* 100.0) / nsyms
);
11414 if (buckets
!= NULL
)
11420 if (do_histogram
&& gnubuckets
!= NULL
)
11422 unsigned long * lengths
;
11423 unsigned long * counts
;
11425 unsigned long maxlength
= 0;
11426 unsigned long nzero_counts
= 0;
11427 unsigned long nsyms
= 0;
11429 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11430 (unsigned long) ngnubuckets
);
11432 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11433 if (lengths
== NULL
)
11435 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11439 printf (_(" Length Number %% of total Coverage\n"));
11441 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11442 if (gnubuckets
[hn
] != 0)
11444 bfd_vma off
, length
= 1;
11446 for (off
= gnubuckets
[hn
] - gnusymidx
;
11447 /* PR 17531 file: 010-77222-0.004. */
11448 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11451 lengths
[hn
] = length
;
11452 if (length
> maxlength
)
11453 maxlength
= length
;
11457 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11458 if (counts
== NULL
)
11461 error (_("Out of memory allocating space for gnu histogram counts\n"));
11465 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11466 ++counts
[lengths
[hn
]];
11468 if (ngnubuckets
> 0)
11471 printf (" 0 %-10lu (%5.1f%%)\n",
11472 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11473 for (j
= 1; j
<= maxlength
; ++j
)
11475 nzero_counts
+= counts
[j
] * j
;
11476 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11477 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11478 (nzero_counts
* 100.0) / nsyms
);
11492 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11496 if (dynamic_syminfo
== NULL
11498 /* No syminfo, this is ok. */
11501 /* There better should be a dynamic symbol section. */
11502 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11506 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11507 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11509 printf (_(" Num: Name BoundTo Flags\n"));
11510 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11512 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11514 printf ("%4d: ", i
);
11515 if (i
>= num_dynamic_syms
)
11516 printf (_("<corrupt index>"));
11517 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11518 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11520 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11523 switch (dynamic_syminfo
[i
].si_boundto
)
11525 case SYMINFO_BT_SELF
:
11526 fputs ("SELF ", stdout
);
11528 case SYMINFO_BT_PARENT
:
11529 fputs ("PARENT ", stdout
);
11532 if (dynamic_syminfo
[i
].si_boundto
> 0
11533 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11534 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11536 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11540 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11544 if (flags
& SYMINFO_FLG_DIRECT
)
11545 printf (" DIRECT");
11546 if (flags
& SYMINFO_FLG_PASSTHRU
)
11547 printf (" PASSTHRU");
11548 if (flags
& SYMINFO_FLG_COPY
)
11550 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11551 printf (" LAZYLOAD");
11559 /* Check to see if the given reloc needs to be handled in a target specific
11560 manner. If so then process the reloc and return TRUE otherwise return
11564 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11565 unsigned char * start
,
11566 Elf_Internal_Sym
* symtab
)
11568 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11570 switch (elf_header
.e_machine
)
11573 case EM_MSP430_OLD
:
11575 static Elf_Internal_Sym
* saved_sym
= NULL
;
11577 switch (reloc_type
)
11579 case 10: /* R_MSP430_SYM_DIFF */
11580 if (uses_msp430x_relocs ())
11582 /* Fall through. */
11583 case 21: /* R_MSP430X_SYM_DIFF */
11584 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11587 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11588 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11589 goto handle_sym_diff
;
11591 case 5: /* R_MSP430_16_BYTE */
11592 case 9: /* R_MSP430_8 */
11593 if (uses_msp430x_relocs ())
11595 goto handle_sym_diff
;
11597 case 2: /* R_MSP430_ABS16 */
11598 case 15: /* R_MSP430X_ABS16 */
11599 if (! uses_msp430x_relocs ())
11601 goto handle_sym_diff
;
11604 if (saved_sym
!= NULL
)
11608 value
= reloc
->r_addend
11609 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11610 - saved_sym
->st_value
);
11612 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11620 if (saved_sym
!= NULL
)
11621 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11628 case EM_CYGNUS_MN10300
:
11630 static Elf_Internal_Sym
* saved_sym
= NULL
;
11632 switch (reloc_type
)
11634 case 34: /* R_MN10300_ALIGN */
11636 case 33: /* R_MN10300_SYM_DIFF */
11637 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11639 case 1: /* R_MN10300_32 */
11640 case 2: /* R_MN10300_16 */
11641 if (saved_sym
!= NULL
)
11645 value
= reloc
->r_addend
11646 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11647 - saved_sym
->st_value
);
11649 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11656 if (saved_sym
!= NULL
)
11657 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11665 static bfd_vma saved_sym1
= 0;
11666 static bfd_vma saved_sym2
= 0;
11667 static bfd_vma value
;
11669 switch (reloc_type
)
11671 case 0x80: /* R_RL78_SYM. */
11672 saved_sym1
= saved_sym2
;
11673 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11674 saved_sym2
+= reloc
->r_addend
;
11677 case 0x83: /* R_RL78_OPsub. */
11678 value
= saved_sym1
- saved_sym2
;
11679 saved_sym2
= saved_sym1
= 0;
11683 case 0x41: /* R_RL78_ABS32. */
11684 byte_put (start
+ reloc
->r_offset
, value
, 4);
11688 case 0x43: /* R_RL78_ABS16. */
11689 byte_put (start
+ reloc
->r_offset
, value
, 2);
11703 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11704 DWARF debug sections. This is a target specific test. Note - we do not
11705 go through the whole including-target-headers-multiple-times route, (as
11706 we have already done with <elf/h8.h>) because this would become very
11707 messy and even then this function would have to contain target specific
11708 information (the names of the relocs instead of their numeric values).
11709 FIXME: This is not the correct way to solve this problem. The proper way
11710 is to have target specific reloc sizing and typing functions created by
11711 the reloc-macros.h header, in the same way that it already creates the
11712 reloc naming functions. */
11715 is_32bit_abs_reloc (unsigned int reloc_type
)
11717 /* Please keep this table alpha-sorted for ease of visual lookup. */
11718 switch (elf_header
.e_machine
)
11722 return reloc_type
== 1; /* R_386_32. */
11724 return reloc_type
== 1; /* R_68K_32. */
11726 return reloc_type
== 1; /* R_860_32. */
11728 return reloc_type
== 2; /* R_960_32. */
11730 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11731 case EM_ADAPTEVA_EPIPHANY
:
11732 return reloc_type
== 3;
11734 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11736 return reloc_type
== 1; /* R_ARC_32. */
11737 case EM_ARC_COMPACT
:
11738 case EM_ARC_COMPACT2
:
11739 return reloc_type
== 4; /* R_ARC_32. */
11741 return reloc_type
== 2; /* R_ARM_ABS32 */
11744 return reloc_type
== 1;
11746 return reloc_type
== 0x12; /* R_byte4_data. */
11748 return reloc_type
== 3; /* R_CRIS_32. */
11750 return reloc_type
== 3; /* R_CR16_NUM32. */
11752 return reloc_type
== 15; /* R_CRX_NUM32. */
11753 case EM_CYGNUS_FRV
:
11754 return reloc_type
== 1;
11755 case EM_CYGNUS_D10V
:
11757 return reloc_type
== 6; /* R_D10V_32. */
11758 case EM_CYGNUS_D30V
:
11760 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11762 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11763 case EM_CYGNUS_FR30
:
11765 return reloc_type
== 3; /* R_FR30_32. */
11767 return reloc_type
== 1; /* R_FT32_32. */
11771 return reloc_type
== 1; /* R_H8_DIR32. */
11773 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11774 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11777 return reloc_type
== 2; /* R_IP2K_32. */
11779 return reloc_type
== 2; /* R_IQ2000_32. */
11780 case EM_LATTICEMICO32
:
11781 return reloc_type
== 3; /* R_LM32_32. */
11784 return reloc_type
== 3; /* R_M32C_32. */
11786 return reloc_type
== 34; /* R_M32R_32_RELA. */
11789 return reloc_type
== 6; /* R_M68HC11_32. */
11791 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11792 case EM_CYGNUS_MEP
:
11793 return reloc_type
== 4; /* R_MEP_32. */
11795 return reloc_type
== 2; /* R_METAG_ADDR32. */
11796 case EM_MICROBLAZE
:
11797 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11799 return reloc_type
== 2; /* R_MIPS_32. */
11801 return reloc_type
== 4; /* R_MMIX_32. */
11802 case EM_CYGNUS_MN10200
:
11804 return reloc_type
== 1; /* R_MN10200_32. */
11805 case EM_CYGNUS_MN10300
:
11807 return reloc_type
== 1; /* R_MN10300_32. */
11809 return reloc_type
== 1; /* R_MOXIE_32. */
11810 case EM_MSP430_OLD
:
11812 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11814 return reloc_type
== 2; /* R_MT_32. */
11816 return reloc_type
== 20; /* R_NDS32_RELA. */
11817 case EM_ALTERA_NIOS2
:
11818 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11820 return reloc_type
== 1; /* R_NIOS_32. */
11822 return reloc_type
== 1; /* R_OR1K_32. */
11824 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11825 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11828 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11830 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11832 return reloc_type
== 1; /* R_PPC_ADDR32. */
11834 return reloc_type
== 1; /* R_RISCV_32. */
11836 return reloc_type
== 1; /* R_RL78_DIR32. */
11838 return reloc_type
== 1; /* R_RX_DIR32. */
11840 return reloc_type
== 1; /* R_I370_ADDR31. */
11843 return reloc_type
== 4; /* R_S390_32. */
11845 return reloc_type
== 8; /* R_SCORE_ABS32. */
11847 return reloc_type
== 1; /* R_SH_DIR32. */
11848 case EM_SPARC32PLUS
:
11851 return reloc_type
== 3 /* R_SPARC_32. */
11852 || reloc_type
== 23; /* R_SPARC_UA32. */
11854 return reloc_type
== 6; /* R_SPU_ADDR32 */
11856 return reloc_type
== 1; /* R_C6000_ABS32. */
11858 return reloc_type
== 2; /* R_TILEGX_32. */
11860 return reloc_type
== 1; /* R_TILEPRO_32. */
11861 case EM_CYGNUS_V850
:
11863 return reloc_type
== 6; /* R_V850_ABS32. */
11865 return reloc_type
== 0x33; /* R_V810_WORD. */
11867 return reloc_type
== 1; /* R_VAX_32. */
11869 return reloc_type
== 3; /* R_VISIUM_32. */
11873 return reloc_type
== 10; /* R_X86_64_32. */
11876 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11878 return reloc_type
== 4; /* R_XGATE_32. */
11880 return reloc_type
== 1; /* R_XSTROMY16_32. */
11881 case EM_XTENSA_OLD
:
11883 return reloc_type
== 1; /* R_XTENSA_32. */
11886 static unsigned int prev_warn
= 0;
11888 /* Avoid repeating the same warning multiple times. */
11889 if (prev_warn
!= elf_header
.e_machine
)
11890 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11891 elf_header
.e_machine
);
11892 prev_warn
= elf_header
.e_machine
;
11898 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11899 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11902 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11904 switch (elf_header
.e_machine
)
11905 /* Please keep this table alpha-sorted for ease of visual lookup. */
11909 return reloc_type
== 2; /* R_386_PC32. */
11911 return reloc_type
== 4; /* R_68K_PC32. */
11913 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11914 case EM_ADAPTEVA_EPIPHANY
:
11915 return reloc_type
== 6;
11917 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11918 case EM_ARC_COMPACT
:
11919 case EM_ARC_COMPACT2
:
11920 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11922 return reloc_type
== 3; /* R_ARM_REL32 */
11925 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11926 case EM_MICROBLAZE
:
11927 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11929 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11931 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11933 return reloc_type
== 26; /* R_PPC_REL32. */
11935 return reloc_type
== 26; /* R_PPC64_REL32. */
11938 return reloc_type
== 5; /* R_390_PC32. */
11940 return reloc_type
== 2; /* R_SH_REL32. */
11941 case EM_SPARC32PLUS
:
11944 return reloc_type
== 6; /* R_SPARC_DISP32. */
11946 return reloc_type
== 13; /* R_SPU_REL32. */
11948 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11950 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11952 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11956 return reloc_type
== 2; /* R_X86_64_PC32. */
11957 case EM_XTENSA_OLD
:
11959 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11961 /* Do not abort or issue an error message here. Not all targets use
11962 pc-relative 32-bit relocs in their DWARF debug information and we
11963 have already tested for target coverage in is_32bit_abs_reloc. A
11964 more helpful warning message will be generated by apply_relocations
11965 anyway, so just return. */
11970 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11971 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11974 is_64bit_abs_reloc (unsigned int reloc_type
)
11976 switch (elf_header
.e_machine
)
11979 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11981 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11983 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11985 return reloc_type
== 80; /* R_PARISC_DIR64. */
11987 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11989 return reloc_type
== 2; /* R_RISCV_64. */
11990 case EM_SPARC32PLUS
:
11993 return reloc_type
== 54; /* R_SPARC_UA64. */
11997 return reloc_type
== 1; /* R_X86_64_64. */
12000 return reloc_type
== 22; /* R_S390_64. */
12002 return reloc_type
== 1; /* R_TILEGX_64. */
12004 return reloc_type
== 18; /* R_MIPS_64. */
12010 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12011 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12014 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12016 switch (elf_header
.e_machine
)
12019 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12021 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12023 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12025 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12027 return reloc_type
== 44; /* R_PPC64_REL64. */
12028 case EM_SPARC32PLUS
:
12031 return reloc_type
== 46; /* R_SPARC_DISP64. */
12035 return reloc_type
== 24; /* R_X86_64_PC64. */
12038 return reloc_type
== 23; /* R_S390_PC64. */
12040 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12047 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12050 is_24bit_abs_reloc (unsigned int reloc_type
)
12052 switch (elf_header
.e_machine
)
12054 case EM_CYGNUS_MN10200
:
12056 return reloc_type
== 4; /* R_MN10200_24. */
12058 return reloc_type
== 5; /* R_FT32_20. */
12064 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12065 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12068 is_16bit_abs_reloc (unsigned int reloc_type
)
12070 /* Please keep this table alpha-sorted for ease of visual lookup. */
12071 switch (elf_header
.e_machine
)
12074 case EM_ARC_COMPACT
:
12075 case EM_ARC_COMPACT2
:
12076 return reloc_type
== 2; /* R_ARC_16. */
12077 case EM_ADAPTEVA_EPIPHANY
:
12078 return reloc_type
== 5;
12081 return reloc_type
== 4; /* R_AVR_16. */
12082 case EM_CYGNUS_D10V
:
12084 return reloc_type
== 3; /* R_D10V_16. */
12088 return reloc_type
== R_H8_DIR16
;
12091 return reloc_type
== 1; /* R_IP2K_16. */
12094 return reloc_type
== 1; /* R_M32C_16 */
12095 case EM_CYGNUS_MN10200
:
12097 return reloc_type
== 2; /* R_MN10200_16. */
12098 case EM_CYGNUS_MN10300
:
12100 return reloc_type
== 2; /* R_MN10300_16. */
12102 if (uses_msp430x_relocs ())
12103 return reloc_type
== 2; /* R_MSP430_ABS16. */
12104 /* Fall through. */
12105 case EM_MSP430_OLD
:
12106 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12108 return reloc_type
== 19; /* R_NDS32_RELA. */
12109 case EM_ALTERA_NIOS2
:
12110 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12112 return reloc_type
== 9; /* R_NIOS_16. */
12114 return reloc_type
== 2; /* R_OR1K_16. */
12116 return reloc_type
== 2; /* R_C6000_ABS16. */
12118 return reloc_type
== 2; /* R_VISIUM_16. */
12121 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12123 return reloc_type
== 3; /* R_XGATE_16. */
12129 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12130 relocation entries (possibly formerly used for SHT_GROUP sections). */
12133 is_none_reloc (unsigned int reloc_type
)
12135 switch (elf_header
.e_machine
)
12137 case EM_386
: /* R_386_NONE. */
12138 case EM_68K
: /* R_68K_NONE. */
12139 case EM_ADAPTEVA_EPIPHANY
:
12140 case EM_ALPHA
: /* R_ALPHA_NONE. */
12141 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12142 case EM_ARC
: /* R_ARC_NONE. */
12143 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12144 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12145 case EM_ARM
: /* R_ARM_NONE. */
12146 case EM_C166
: /* R_XC16X_NONE. */
12147 case EM_CRIS
: /* R_CRIS_NONE. */
12148 case EM_FT32
: /* R_FT32_NONE. */
12149 case EM_IA_64
: /* R_IA64_NONE. */
12150 case EM_K1OM
: /* R_X86_64_NONE. */
12151 case EM_L1OM
: /* R_X86_64_NONE. */
12152 case EM_M32R
: /* R_M32R_NONE. */
12153 case EM_MIPS
: /* R_MIPS_NONE. */
12154 case EM_MN10300
: /* R_MN10300_NONE. */
12155 case EM_MOXIE
: /* R_MOXIE_NONE. */
12156 case EM_NIOS32
: /* R_NIOS_NONE. */
12157 case EM_OR1K
: /* R_OR1K_NONE. */
12158 case EM_PARISC
: /* R_PARISC_NONE. */
12159 case EM_PPC64
: /* R_PPC64_NONE. */
12160 case EM_PPC
: /* R_PPC_NONE. */
12161 case EM_RISCV
: /* R_RISCV_NONE. */
12162 case EM_S390
: /* R_390_NONE. */
12164 case EM_SH
: /* R_SH_NONE. */
12165 case EM_SPARC32PLUS
:
12166 case EM_SPARC
: /* R_SPARC_NONE. */
12168 case EM_TILEGX
: /* R_TILEGX_NONE. */
12169 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12170 case EM_TI_C6000
:/* R_C6000_NONE. */
12171 case EM_X86_64
: /* R_X86_64_NONE. */
12173 return reloc_type
== 0;
12176 return reloc_type
== 0 || reloc_type
== 256;
12179 return (reloc_type
== 0 /* R_AVR_NONE. */
12180 || reloc_type
== 30 /* R_AVR_DIFF8. */
12181 || reloc_type
== 31 /* R_AVR_DIFF16. */
12182 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12184 return reloc_type
== 3; /* R_METAG_NONE. */
12186 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12187 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12188 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12189 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12190 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12191 case EM_XTENSA_OLD
:
12193 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12194 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12195 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12196 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12201 /* Returns TRUE if there is a relocation against
12202 section NAME at OFFSET bytes. */
12205 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12207 Elf_Internal_Rela
* relocs
;
12208 Elf_Internal_Rela
* rp
;
12210 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12213 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12215 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12216 if (rp
->r_offset
== offset
)
12222 /* Apply relocations to a section.
12223 Note: So far support has been added only for those relocations
12224 which can be found in debug sections.
12225 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12226 loaded relocs. It is then the caller's responsibility to free them.
12227 FIXME: Add support for more relocations ? */
12230 apply_relocations (void * file
,
12231 const Elf_Internal_Shdr
* section
,
12232 unsigned char * start
,
12233 bfd_size_type size
,
12234 void ** relocs_return
,
12235 unsigned long * num_relocs_return
)
12237 Elf_Internal_Shdr
* relsec
;
12238 unsigned char * end
= start
+ size
;
12240 if (relocs_return
!= NULL
)
12242 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12243 * num_relocs_return
= 0;
12246 if (elf_header
.e_type
!= ET_REL
)
12249 /* Find the reloc section associated with the section. */
12250 for (relsec
= section_headers
;
12251 relsec
< section_headers
+ elf_header
.e_shnum
;
12254 bfd_boolean is_rela
;
12255 unsigned long num_relocs
;
12256 Elf_Internal_Rela
* relocs
;
12257 Elf_Internal_Rela
* rp
;
12258 Elf_Internal_Shdr
* symsec
;
12259 Elf_Internal_Sym
* symtab
;
12260 unsigned long num_syms
;
12261 Elf_Internal_Sym
* sym
;
12263 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12264 || relsec
->sh_info
>= elf_header
.e_shnum
12265 || section_headers
+ relsec
->sh_info
!= section
12266 || relsec
->sh_size
== 0
12267 || relsec
->sh_link
>= elf_header
.e_shnum
)
12270 is_rela
= relsec
->sh_type
== SHT_RELA
;
12274 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12275 relsec
->sh_size
, & relocs
, & num_relocs
))
12280 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12281 relsec
->sh_size
, & relocs
, & num_relocs
))
12285 /* SH uses RELA but uses in place value instead of the addend field. */
12286 if (elf_header
.e_machine
== EM_SH
)
12289 symsec
= section_headers
+ relsec
->sh_link
;
12290 if (symsec
->sh_type
!= SHT_SYMTAB
12291 && symsec
->sh_type
!= SHT_DYNSYM
)
12293 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12295 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12298 unsigned int reloc_type
;
12299 unsigned int reloc_size
;
12300 unsigned char * rloc
;
12301 unsigned long sym_index
;
12303 reloc_type
= get_reloc_type (rp
->r_info
);
12305 if (target_specific_reloc_handling (rp
, start
, symtab
))
12307 else if (is_none_reloc (reloc_type
))
12309 else if (is_32bit_abs_reloc (reloc_type
)
12310 || is_32bit_pcrel_reloc (reloc_type
))
12312 else if (is_64bit_abs_reloc (reloc_type
)
12313 || is_64bit_pcrel_reloc (reloc_type
))
12315 else if (is_24bit_abs_reloc (reloc_type
))
12317 else if (is_16bit_abs_reloc (reloc_type
))
12321 static unsigned int prev_reloc
= 0;
12322 if (reloc_type
!= prev_reloc
)
12323 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12324 reloc_type
, printable_section_name (section
));
12325 prev_reloc
= reloc_type
;
12329 rloc
= start
+ rp
->r_offset
;
12330 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12332 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12333 (unsigned long) rp
->r_offset
,
12334 printable_section_name (section
));
12338 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12339 if (sym_index
>= num_syms
)
12341 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12342 sym_index
, printable_section_name (section
));
12345 sym
= symtab
+ sym_index
;
12347 /* If the reloc has a symbol associated with it,
12348 make sure that it is of an appropriate type.
12350 Relocations against symbols without type can happen.
12351 Gcc -feliminate-dwarf2-dups may generate symbols
12352 without type for debug info.
12354 Icc generates relocations against function symbols
12355 instead of local labels.
12357 Relocations against object symbols can happen, eg when
12358 referencing a global array. For an example of this see
12359 the _clz.o binary in libgcc.a. */
12361 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12362 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12364 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12365 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12366 (long int)(rp
- relocs
),
12367 printable_section_name (relsec
));
12373 addend
+= rp
->r_addend
;
12374 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12375 partial_inplace. */
12377 || (elf_header
.e_machine
== EM_XTENSA
12378 && reloc_type
== 1)
12379 || ((elf_header
.e_machine
== EM_PJ
12380 || elf_header
.e_machine
== EM_PJ_OLD
)
12381 && reloc_type
== 1)
12382 || ((elf_header
.e_machine
== EM_D30V
12383 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12384 && reloc_type
== 12))
12385 addend
+= byte_get (rloc
, reloc_size
);
12387 if (is_32bit_pcrel_reloc (reloc_type
)
12388 || is_64bit_pcrel_reloc (reloc_type
))
12390 /* On HPPA, all pc-relative relocations are biased by 8. */
12391 if (elf_header
.e_machine
== EM_PARISC
)
12393 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12397 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12404 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12405 * num_relocs_return
= num_relocs
;
12414 #ifdef SUPPORT_DISASSEMBLY
12416 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12418 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12420 /* FIXME: XXX -- to be done --- XXX */
12426 /* Reads in the contents of SECTION from FILE, returning a pointer
12427 to a malloc'ed buffer or NULL if something went wrong. */
12430 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12432 bfd_size_type num_bytes
;
12434 num_bytes
= section
->sh_size
;
12436 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12438 printf (_("\nSection '%s' has no data to dump.\n"),
12439 printable_section_name (section
));
12443 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12444 _("section contents"));
12447 /* Uncompresses a section that was compressed using zlib, in place. */
12450 uncompress_section_contents (unsigned char **buffer
,
12451 dwarf_size_type uncompressed_size
,
12452 dwarf_size_type
*size
)
12454 dwarf_size_type compressed_size
= *size
;
12455 unsigned char * compressed_buffer
= *buffer
;
12456 unsigned char * uncompressed_buffer
;
12460 /* It is possible the section consists of several compressed
12461 buffers concatenated together, so we uncompress in a loop. */
12462 /* PR 18313: The state field in the z_stream structure is supposed
12463 to be invisible to the user (ie us), but some compilers will
12464 still complain about it being used without initialisation. So
12465 we first zero the entire z_stream structure and then set the fields
12467 memset (& strm
, 0, sizeof strm
);
12468 strm
.avail_in
= compressed_size
;
12469 strm
.next_in
= (Bytef
*) compressed_buffer
;
12470 strm
.avail_out
= uncompressed_size
;
12471 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12473 rc
= inflateInit (& strm
);
12474 while (strm
.avail_in
> 0)
12478 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12479 + (uncompressed_size
- strm
.avail_out
));
12480 rc
= inflate (&strm
, Z_FINISH
);
12481 if (rc
!= Z_STREAM_END
)
12483 rc
= inflateReset (& strm
);
12485 rc
= inflateEnd (& strm
);
12487 || strm
.avail_out
!= 0)
12490 *buffer
= uncompressed_buffer
;
12491 *size
= uncompressed_size
;
12495 free (uncompressed_buffer
);
12496 /* Indicate decompression failure. */
12502 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12504 Elf_Internal_Shdr
* relsec
;
12505 bfd_size_type num_bytes
;
12506 unsigned char * data
;
12507 unsigned char * end
;
12508 unsigned char * real_start
;
12509 unsigned char * start
;
12510 bfd_boolean some_strings_shown
;
12512 real_start
= start
= (unsigned char *) get_section_contents (section
,
12516 num_bytes
= section
->sh_size
;
12518 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12520 if (decompress_dumps
)
12522 dwarf_size_type new_size
= num_bytes
;
12523 dwarf_size_type uncompressed_size
= 0;
12525 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12527 Elf_Internal_Chdr chdr
;
12528 unsigned int compression_header_size
12529 = get_compression_header (& chdr
, (unsigned char *) start
);
12531 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12533 warn (_("section '%s' has unsupported compress type: %d\n"),
12534 printable_section_name (section
), chdr
.ch_type
);
12537 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12539 warn (_("compressed section '%s' is corrupted\n"),
12540 printable_section_name (section
));
12543 uncompressed_size
= chdr
.ch_size
;
12544 start
+= compression_header_size
;
12545 new_size
-= compression_header_size
;
12547 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12549 /* Read the zlib header. In this case, it should be "ZLIB"
12550 followed by the uncompressed section size, 8 bytes in
12551 big-endian order. */
12552 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12553 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12554 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12555 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12556 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12557 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12558 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12559 uncompressed_size
+= start
[11];
12564 if (uncompressed_size
12565 && uncompress_section_contents (& start
,
12566 uncompressed_size
, & new_size
))
12567 num_bytes
= new_size
;
12570 /* If the section being dumped has relocations against it the user might
12571 be expecting these relocations to have been applied. Check for this
12572 case and issue a warning message in order to avoid confusion.
12573 FIXME: Maybe we ought to have an option that dumps a section with
12574 relocs applied ? */
12575 for (relsec
= section_headers
;
12576 relsec
< section_headers
+ elf_header
.e_shnum
;
12579 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12580 || relsec
->sh_info
>= elf_header
.e_shnum
12581 || section_headers
+ relsec
->sh_info
!= section
12582 || relsec
->sh_size
== 0
12583 || relsec
->sh_link
>= elf_header
.e_shnum
)
12586 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12591 end
= start
+ num_bytes
;
12592 some_strings_shown
= FALSE
;
12596 while (!ISPRINT (* data
))
12597 if (++ data
>= end
)
12602 size_t maxlen
= end
- data
;
12605 /* PR 11128: Use two separate invocations in order to work
12606 around bugs in the Solaris 8 implementation of printf. */
12607 printf (" [%6tx] ", data
- start
);
12609 printf (" [%6Ix] ", (size_t) (data
- start
));
12613 print_symbol ((int) maxlen
, (const char *) data
);
12615 data
+= strnlen ((const char *) data
, maxlen
);
12619 printf (_("<corrupt>\n"));
12622 some_strings_shown
= TRUE
;
12626 if (! some_strings_shown
)
12627 printf (_(" No strings found in this section."));
12635 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12637 bfd_boolean relocate
)
12639 Elf_Internal_Shdr
* relsec
;
12640 bfd_size_type bytes
;
12641 bfd_size_type section_size
;
12643 unsigned char * data
;
12644 unsigned char * real_start
;
12645 unsigned char * start
;
12647 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12650 section_size
= section
->sh_size
;
12652 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12654 if (decompress_dumps
)
12656 dwarf_size_type new_size
= section_size
;
12657 dwarf_size_type uncompressed_size
= 0;
12659 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12661 Elf_Internal_Chdr chdr
;
12662 unsigned int compression_header_size
12663 = get_compression_header (& chdr
, start
);
12665 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12667 warn (_("section '%s' has unsupported compress type: %d\n"),
12668 printable_section_name (section
), chdr
.ch_type
);
12671 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12673 warn (_("compressed section '%s' is corrupted\n"),
12674 printable_section_name (section
));
12677 uncompressed_size
= chdr
.ch_size
;
12678 start
+= compression_header_size
;
12679 new_size
-= compression_header_size
;
12681 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12683 /* Read the zlib header. In this case, it should be "ZLIB"
12684 followed by the uncompressed section size, 8 bytes in
12685 big-endian order. */
12686 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12687 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12688 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12689 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12690 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12691 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12692 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12693 uncompressed_size
+= start
[11];
12698 if (uncompressed_size
12699 && uncompress_section_contents (& start
, uncompressed_size
,
12701 section_size
= new_size
;
12706 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12710 /* If the section being dumped has relocations against it the user might
12711 be expecting these relocations to have been applied. Check for this
12712 case and issue a warning message in order to avoid confusion.
12713 FIXME: Maybe we ought to have an option that dumps a section with
12714 relocs applied ? */
12715 for (relsec
= section_headers
;
12716 relsec
< section_headers
+ elf_header
.e_shnum
;
12719 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12720 || relsec
->sh_info
>= elf_header
.e_shnum
12721 || section_headers
+ relsec
->sh_info
!= section
12722 || relsec
->sh_size
== 0
12723 || relsec
->sh_link
>= elf_header
.e_shnum
)
12726 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12731 addr
= section
->sh_addr
;
12732 bytes
= section_size
;
12741 lbytes
= (bytes
> 16 ? 16 : bytes
);
12743 printf (" 0x%8.8lx ", (unsigned long) addr
);
12745 for (j
= 0; j
< 16; j
++)
12748 printf ("%2.2x", data
[j
]);
12756 for (j
= 0; j
< lbytes
; j
++)
12759 if (k
>= ' ' && k
< 0x7f)
12778 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12779 const Elf_Internal_Shdr
* sec
, void * file
)
12781 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12784 /* If it is already loaded, do nothing. */
12785 if (section
->start
!= NULL
)
12788 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12789 section
->address
= sec
->sh_addr
;
12790 section
->user_data
= NULL
;
12791 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12793 sec
->sh_size
, buf
);
12794 if (section
->start
== NULL
)
12798 unsigned char *start
= section
->start
;
12799 dwarf_size_type size
= sec
->sh_size
;
12800 dwarf_size_type uncompressed_size
= 0;
12802 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12804 Elf_Internal_Chdr chdr
;
12805 unsigned int compression_header_size
;
12807 if (size
< (is_32bit_elf
12808 ? sizeof (Elf32_External_Chdr
)
12809 : sizeof (Elf64_External_Chdr
)))
12811 warn (_("compressed section %s is too small to contain a compression header"),
12816 compression_header_size
= get_compression_header (&chdr
, start
);
12818 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12820 warn (_("section '%s' has unsupported compress type: %d\n"),
12821 section
->name
, chdr
.ch_type
);
12824 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12826 warn (_("compressed section '%s' is corrupted\n"),
12830 uncompressed_size
= chdr
.ch_size
;
12831 start
+= compression_header_size
;
12832 size
-= compression_header_size
;
12834 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12836 /* Read the zlib header. In this case, it should be "ZLIB"
12837 followed by the uncompressed section size, 8 bytes in
12838 big-endian order. */
12839 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12840 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12841 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12842 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12843 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12844 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12845 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12846 uncompressed_size
+= start
[11];
12851 if (uncompressed_size
12852 && uncompress_section_contents (&start
, uncompressed_size
,
12855 /* Free the compressed buffer, update the section buffer
12856 and the section size if uncompress is successful. */
12857 free (section
->start
);
12858 section
->start
= start
;
12860 section
->size
= size
;
12863 if (section
->start
== NULL
)
12866 if (debug_displays
[debug
].relocate
)
12867 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12868 & section
->reloc_info
, & section
->num_relocs
);
12871 section
->reloc_info
= NULL
;
12872 section
->num_relocs
= 0;
12878 /* If this is not NULL, load_debug_section will only look for sections
12879 within the list of sections given here. */
12880 unsigned int *section_subset
= NULL
;
12883 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12885 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12886 Elf_Internal_Shdr
* sec
;
12888 /* Locate the debug section. */
12889 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12891 section
->name
= section
->uncompressed_name
;
12894 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12896 section
->name
= section
->compressed_name
;
12901 /* If we're loading from a subset of sections, and we've loaded
12902 a section matching this name before, it's likely that it's a
12904 if (section_subset
!= NULL
)
12905 free_debug_section (debug
);
12907 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12911 free_debug_section (enum dwarf_section_display_enum debug
)
12913 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12915 if (section
->start
== NULL
)
12918 free ((char *) section
->start
);
12919 section
->start
= NULL
;
12920 section
->address
= 0;
12925 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12927 char * name
= SECTION_NAME (section
);
12928 const char * print_name
= printable_section_name (section
);
12929 bfd_size_type length
;
12933 length
= section
->sh_size
;
12936 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12939 if (section
->sh_type
== SHT_NOBITS
)
12941 /* There is no point in dumping the contents of a debugging section
12942 which has the NOBITS type - the bits in the file will be random.
12943 This can happen when a file containing a .eh_frame section is
12944 stripped with the --only-keep-debug command line option. */
12945 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12950 if (const_strneq (name
, ".gnu.linkonce.wi."))
12951 name
= ".debug_info";
12953 /* See if we know how to display the contents of this section. */
12954 for (i
= 0; i
< max
; i
++)
12955 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12956 || (i
== line
&& const_strneq (name
, ".debug_line."))
12957 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12959 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12960 int secondary
= (section
!= find_section (name
));
12963 free_debug_section ((enum dwarf_section_display_enum
) i
);
12965 if (i
== line
&& const_strneq (name
, ".debug_line."))
12967 else if (streq (sec
->uncompressed_name
, name
))
12968 sec
->name
= sec
->uncompressed_name
;
12970 sec
->name
= sec
->compressed_name
;
12971 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12974 /* If this debug section is part of a CU/TU set in a .dwp file,
12975 restrict load_debug_section to the sections in that set. */
12976 section_subset
= find_cu_tu_set (file
, shndx
);
12978 result
&= debug_displays
[i
].display (sec
, file
);
12980 section_subset
= NULL
;
12982 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12983 free_debug_section ((enum dwarf_section_display_enum
) i
);
12991 printf (_("Unrecognized debug section: %s\n"), print_name
);
12998 /* Set DUMP_SECTS for all sections where dumps were requested
12999 based on section name. */
13002 initialise_dumps_byname (void)
13004 struct dump_list_entry
* cur
;
13006 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13011 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13012 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13014 request_dump_bynumber (i
, cur
->type
);
13019 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13025 process_section_contents (FILE * file
)
13027 Elf_Internal_Shdr
* section
;
13033 initialise_dumps_byname ();
13035 for (i
= 0, section
= section_headers
;
13036 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13039 #ifdef SUPPORT_DISASSEMBLY
13040 if (dump_sects
[i
] & DISASS_DUMP
)
13041 disassemble_section (section
, file
);
13043 if (dump_sects
[i
] & HEX_DUMP
)
13044 dump_section_as_bytes (section
, file
, FALSE
);
13046 if (dump_sects
[i
] & RELOC_DUMP
)
13047 dump_section_as_bytes (section
, file
, TRUE
);
13049 if (dump_sects
[i
] & STRING_DUMP
)
13050 dump_section_as_strings (section
, file
);
13052 if (dump_sects
[i
] & DEBUG_DUMP
)
13053 display_debug_section (i
, section
, file
);
13056 /* Check to see if the user requested a
13057 dump of a section that does not exist. */
13058 while (i
++ < num_dump_sects
)
13060 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13064 process_mips_fpe_exception (int mask
)
13069 if (mask
& OEX_FPU_INEX
)
13070 fputs ("INEX", stdout
), first
= 0;
13071 if (mask
& OEX_FPU_UFLO
)
13072 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13073 if (mask
& OEX_FPU_OFLO
)
13074 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13075 if (mask
& OEX_FPU_DIV0
)
13076 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13077 if (mask
& OEX_FPU_INVAL
)
13078 printf ("%sINVAL", first
? "" : "|");
13081 fputs ("0", stdout
);
13084 /* Display's the value of TAG at location P. If TAG is
13085 greater than 0 it is assumed to be an unknown tag, and
13086 a message is printed to this effect. Otherwise it is
13087 assumed that a message has already been printed.
13089 If the bottom bit of TAG is set it assumed to have a
13090 string value, otherwise it is assumed to have an integer
13093 Returns an updated P pointing to the first unread byte
13094 beyond the end of TAG's value.
13096 Reads at or beyond END will not be made. */
13098 static unsigned char *
13099 display_tag_value (int tag
,
13101 const unsigned char * const end
)
13106 printf (" Tag_unknown_%d: ", tag
);
13110 warn (_("<corrupt tag>\n"));
13114 /* PR 17531 file: 027-19978-0.004. */
13115 size_t maxlen
= (end
- p
) - 1;
13120 print_symbol ((int) maxlen
, (const char *) p
);
13121 p
+= strnlen ((char *) p
, maxlen
) + 1;
13125 printf (_("<corrupt string tag>"));
13126 p
= (unsigned char *) end
;
13134 val
= read_uleb128 (p
, &len
, end
);
13136 printf ("%ld (0x%lx)\n", val
, val
);
13143 /* ARM EABI attributes section. */
13148 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13150 const char ** table
;
13151 } arm_attr_public_tag
;
13153 static const char * arm_attr_tag_CPU_arch
[] =
13154 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13155 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13157 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13158 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13159 {"No", "Thumb-1", "Thumb-2", "Yes"};
13160 static const char * arm_attr_tag_FP_arch
[] =
13161 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13162 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13163 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13164 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13165 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13166 "NEON for ARMv8.1"};
13167 static const char * arm_attr_tag_PCS_config
[] =
13168 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13169 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13170 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13171 {"V6", "SB", "TLS", "Unused"};
13172 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13173 {"Absolute", "PC-relative", "SB-relative", "None"};
13174 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13175 {"Absolute", "PC-relative", "None"};
13176 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13177 {"None", "direct", "GOT-indirect"};
13178 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13179 {"None", "??? 1", "2", "??? 3", "4"};
13180 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13181 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13182 {"Unused", "Needed", "Sign only"};
13183 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13184 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13185 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13186 {"Unused", "Finite", "RTABI", "IEEE 754"};
13187 static const char * arm_attr_tag_ABI_enum_size
[] =
13188 {"Unused", "small", "int", "forced to int"};
13189 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13190 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13191 static const char * arm_attr_tag_ABI_VFP_args
[] =
13192 {"AAPCS", "VFP registers", "custom", "compatible"};
13193 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13194 {"AAPCS", "WMMX registers", "custom"};
13195 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13196 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13197 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13198 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13199 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13200 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13201 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13202 static const char * arm_attr_tag_FP_HP_extension
[] =
13203 {"Not Allowed", "Allowed"};
13204 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13205 {"None", "IEEE 754", "Alternative Format"};
13206 static const char * arm_attr_tag_DSP_extension
[] =
13207 {"Follow architecture", "Allowed"};
13208 static const char * arm_attr_tag_MPextension_use
[] =
13209 {"Not Allowed", "Allowed"};
13210 static const char * arm_attr_tag_DIV_use
[] =
13211 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13212 "Allowed in v7-A with integer division extension"};
13213 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13214 static const char * arm_attr_tag_Virtualization_use
[] =
13215 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13216 "TrustZone and Virtualization Extensions"};
13217 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13218 {"Not Allowed", "Allowed"};
13220 #define LOOKUP(id, name) \
13221 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13222 static arm_attr_public_tag arm_attr_public_tags
[] =
13224 {4, "CPU_raw_name", 1, NULL
},
13225 {5, "CPU_name", 1, NULL
},
13226 LOOKUP(6, CPU_arch
),
13227 {7, "CPU_arch_profile", 0, NULL
},
13228 LOOKUP(8, ARM_ISA_use
),
13229 LOOKUP(9, THUMB_ISA_use
),
13230 LOOKUP(10, FP_arch
),
13231 LOOKUP(11, WMMX_arch
),
13232 LOOKUP(12, Advanced_SIMD_arch
),
13233 LOOKUP(13, PCS_config
),
13234 LOOKUP(14, ABI_PCS_R9_use
),
13235 LOOKUP(15, ABI_PCS_RW_data
),
13236 LOOKUP(16, ABI_PCS_RO_data
),
13237 LOOKUP(17, ABI_PCS_GOT_use
),
13238 LOOKUP(18, ABI_PCS_wchar_t
),
13239 LOOKUP(19, ABI_FP_rounding
),
13240 LOOKUP(20, ABI_FP_denormal
),
13241 LOOKUP(21, ABI_FP_exceptions
),
13242 LOOKUP(22, ABI_FP_user_exceptions
),
13243 LOOKUP(23, ABI_FP_number_model
),
13244 {24, "ABI_align_needed", 0, NULL
},
13245 {25, "ABI_align_preserved", 0, NULL
},
13246 LOOKUP(26, ABI_enum_size
),
13247 LOOKUP(27, ABI_HardFP_use
),
13248 LOOKUP(28, ABI_VFP_args
),
13249 LOOKUP(29, ABI_WMMX_args
),
13250 LOOKUP(30, ABI_optimization_goals
),
13251 LOOKUP(31, ABI_FP_optimization_goals
),
13252 {32, "compatibility", 0, NULL
},
13253 LOOKUP(34, CPU_unaligned_access
),
13254 LOOKUP(36, FP_HP_extension
),
13255 LOOKUP(38, ABI_FP_16bit_format
),
13256 LOOKUP(42, MPextension_use
),
13257 LOOKUP(44, DIV_use
),
13258 LOOKUP(46, DSP_extension
),
13259 {64, "nodefaults", 0, NULL
},
13260 {65, "also_compatible_with", 0, NULL
},
13261 LOOKUP(66, T2EE_use
),
13262 {67, "conformance", 1, NULL
},
13263 LOOKUP(68, Virtualization_use
),
13264 LOOKUP(70, MPextension_use_legacy
)
13268 static unsigned char *
13269 display_arm_attribute (unsigned char * p
,
13270 const unsigned char * const end
)
13275 arm_attr_public_tag
* attr
;
13279 tag
= read_uleb128 (p
, &len
, end
);
13282 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13284 if (arm_attr_public_tags
[i
].tag
== tag
)
13286 attr
= &arm_attr_public_tags
[i
];
13293 printf (" Tag_%s: ", attr
->name
);
13294 switch (attr
->type
)
13299 case 7: /* Tag_CPU_arch_profile. */
13300 val
= read_uleb128 (p
, &len
, end
);
13304 case 0: printf (_("None\n")); break;
13305 case 'A': printf (_("Application\n")); break;
13306 case 'R': printf (_("Realtime\n")); break;
13307 case 'M': printf (_("Microcontroller\n")); break;
13308 case 'S': printf (_("Application or Realtime\n")); break;
13309 default: printf ("??? (%d)\n", val
); break;
13313 case 24: /* Tag_align_needed. */
13314 val
= read_uleb128 (p
, &len
, end
);
13318 case 0: printf (_("None\n")); break;
13319 case 1: printf (_("8-byte\n")); break;
13320 case 2: printf (_("4-byte\n")); break;
13321 case 3: printf ("??? 3\n"); break;
13324 printf (_("8-byte and up to %d-byte extended\n"),
13327 printf ("??? (%d)\n", val
);
13332 case 25: /* Tag_align_preserved. */
13333 val
= read_uleb128 (p
, &len
, end
);
13337 case 0: printf (_("None\n")); break;
13338 case 1: printf (_("8-byte, except leaf SP\n")); break;
13339 case 2: printf (_("8-byte\n")); break;
13340 case 3: printf ("??? 3\n"); break;
13343 printf (_("8-byte and up to %d-byte extended\n"),
13346 printf ("??? (%d)\n", val
);
13351 case 32: /* Tag_compatibility. */
13353 val
= read_uleb128 (p
, &len
, end
);
13355 printf (_("flag = %d, vendor = "), val
);
13358 size_t maxlen
= (end
- p
) - 1;
13360 print_symbol ((int) maxlen
, (const char *) p
);
13361 p
+= strnlen ((char *) p
, maxlen
) + 1;
13365 printf (_("<corrupt>"));
13366 p
= (unsigned char *) end
;
13372 case 64: /* Tag_nodefaults. */
13373 /* PR 17531: file: 001-505008-0.01. */
13376 printf (_("True\n"));
13379 case 65: /* Tag_also_compatible_with. */
13380 val
= read_uleb128 (p
, &len
, end
);
13382 if (val
== 6 /* Tag_CPU_arch. */)
13384 val
= read_uleb128 (p
, &len
, end
);
13386 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13387 printf ("??? (%d)\n", val
);
13389 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13393 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13398 printf (_("<unknown: %d>\n"), tag
);
13404 return display_tag_value (-1, p
, end
);
13406 return display_tag_value (0, p
, end
);
13409 assert (attr
->type
& 0x80);
13410 val
= read_uleb128 (p
, &len
, end
);
13412 type
= attr
->type
& 0x7f;
13414 printf ("??? (%d)\n", val
);
13416 printf ("%s\n", attr
->table
[val
]);
13421 return display_tag_value (tag
, p
, end
);
13424 static unsigned char *
13425 display_gnu_attribute (unsigned char * p
,
13426 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13427 const unsigned char * const end
)
13433 tag
= read_uleb128 (p
, &len
, end
);
13436 /* Tag_compatibility is the only generic GNU attribute defined at
13440 val
= read_uleb128 (p
, &len
, end
);
13443 printf (_("flag = %d, vendor = "), val
);
13446 printf (_("<corrupt>\n"));
13447 warn (_("corrupt vendor attribute\n"));
13453 size_t maxlen
= (end
- p
) - 1;
13455 print_symbol ((int) maxlen
, (const char *) p
);
13456 p
+= strnlen ((char *) p
, maxlen
) + 1;
13460 printf (_("<corrupt>"));
13461 p
= (unsigned char *) end
;
13468 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13469 return display_proc_gnu_attribute (p
, tag
, end
);
13471 return display_tag_value (tag
, p
, end
);
13474 static unsigned char *
13475 display_power_gnu_attribute (unsigned char * p
,
13477 const unsigned char * const end
)
13482 if (tag
== Tag_GNU_Power_ABI_FP
)
13484 val
= read_uleb128 (p
, &len
, end
);
13486 printf (" Tag_GNU_Power_ABI_FP: ");
13489 printf (_("<corrupt>\n"));
13494 printf ("(%#x), ", val
);
13499 printf (_("unspecified hard/soft float, "));
13502 printf (_("hard float, "));
13505 printf (_("soft float, "));
13508 printf (_("single-precision hard float, "));
13515 printf (_("unspecified long double\n"));
13518 printf (_("128-bit IBM long double\n"));
13521 printf (_("64-bit long double\n"));
13524 printf (_("128-bit IEEE long double\n"));
13530 if (tag
== Tag_GNU_Power_ABI_Vector
)
13532 val
= read_uleb128 (p
, &len
, end
);
13534 printf (" Tag_GNU_Power_ABI_Vector: ");
13537 printf (_("<corrupt>\n"));
13542 printf ("(%#x), ", val
);
13547 printf (_("unspecified\n"));
13550 printf (_("generic\n"));
13553 printf ("AltiVec\n");
13562 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13564 val
= read_uleb128 (p
, &len
, end
);
13566 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13569 printf (_("<corrupt>\n"));
13574 printf ("(%#x), ", val
);
13579 printf (_("unspecified\n"));
13582 printf ("r3/r4\n");
13585 printf (_("memory\n"));
13594 return display_tag_value (tag
& 1, p
, end
);
13597 static unsigned char *
13598 display_s390_gnu_attribute (unsigned char * p
,
13600 const unsigned char * const end
)
13605 if (tag
== Tag_GNU_S390_ABI_Vector
)
13607 val
= read_uleb128 (p
, &len
, end
);
13609 printf (" Tag_GNU_S390_ABI_Vector: ");
13614 printf (_("any\n"));
13617 printf (_("software\n"));
13620 printf (_("hardware\n"));
13623 printf ("??? (%d)\n", val
);
13629 return display_tag_value (tag
& 1, p
, end
);
13633 display_sparc_hwcaps (int mask
)
13639 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13640 fputs ("mul32", stdout
), first
= 0;
13641 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13642 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13643 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13644 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13645 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13646 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13647 if (mask
& ELF_SPARC_HWCAP_POPC
)
13648 printf ("%spopc", first
? "" : "|"), first
= 0;
13649 if (mask
& ELF_SPARC_HWCAP_VIS
)
13650 printf ("%svis", first
? "" : "|"), first
= 0;
13651 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13652 printf ("%svis2", first
? "" : "|"), first
= 0;
13653 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13654 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13655 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13656 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13657 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13658 printf ("%svis3", first
? "" : "|"), first
= 0;
13659 if (mask
& ELF_SPARC_HWCAP_HPC
)
13660 printf ("%shpc", first
? "" : "|"), first
= 0;
13661 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13662 printf ("%srandom", first
? "" : "|"), first
= 0;
13663 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13664 printf ("%strans", first
? "" : "|"), first
= 0;
13665 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13666 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13667 if (mask
& ELF_SPARC_HWCAP_IMA
)
13668 printf ("%sima", first
? "" : "|"), first
= 0;
13669 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13670 printf ("%scspare", first
? "" : "|"), first
= 0;
13673 fputc ('0', stdout
);
13674 fputc ('\n', stdout
);
13678 display_sparc_hwcaps2 (int mask
)
13684 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13685 fputs ("fjathplus", stdout
), first
= 0;
13686 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13687 printf ("%svis3b", first
? "" : "|"), first
= 0;
13688 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13689 printf ("%sadp", first
? "" : "|"), first
= 0;
13690 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13691 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13692 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13693 printf ("%smwait", first
? "" : "|"), first
= 0;
13694 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13695 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13696 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13697 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13698 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13699 printf ("%snsec", first
? "" : "|"), first
= 0;
13700 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13701 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13702 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13703 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13704 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13705 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13708 fputc ('0', stdout
);
13709 fputc ('\n', stdout
);
13712 static unsigned char *
13713 display_sparc_gnu_attribute (unsigned char * p
,
13715 const unsigned char * const end
)
13720 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13722 val
= read_uleb128 (p
, &len
, end
);
13724 printf (" Tag_GNU_Sparc_HWCAPS: ");
13725 display_sparc_hwcaps (val
);
13728 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13730 val
= read_uleb128 (p
, &len
, end
);
13732 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13733 display_sparc_hwcaps2 (val
);
13737 return display_tag_value (tag
, p
, end
);
13741 print_mips_fp_abi_value (int val
)
13745 case Val_GNU_MIPS_ABI_FP_ANY
:
13746 printf (_("Hard or soft float\n"));
13748 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13749 printf (_("Hard float (double precision)\n"));
13751 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13752 printf (_("Hard float (single precision)\n"));
13754 case Val_GNU_MIPS_ABI_FP_SOFT
:
13755 printf (_("Soft float\n"));
13757 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13758 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13760 case Val_GNU_MIPS_ABI_FP_XX
:
13761 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13763 case Val_GNU_MIPS_ABI_FP_64
:
13764 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13766 case Val_GNU_MIPS_ABI_FP_64A
:
13767 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13769 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13770 printf (_("NaN 2008 compatibility\n"));
13773 printf ("??? (%d)\n", val
);
13778 static unsigned char *
13779 display_mips_gnu_attribute (unsigned char * p
,
13781 const unsigned char * const end
)
13783 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13788 val
= read_uleb128 (p
, &len
, end
);
13790 printf (" Tag_GNU_MIPS_ABI_FP: ");
13792 print_mips_fp_abi_value (val
);
13797 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13802 val
= read_uleb128 (p
, &len
, end
);
13804 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13808 case Val_GNU_MIPS_ABI_MSA_ANY
:
13809 printf (_("Any MSA or not\n"));
13811 case Val_GNU_MIPS_ABI_MSA_128
:
13812 printf (_("128-bit MSA\n"));
13815 printf ("??? (%d)\n", val
);
13821 return display_tag_value (tag
& 1, p
, end
);
13824 static unsigned char *
13825 display_tic6x_attribute (unsigned char * p
,
13826 const unsigned char * const end
)
13832 tag
= read_uleb128 (p
, &len
, end
);
13838 val
= read_uleb128 (p
, &len
, end
);
13840 printf (" Tag_ISA: ");
13844 case C6XABI_Tag_ISA_none
:
13845 printf (_("None\n"));
13847 case C6XABI_Tag_ISA_C62X
:
13850 case C6XABI_Tag_ISA_C67X
:
13853 case C6XABI_Tag_ISA_C67XP
:
13854 printf ("C67x+\n");
13856 case C6XABI_Tag_ISA_C64X
:
13859 case C6XABI_Tag_ISA_C64XP
:
13860 printf ("C64x+\n");
13862 case C6XABI_Tag_ISA_C674X
:
13863 printf ("C674x\n");
13866 printf ("??? (%d)\n", val
);
13871 case Tag_ABI_wchar_t
:
13872 val
= read_uleb128 (p
, &len
, end
);
13874 printf (" Tag_ABI_wchar_t: ");
13878 printf (_("Not used\n"));
13881 printf (_("2 bytes\n"));
13884 printf (_("4 bytes\n"));
13887 printf ("??? (%d)\n", val
);
13892 case Tag_ABI_stack_align_needed
:
13893 val
= read_uleb128 (p
, &len
, end
);
13895 printf (" Tag_ABI_stack_align_needed: ");
13899 printf (_("8-byte\n"));
13902 printf (_("16-byte\n"));
13905 printf ("??? (%d)\n", val
);
13910 case Tag_ABI_stack_align_preserved
:
13911 val
= read_uleb128 (p
, &len
, end
);
13913 printf (" Tag_ABI_stack_align_preserved: ");
13917 printf (_("8-byte\n"));
13920 printf (_("16-byte\n"));
13923 printf ("??? (%d)\n", val
);
13929 val
= read_uleb128 (p
, &len
, end
);
13931 printf (" Tag_ABI_DSBT: ");
13935 printf (_("DSBT addressing not used\n"));
13938 printf (_("DSBT addressing used\n"));
13941 printf ("??? (%d)\n", val
);
13947 val
= read_uleb128 (p
, &len
, end
);
13949 printf (" Tag_ABI_PID: ");
13953 printf (_("Data addressing position-dependent\n"));
13956 printf (_("Data addressing position-independent, GOT near DP\n"));
13959 printf (_("Data addressing position-independent, GOT far from DP\n"));
13962 printf ("??? (%d)\n", val
);
13968 val
= read_uleb128 (p
, &len
, end
);
13970 printf (" Tag_ABI_PIC: ");
13974 printf (_("Code addressing position-dependent\n"));
13977 printf (_("Code addressing position-independent\n"));
13980 printf ("??? (%d)\n", val
);
13985 case Tag_ABI_array_object_alignment
:
13986 val
= read_uleb128 (p
, &len
, end
);
13988 printf (" Tag_ABI_array_object_alignment: ");
13992 printf (_("8-byte\n"));
13995 printf (_("4-byte\n"));
13998 printf (_("16-byte\n"));
14001 printf ("??? (%d)\n", val
);
14006 case Tag_ABI_array_object_align_expected
:
14007 val
= read_uleb128 (p
, &len
, end
);
14009 printf (" Tag_ABI_array_object_align_expected: ");
14013 printf (_("8-byte\n"));
14016 printf (_("4-byte\n"));
14019 printf (_("16-byte\n"));
14022 printf ("??? (%d)\n", val
);
14027 case Tag_ABI_compatibility
:
14029 val
= read_uleb128 (p
, &len
, end
);
14031 printf (" Tag_ABI_compatibility: ");
14032 printf (_("flag = %d, vendor = "), val
);
14035 size_t maxlen
= (end
- p
) - 1;
14037 print_symbol ((int) maxlen
, (const char *) p
);
14038 p
+= strnlen ((char *) p
, maxlen
) + 1;
14042 printf (_("<corrupt>"));
14043 p
= (unsigned char *) end
;
14049 case Tag_ABI_conformance
:
14051 printf (" Tag_ABI_conformance: \"");
14054 size_t maxlen
= (end
- p
) - 1;
14056 print_symbol ((int) maxlen
, (const char *) p
);
14057 p
+= strnlen ((char *) p
, maxlen
) + 1;
14061 printf (_("<corrupt>"));
14062 p
= (unsigned char *) end
;
14069 return display_tag_value (tag
, p
, end
);
14073 display_raw_attribute (unsigned char * p
, unsigned char * end
)
14075 unsigned long addr
= 0;
14076 size_t bytes
= end
- p
;
14083 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14085 printf (" 0x%8.8lx ", addr
);
14087 for (j
= 0; j
< 16; j
++)
14090 printf ("%2.2x", p
[j
]);
14098 for (j
= 0; j
< lbytes
; j
++)
14101 if (k
>= ' ' && k
< 0x7f)
14117 static unsigned char *
14118 display_msp430x_attribute (unsigned char * p
,
14119 const unsigned char * const end
)
14125 tag
= read_uleb128 (p
, & len
, end
);
14130 case OFBA_MSPABI_Tag_ISA
:
14131 val
= read_uleb128 (p
, &len
, end
);
14133 printf (" Tag_ISA: ");
14136 case 0: printf (_("None\n")); break;
14137 case 1: printf (_("MSP430\n")); break;
14138 case 2: printf (_("MSP430X\n")); break;
14139 default: printf ("??? (%d)\n", val
); break;
14143 case OFBA_MSPABI_Tag_Code_Model
:
14144 val
= read_uleb128 (p
, &len
, end
);
14146 printf (" Tag_Code_Model: ");
14149 case 0: printf (_("None\n")); break;
14150 case 1: printf (_("Small\n")); break;
14151 case 2: printf (_("Large\n")); break;
14152 default: printf ("??? (%d)\n", val
); break;
14156 case OFBA_MSPABI_Tag_Data_Model
:
14157 val
= read_uleb128 (p
, &len
, end
);
14159 printf (" Tag_Data_Model: ");
14162 case 0: printf (_("None\n")); break;
14163 case 1: printf (_("Small\n")); break;
14164 case 2: printf (_("Large\n")); break;
14165 case 3: printf (_("Restricted Large\n")); break;
14166 default: printf ("??? (%d)\n", val
); break;
14171 printf (_(" <unknown tag %d>: "), tag
);
14178 size_t maxlen
= (end
- p
) - 1;
14180 print_symbol ((int) maxlen
, (const char *) p
);
14181 p
+= strnlen ((char *) p
, maxlen
) + 1;
14185 printf (_("<corrupt>"));
14186 p
= (unsigned char *) end
;
14192 val
= read_uleb128 (p
, &len
, end
);
14194 printf ("%d (0x%x)\n", val
, val
);
14204 process_attributes (FILE * file
,
14205 const char * public_name
,
14206 unsigned int proc_type
,
14207 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14208 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14210 Elf_Internal_Shdr
* sect
;
14213 /* Find the section header so that we get the size. */
14214 for (i
= 0, sect
= section_headers
;
14215 i
< elf_header
.e_shnum
;
14218 unsigned char * contents
;
14221 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14224 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14225 sect
->sh_size
, _("attributes"));
14226 if (contents
== NULL
)
14232 bfd_vma section_len
;
14234 section_len
= sect
->sh_size
- 1;
14237 while (section_len
> 0)
14240 unsigned int namelen
;
14241 bfd_boolean public_section
;
14242 bfd_boolean gnu_section
;
14244 if (section_len
<= 4)
14246 error (_("Tag section ends prematurely\n"));
14249 attr_len
= byte_get (p
, 4);
14252 if (attr_len
> section_len
)
14254 error (_("Bad attribute length (%u > %u)\n"),
14255 (unsigned) attr_len
, (unsigned) section_len
);
14256 attr_len
= section_len
;
14258 /* PR 17531: file: 001-101425-0.004 */
14259 else if (attr_len
< 5)
14261 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14265 section_len
-= attr_len
;
14268 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14269 if (namelen
== 0 || namelen
>= attr_len
)
14271 error (_("Corrupt attribute section name\n"));
14275 printf (_("Attribute Section: "));
14276 print_symbol (INT_MAX
, (const char *) p
);
14279 if (public_name
&& streq ((char *) p
, public_name
))
14280 public_section
= TRUE
;
14282 public_section
= FALSE
;
14284 if (streq ((char *) p
, "gnu"))
14285 gnu_section
= TRUE
;
14287 gnu_section
= FALSE
;
14290 attr_len
-= namelen
;
14292 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14297 unsigned char * end
;
14299 /* PR binutils/17531: Safe handling of corrupt files. */
14302 error (_("Unused bytes at end of section\n"));
14308 size
= byte_get (p
, 4);
14309 if (size
> attr_len
)
14311 error (_("Bad subsection length (%u > %u)\n"),
14312 (unsigned) size
, (unsigned) attr_len
);
14315 /* PR binutils/17531: Safe handling of corrupt files. */
14318 error (_("Bad subsection length (%u < 6)\n"),
14325 end
= p
+ size
- 1;
14326 assert (end
<= contents
+ sect
->sh_size
);
14332 printf (_("File Attributes\n"));
14335 printf (_("Section Attributes:"));
14338 printf (_("Symbol Attributes:"));
14339 /* Fall through. */
14345 val
= read_uleb128 (p
, &j
, end
);
14349 printf (" %d", val
);
14354 printf (_("Unknown tag: %d\n"), tag
);
14355 public_section
= FALSE
;
14359 if (public_section
&& display_pub_attribute
!= NULL
)
14362 p
= display_pub_attribute (p
, end
);
14365 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14368 p
= display_gnu_attribute (p
,
14369 display_proc_gnu_attribute
,
14375 printf (_(" Unknown attribute:\n"));
14376 display_raw_attribute (p
, end
);
14385 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14393 process_arm_specific (FILE * file
)
14395 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14396 display_arm_attribute
, NULL
);
14400 process_power_specific (FILE * file
)
14402 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14403 display_power_gnu_attribute
);
14407 process_s390_specific (FILE * file
)
14409 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14410 display_s390_gnu_attribute
);
14414 process_sparc_specific (FILE * file
)
14416 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14417 display_sparc_gnu_attribute
);
14421 process_tic6x_specific (FILE * file
)
14423 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14424 display_tic6x_attribute
, NULL
);
14428 process_msp430x_specific (FILE * file
)
14430 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14431 display_msp430x_attribute
, NULL
);
14434 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14435 Print the Address, Access and Initial fields of an entry at VMA ADDR
14436 and return the VMA of the next entry, or -1 if there was a problem.
14437 Does not read from DATA_END or beyond. */
14440 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14441 unsigned char * data_end
)
14444 print_vma (addr
, LONG_HEX
);
14446 if (addr
< pltgot
+ 0xfff0)
14447 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14449 printf ("%10s", "");
14452 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14456 unsigned char * from
= data
+ addr
- pltgot
;
14458 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14460 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14461 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14462 return (bfd_vma
) -1;
14466 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14467 print_vma (entry
, LONG_HEX
);
14470 return addr
+ (is_32bit_elf
? 4 : 8);
14473 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14474 PLTGOT. Print the Address and Initial fields of an entry at VMA
14475 ADDR and return the VMA of the next entry. */
14478 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14481 print_vma (addr
, LONG_HEX
);
14484 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14489 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14490 print_vma (entry
, LONG_HEX
);
14492 return addr
+ (is_32bit_elf
? 4 : 8);
14496 print_mips_ases (unsigned int mask
)
14498 if (mask
& AFL_ASE_DSP
)
14499 fputs ("\n\tDSP ASE", stdout
);
14500 if (mask
& AFL_ASE_DSPR2
)
14501 fputs ("\n\tDSP R2 ASE", stdout
);
14502 if (mask
& AFL_ASE_DSPR3
)
14503 fputs ("\n\tDSP R3 ASE", stdout
);
14504 if (mask
& AFL_ASE_EVA
)
14505 fputs ("\n\tEnhanced VA Scheme", stdout
);
14506 if (mask
& AFL_ASE_MCU
)
14507 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14508 if (mask
& AFL_ASE_MDMX
)
14509 fputs ("\n\tMDMX ASE", stdout
);
14510 if (mask
& AFL_ASE_MIPS3D
)
14511 fputs ("\n\tMIPS-3D ASE", stdout
);
14512 if (mask
& AFL_ASE_MT
)
14513 fputs ("\n\tMT ASE", stdout
);
14514 if (mask
& AFL_ASE_SMARTMIPS
)
14515 fputs ("\n\tSmartMIPS ASE", stdout
);
14516 if (mask
& AFL_ASE_VIRT
)
14517 fputs ("\n\tVZ ASE", stdout
);
14518 if (mask
& AFL_ASE_MSA
)
14519 fputs ("\n\tMSA ASE", stdout
);
14520 if (mask
& AFL_ASE_MIPS16
)
14521 fputs ("\n\tMIPS16 ASE", stdout
);
14522 if (mask
& AFL_ASE_MICROMIPS
)
14523 fputs ("\n\tMICROMIPS ASE", stdout
);
14524 if (mask
& AFL_ASE_XPA
)
14525 fputs ("\n\tXPA ASE", stdout
);
14527 fprintf (stdout
, "\n\t%s", _("None"));
14528 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14529 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14533 print_mips_isa_ext (unsigned int isa_ext
)
14538 fputs (_("None"), stdout
);
14541 fputs ("RMI XLR", stdout
);
14543 case AFL_EXT_OCTEON3
:
14544 fputs ("Cavium Networks Octeon3", stdout
);
14546 case AFL_EXT_OCTEON2
:
14547 fputs ("Cavium Networks Octeon2", stdout
);
14549 case AFL_EXT_OCTEONP
:
14550 fputs ("Cavium Networks OcteonP", stdout
);
14552 case AFL_EXT_LOONGSON_3A
:
14553 fputs ("Loongson 3A", stdout
);
14555 case AFL_EXT_OCTEON
:
14556 fputs ("Cavium Networks Octeon", stdout
);
14559 fputs ("Toshiba R5900", stdout
);
14562 fputs ("MIPS R4650", stdout
);
14565 fputs ("LSI R4010", stdout
);
14568 fputs ("NEC VR4100", stdout
);
14571 fputs ("Toshiba R3900", stdout
);
14573 case AFL_EXT_10000
:
14574 fputs ("MIPS R10000", stdout
);
14577 fputs ("Broadcom SB-1", stdout
);
14580 fputs ("NEC VR4111/VR4181", stdout
);
14583 fputs ("NEC VR4120", stdout
);
14586 fputs ("NEC VR5400", stdout
);
14589 fputs ("NEC VR5500", stdout
);
14591 case AFL_EXT_LOONGSON_2E
:
14592 fputs ("ST Microelectronics Loongson 2E", stdout
);
14594 case AFL_EXT_LOONGSON_2F
:
14595 fputs ("ST Microelectronics Loongson 2F", stdout
);
14598 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14603 get_mips_reg_size (int reg_size
)
14605 return (reg_size
== AFL_REG_NONE
) ? 0
14606 : (reg_size
== AFL_REG_32
) ? 32
14607 : (reg_size
== AFL_REG_64
) ? 64
14608 : (reg_size
== AFL_REG_128
) ? 128
14613 process_mips_specific (FILE * file
)
14615 Elf_Internal_Dyn
* entry
;
14616 Elf_Internal_Shdr
*sect
= NULL
;
14617 size_t liblist_offset
= 0;
14618 size_t liblistno
= 0;
14619 size_t conflictsno
= 0;
14620 size_t options_offset
= 0;
14621 size_t conflicts_offset
= 0;
14622 size_t pltrelsz
= 0;
14624 bfd_vma pltgot
= 0;
14625 bfd_vma mips_pltgot
= 0;
14626 bfd_vma jmprel
= 0;
14627 bfd_vma local_gotno
= 0;
14628 bfd_vma gotsym
= 0;
14629 bfd_vma symtabno
= 0;
14631 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14632 display_mips_gnu_attribute
);
14634 sect
= find_section (".MIPS.abiflags");
14638 Elf_External_ABIFlags_v0
*abiflags_ext
;
14639 Elf_Internal_ABIFlags_v0 abiflags_in
;
14641 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14642 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14645 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14646 sect
->sh_size
, _("MIPS ABI Flags section"));
14649 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14650 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14651 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14652 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14653 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14654 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14655 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14656 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14657 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14658 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14659 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14661 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14662 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14663 if (abiflags_in
.isa_rev
> 1)
14664 printf ("r%d", abiflags_in
.isa_rev
);
14665 printf ("\nGPR size: %d",
14666 get_mips_reg_size (abiflags_in
.gpr_size
));
14667 printf ("\nCPR1 size: %d",
14668 get_mips_reg_size (abiflags_in
.cpr1_size
));
14669 printf ("\nCPR2 size: %d",
14670 get_mips_reg_size (abiflags_in
.cpr2_size
));
14671 fputs ("\nFP ABI: ", stdout
);
14672 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14673 fputs ("ISA Extension: ", stdout
);
14674 print_mips_isa_ext (abiflags_in
.isa_ext
);
14675 fputs ("\nASEs:", stdout
);
14676 print_mips_ases (abiflags_in
.ases
);
14677 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14678 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14679 fputc ('\n', stdout
);
14680 free (abiflags_ext
);
14685 /* We have a lot of special sections. Thanks SGI! */
14686 if (dynamic_section
== NULL
)
14687 /* No information available. */
14690 for (entry
= dynamic_section
;
14691 /* PR 17531 file: 012-50589-0.004. */
14692 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14694 switch (entry
->d_tag
)
14696 case DT_MIPS_LIBLIST
:
14698 = offset_from_vma (file
, entry
->d_un
.d_val
,
14699 liblistno
* sizeof (Elf32_External_Lib
));
14701 case DT_MIPS_LIBLISTNO
:
14702 liblistno
= entry
->d_un
.d_val
;
14704 case DT_MIPS_OPTIONS
:
14705 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14707 case DT_MIPS_CONFLICT
:
14709 = offset_from_vma (file
, entry
->d_un
.d_val
,
14710 conflictsno
* sizeof (Elf32_External_Conflict
));
14712 case DT_MIPS_CONFLICTNO
:
14713 conflictsno
= entry
->d_un
.d_val
;
14716 pltgot
= entry
->d_un
.d_ptr
;
14718 case DT_MIPS_LOCAL_GOTNO
:
14719 local_gotno
= entry
->d_un
.d_val
;
14721 case DT_MIPS_GOTSYM
:
14722 gotsym
= entry
->d_un
.d_val
;
14724 case DT_MIPS_SYMTABNO
:
14725 symtabno
= entry
->d_un
.d_val
;
14727 case DT_MIPS_PLTGOT
:
14728 mips_pltgot
= entry
->d_un
.d_ptr
;
14731 pltrel
= entry
->d_un
.d_val
;
14734 pltrelsz
= entry
->d_un
.d_val
;
14737 jmprel
= entry
->d_un
.d_ptr
;
14743 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14745 Elf32_External_Lib
* elib
;
14748 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14750 sizeof (Elf32_External_Lib
),
14751 _("liblist section data"));
14754 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14755 (unsigned long) liblistno
);
14756 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14759 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14766 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14767 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14768 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14769 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14770 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14772 tmp
= gmtime (&atime
);
14773 snprintf (timebuf
, sizeof (timebuf
),
14774 "%04u-%02u-%02uT%02u:%02u:%02u",
14775 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14776 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14778 printf ("%3lu: ", (unsigned long) cnt
);
14779 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14780 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14782 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14783 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14784 liblist
.l_version
);
14786 if (liblist
.l_flags
== 0)
14790 static const struct
14797 { " EXACT_MATCH", LL_EXACT_MATCH
},
14798 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14799 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14800 { " EXPORTS", LL_EXPORTS
},
14801 { " DELAY_LOAD", LL_DELAY_LOAD
},
14802 { " DELTA", LL_DELTA
}
14804 int flags
= liblist
.l_flags
;
14807 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14808 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14810 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14811 flags
^= l_flags_vals
[fcnt
].bit
;
14814 printf (" %#x", (unsigned int) flags
);
14824 if (options_offset
!= 0)
14826 Elf_External_Options
* eopt
;
14827 Elf_Internal_Options
* iopt
;
14828 Elf_Internal_Options
* option
;
14831 sect
= section_headers
;
14833 /* Find the section header so that we get the size. */
14834 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14835 /* PR 17533 file: 012-277276-0.004. */
14838 error (_("No MIPS_OPTIONS header found\n"));
14842 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14843 sect
->sh_size
, _("options"));
14846 iopt
= (Elf_Internal_Options
*)
14847 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14850 error (_("Out of memory allocating space for MIPS options\n"));
14857 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14859 Elf_External_Options
* eoption
;
14861 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14863 option
->kind
= BYTE_GET (eoption
->kind
);
14864 option
->size
= BYTE_GET (eoption
->size
);
14865 option
->section
= BYTE_GET (eoption
->section
);
14866 option
->info
= BYTE_GET (eoption
->info
);
14868 /* PR 17531: file: ffa0fa3b. */
14869 if (option
->size
< sizeof (* eopt
)
14870 || offset
+ option
->size
> sect
->sh_size
)
14872 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14875 offset
+= option
->size
;
14881 printf (_("\nSection '%s' contains %d entries:\n"),
14882 printable_section_name (sect
), cnt
);
14891 switch (option
->kind
)
14894 /* This shouldn't happen. */
14895 printf (" NULL %d %lx", option
->section
, option
->info
);
14898 printf (" REGINFO ");
14899 if (elf_header
.e_machine
== EM_MIPS
)
14902 Elf32_External_RegInfo
* ereg
;
14903 Elf32_RegInfo reginfo
;
14905 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14906 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14907 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14908 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14909 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14910 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14911 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14913 printf ("GPR %08lx GP 0x%lx\n",
14914 reginfo
.ri_gprmask
,
14915 (unsigned long) reginfo
.ri_gp_value
);
14916 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14917 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14918 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14923 Elf64_External_RegInfo
* ereg
;
14924 Elf64_Internal_RegInfo reginfo
;
14926 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14927 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14928 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14929 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14930 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14931 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14932 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14934 printf ("GPR %08lx GP 0x",
14935 reginfo
.ri_gprmask
);
14936 printf_vma (reginfo
.ri_gp_value
);
14939 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14940 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14941 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14945 case ODK_EXCEPTIONS
:
14946 fputs (" EXCEPTIONS fpe_min(", stdout
);
14947 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14948 fputs (") fpe_max(", stdout
);
14949 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14950 fputs (")", stdout
);
14952 if (option
->info
& OEX_PAGE0
)
14953 fputs (" PAGE0", stdout
);
14954 if (option
->info
& OEX_SMM
)
14955 fputs (" SMM", stdout
);
14956 if (option
->info
& OEX_FPDBUG
)
14957 fputs (" FPDBUG", stdout
);
14958 if (option
->info
& OEX_DISMISS
)
14959 fputs (" DISMISS", stdout
);
14962 fputs (" PAD ", stdout
);
14963 if (option
->info
& OPAD_PREFIX
)
14964 fputs (" PREFIX", stdout
);
14965 if (option
->info
& OPAD_POSTFIX
)
14966 fputs (" POSTFIX", stdout
);
14967 if (option
->info
& OPAD_SYMBOL
)
14968 fputs (" SYMBOL", stdout
);
14971 fputs (" HWPATCH ", stdout
);
14972 if (option
->info
& OHW_R4KEOP
)
14973 fputs (" R4KEOP", stdout
);
14974 if (option
->info
& OHW_R8KPFETCH
)
14975 fputs (" R8KPFETCH", stdout
);
14976 if (option
->info
& OHW_R5KEOP
)
14977 fputs (" R5KEOP", stdout
);
14978 if (option
->info
& OHW_R5KCVTL
)
14979 fputs (" R5KCVTL", stdout
);
14982 fputs (" FILL ", stdout
);
14983 /* XXX Print content of info word? */
14986 fputs (" TAGS ", stdout
);
14987 /* XXX Print content of info word? */
14990 fputs (" HWAND ", stdout
);
14991 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14992 fputs (" R4KEOP_CHECKED", stdout
);
14993 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14994 fputs (" R4KEOP_CLEAN", stdout
);
14997 fputs (" HWOR ", stdout
);
14998 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14999 fputs (" R4KEOP_CHECKED", stdout
);
15000 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15001 fputs (" R4KEOP_CLEAN", stdout
);
15004 printf (" GP_GROUP %#06lx self-contained %#06lx",
15005 option
->info
& OGP_GROUP
,
15006 (option
->info
& OGP_SELF
) >> 16);
15009 printf (" IDENT %#06lx self-contained %#06lx",
15010 option
->info
& OGP_GROUP
,
15011 (option
->info
& OGP_SELF
) >> 16);
15014 /* This shouldn't happen. */
15015 printf (" %3d ??? %d %lx",
15016 option
->kind
, option
->section
, option
->info
);
15020 len
= sizeof (* eopt
);
15021 while (len
< option
->size
)
15023 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15025 if (ISPRINT (datum
))
15026 printf ("%c", datum
);
15028 printf ("\\%03o", datum
);
15031 fputs ("\n", stdout
);
15033 offset
+= option
->size
;
15041 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15043 Elf32_Conflict
* iconf
;
15046 if (dynamic_symbols
== NULL
)
15048 error (_("conflict list found without a dynamic symbol table\n"));
15052 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15055 error (_("Out of memory allocating space for dynamic conflicts\n"));
15061 Elf32_External_Conflict
* econf32
;
15063 econf32
= (Elf32_External_Conflict
*)
15064 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15065 sizeof (* econf32
), _("conflict"));
15069 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15070 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15076 Elf64_External_Conflict
* econf64
;
15078 econf64
= (Elf64_External_Conflict
*)
15079 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15080 sizeof (* econf64
), _("conflict"));
15084 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15085 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15090 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15091 (unsigned long) conflictsno
);
15092 puts (_(" Num: Index Value Name"));
15094 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15096 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15098 if (iconf
[cnt
] >= num_dynamic_syms
)
15099 printf (_("<corrupt symbol index>"));
15102 Elf_Internal_Sym
* psym
;
15104 psym
= & dynamic_symbols
[iconf
[cnt
]];
15105 print_vma (psym
->st_value
, FULL_HEX
);
15107 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15108 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15110 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15118 if (pltgot
!= 0 && local_gotno
!= 0)
15120 bfd_vma ent
, local_end
, global_end
;
15122 unsigned char * data
;
15123 unsigned char * data_end
;
15127 addr_size
= (is_32bit_elf
? 4 : 8);
15128 local_end
= pltgot
+ local_gotno
* addr_size
;
15130 /* PR binutils/17533 file: 012-111227-0.004 */
15131 if (symtabno
< gotsym
)
15133 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15134 (unsigned long) gotsym
, (unsigned long) symtabno
);
15138 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15139 /* PR 17531: file: 54c91a34. */
15140 if (global_end
< local_end
)
15142 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15146 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15147 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15148 global_end
- pltgot
, 1,
15149 _("Global Offset Table data"));
15152 data_end
= data
+ (global_end
- pltgot
);
15154 printf (_("\nPrimary GOT:\n"));
15155 printf (_(" Canonical gp value: "));
15156 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15159 printf (_(" Reserved entries:\n"));
15160 printf (_(" %*s %10s %*s Purpose\n"),
15161 addr_size
* 2, _("Address"), _("Access"),
15162 addr_size
* 2, _("Initial"));
15163 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15164 printf (_(" Lazy resolver\n"));
15165 if (ent
== (bfd_vma
) -1)
15166 goto got_print_fail
;
15168 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15169 >> (addr_size
* 8 - 1)) != 0)
15171 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15172 printf (_(" Module pointer (GNU extension)\n"));
15173 if (ent
== (bfd_vma
) -1)
15174 goto got_print_fail
;
15178 if (ent
< local_end
)
15180 printf (_(" Local entries:\n"));
15181 printf (" %*s %10s %*s\n",
15182 addr_size
* 2, _("Address"), _("Access"),
15183 addr_size
* 2, _("Initial"));
15184 while (ent
< local_end
)
15186 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15188 if (ent
== (bfd_vma
) -1)
15189 goto got_print_fail
;
15194 if (gotsym
< symtabno
)
15198 printf (_(" Global entries:\n"));
15199 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15200 addr_size
* 2, _("Address"),
15202 addr_size
* 2, _("Initial"),
15203 addr_size
* 2, _("Sym.Val."),
15205 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15206 _("Ndx"), _("Name"));
15208 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15210 for (i
= gotsym
; i
< symtabno
; i
++)
15212 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15215 if (dynamic_symbols
== NULL
)
15216 printf (_("<no dynamic symbols>"));
15217 else if (i
< num_dynamic_syms
)
15219 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15221 print_vma (psym
->st_value
, LONG_HEX
);
15222 printf (" %-7s %3s ",
15223 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15224 get_symbol_index_type (psym
->st_shndx
));
15226 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15227 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15229 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15232 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15233 (unsigned long) i
);
15236 if (ent
== (bfd_vma
) -1)
15247 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15250 size_t offset
, rel_offset
;
15251 unsigned long count
, i
;
15252 unsigned char * data
;
15253 int addr_size
, sym_width
;
15254 Elf_Internal_Rela
* rels
;
15256 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15257 if (pltrel
== DT_RELA
)
15259 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15264 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15269 addr_size
= (is_32bit_elf
? 4 : 8);
15270 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15272 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15273 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15274 1, _("Procedure Linkage Table data"));
15278 printf ("\nPLT GOT:\n\n");
15279 printf (_(" Reserved entries:\n"));
15280 printf (_(" %*s %*s Purpose\n"),
15281 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15282 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15283 printf (_(" PLT lazy resolver\n"));
15284 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15285 printf (_(" Module pointer\n"));
15288 printf (_(" Entries:\n"));
15289 printf (" %*s %*s %*s %-7s %3s %s\n",
15290 addr_size
* 2, _("Address"),
15291 addr_size
* 2, _("Initial"),
15292 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15293 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15294 for (i
= 0; i
< count
; i
++)
15296 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15298 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15301 if (idx
>= num_dynamic_syms
)
15302 printf (_("<corrupt symbol index: %lu>"), idx
);
15305 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15307 print_vma (psym
->st_value
, LONG_HEX
);
15308 printf (" %-7s %3s ",
15309 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15310 get_symbol_index_type (psym
->st_shndx
));
15311 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15312 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15314 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15329 process_nds32_specific (FILE * file
)
15331 Elf_Internal_Shdr
*sect
= NULL
;
15333 sect
= find_section (".nds32_e_flags");
15336 unsigned int *flag
;
15338 printf ("\nNDS32 elf flags section:\n");
15339 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15340 sect
->sh_size
, _("NDS32 elf flags section"));
15342 switch ((*flag
) & 0x3)
15345 printf ("(VEC_SIZE):\tNo entry.\n");
15348 printf ("(VEC_SIZE):\t4 bytes\n");
15351 printf ("(VEC_SIZE):\t16 bytes\n");
15354 printf ("(VEC_SIZE):\treserved\n");
15363 process_gnu_liblist (FILE * file
)
15365 Elf_Internal_Shdr
* section
;
15366 Elf_Internal_Shdr
* string_sec
;
15367 Elf32_External_Lib
* elib
;
15369 size_t strtab_size
;
15376 for (i
= 0, section
= section_headers
;
15377 i
< elf_header
.e_shnum
;
15380 switch (section
->sh_type
)
15382 case SHT_GNU_LIBLIST
:
15383 if (section
->sh_link
>= elf_header
.e_shnum
)
15386 elib
= (Elf32_External_Lib
*)
15387 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15388 _("liblist section data"));
15392 string_sec
= section_headers
+ section
->sh_link
;
15394 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15395 string_sec
->sh_size
,
15396 _("liblist string table"));
15398 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15404 strtab_size
= string_sec
->sh_size
;
15406 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15407 printable_section_name (section
),
15408 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15410 puts (_(" Library Time Stamp Checksum Version Flags"));
15412 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15420 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15421 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15422 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15423 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15424 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15426 tmp
= gmtime (&atime
);
15427 snprintf (timebuf
, sizeof (timebuf
),
15428 "%04u-%02u-%02uT%02u:%02u:%02u",
15429 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15430 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15432 printf ("%3lu: ", (unsigned long) cnt
);
15434 printf ("%-20s", liblist
.l_name
< strtab_size
15435 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15437 printf ("%-20.20s", liblist
.l_name
< strtab_size
15438 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15439 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15440 liblist
.l_version
, liblist
.l_flags
);
15451 static const char *
15452 get_note_type (unsigned e_type
)
15454 static char buff
[64];
15456 if (elf_header
.e_type
== ET_CORE
)
15460 return _("NT_AUXV (auxiliary vector)");
15462 return _("NT_PRSTATUS (prstatus structure)");
15464 return _("NT_FPREGSET (floating point registers)");
15466 return _("NT_PRPSINFO (prpsinfo structure)");
15467 case NT_TASKSTRUCT
:
15468 return _("NT_TASKSTRUCT (task structure)");
15470 return _("NT_PRXFPREG (user_xfpregs structure)");
15472 return _("NT_PPC_VMX (ppc Altivec registers)");
15474 return _("NT_PPC_VSX (ppc VSX registers)");
15476 return _("NT_386_TLS (x86 TLS information)");
15477 case NT_386_IOPERM
:
15478 return _("NT_386_IOPERM (x86 I/O permissions)");
15479 case NT_X86_XSTATE
:
15480 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15481 case NT_S390_HIGH_GPRS
:
15482 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15483 case NT_S390_TIMER
:
15484 return _("NT_S390_TIMER (s390 timer register)");
15485 case NT_S390_TODCMP
:
15486 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15487 case NT_S390_TODPREG
:
15488 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15490 return _("NT_S390_CTRS (s390 control registers)");
15491 case NT_S390_PREFIX
:
15492 return _("NT_S390_PREFIX (s390 prefix register)");
15493 case NT_S390_LAST_BREAK
:
15494 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15495 case NT_S390_SYSTEM_CALL
:
15496 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15498 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15499 case NT_S390_VXRS_LOW
:
15500 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15501 case NT_S390_VXRS_HIGH
:
15502 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15504 return _("NT_ARM_VFP (arm VFP registers)");
15506 return _("NT_ARM_TLS (AArch TLS registers)");
15507 case NT_ARM_HW_BREAK
:
15508 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15509 case NT_ARM_HW_WATCH
:
15510 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15512 return _("NT_PSTATUS (pstatus structure)");
15514 return _("NT_FPREGS (floating point registers)");
15516 return _("NT_PSINFO (psinfo structure)");
15518 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15520 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15521 case NT_WIN32PSTATUS
:
15522 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15524 return _("NT_SIGINFO (siginfo_t data)");
15526 return _("NT_FILE (mapped files)");
15534 return _("NT_VERSION (version)");
15536 return _("NT_ARCH (architecture)");
15541 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15546 print_core_note (Elf_Internal_Note
*pnote
)
15548 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15549 bfd_vma count
, page_size
;
15550 unsigned char *descdata
, *filenames
, *descend
;
15552 if (pnote
->type
!= NT_FILE
)
15558 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15559 /* Still "successful". */
15564 if (pnote
->descsz
< 2 * addr_size
)
15566 printf (_(" Malformed note - too short for header\n"));
15570 descdata
= (unsigned char *) pnote
->descdata
;
15571 descend
= descdata
+ pnote
->descsz
;
15573 if (descdata
[pnote
->descsz
- 1] != '\0')
15575 printf (_(" Malformed note - does not end with \\0\n"));
15579 count
= byte_get (descdata
, addr_size
);
15580 descdata
+= addr_size
;
15582 page_size
= byte_get (descdata
, addr_size
);
15583 descdata
+= addr_size
;
15585 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15587 printf (_(" Malformed note - too short for supplied file count\n"));
15591 printf (_(" Page size: "));
15592 print_vma (page_size
, DEC
);
15595 printf (_(" %*s%*s%*s\n"),
15596 (int) (2 + 2 * addr_size
), _("Start"),
15597 (int) (4 + 2 * addr_size
), _("End"),
15598 (int) (4 + 2 * addr_size
), _("Page Offset"));
15599 filenames
= descdata
+ count
* 3 * addr_size
;
15600 while (count
-- > 0)
15602 bfd_vma start
, end
, file_ofs
;
15604 if (filenames
== descend
)
15606 printf (_(" Malformed note - filenames end too early\n"));
15610 start
= byte_get (descdata
, addr_size
);
15611 descdata
+= addr_size
;
15612 end
= byte_get (descdata
, addr_size
);
15613 descdata
+= addr_size
;
15614 file_ofs
= byte_get (descdata
, addr_size
);
15615 descdata
+= addr_size
;
15618 print_vma (start
, FULL_HEX
);
15620 print_vma (end
, FULL_HEX
);
15622 print_vma (file_ofs
, FULL_HEX
);
15623 printf ("\n %s\n", filenames
);
15625 filenames
+= 1 + strlen ((char *) filenames
);
15631 static const char *
15632 get_gnu_elf_note_type (unsigned e_type
)
15634 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15637 case NT_GNU_ABI_TAG
:
15638 return _("NT_GNU_ABI_TAG (ABI version tag)");
15640 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15641 case NT_GNU_BUILD_ID
:
15642 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15643 case NT_GNU_GOLD_VERSION
:
15644 return _("NT_GNU_GOLD_VERSION (gold version)");
15647 static char buff
[64];
15649 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15656 print_gnu_note (Elf_Internal_Note
*pnote
)
15658 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15659 switch (pnote
->type
)
15661 case NT_GNU_BUILD_ID
:
15665 printf (_(" Build ID: "));
15666 for (i
= 0; i
< pnote
->descsz
; ++i
)
15667 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15672 case NT_GNU_ABI_TAG
:
15674 unsigned long os
, major
, minor
, subminor
;
15675 const char *osname
;
15677 /* PR 17531: file: 030-599401-0.004. */
15678 if (pnote
->descsz
< 16)
15680 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15684 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15685 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15686 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15687 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15691 case GNU_ABI_TAG_LINUX
:
15694 case GNU_ABI_TAG_HURD
:
15697 case GNU_ABI_TAG_SOLARIS
:
15698 osname
= "Solaris";
15700 case GNU_ABI_TAG_FREEBSD
:
15701 osname
= "FreeBSD";
15703 case GNU_ABI_TAG_NETBSD
:
15706 case GNU_ABI_TAG_SYLLABLE
:
15707 osname
= "Syllable";
15709 case GNU_ABI_TAG_NACL
:
15713 osname
= "Unknown";
15717 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15718 major
, minor
, subminor
);
15722 case NT_GNU_GOLD_VERSION
:
15726 printf (_(" Version: "));
15727 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15728 printf ("%c", pnote
->descdata
[i
]);
15735 unsigned long num_entries
, mask
;
15737 /* Hardware capabilities information. Word 0 is the number of entries.
15738 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15739 is a series of entries, where each entry is a single byte followed
15740 by a nul terminated string. The byte gives the bit number to test
15741 if enabled in the bitmask. */
15742 printf (_(" Hardware Capabilities: "));
15743 if (pnote
->descsz
< 8)
15745 printf (_("<corrupt GNU_HWCAP>\n"));
15748 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15749 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15750 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15751 /* FIXME: Add code to display the entries... */
15756 /* Handle unrecognised types. An error message should have already been
15757 created by get_gnu_elf_note_type(), so all that we need to do is to
15758 display the data. */
15762 printf (_(" Description data: "));
15763 for (i
= 0; i
< pnote
->descsz
; ++i
)
15764 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15773 static const char *
15774 get_v850_elf_note_type (enum v850_notes n_type
)
15776 static char buff
[64];
15780 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15781 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15782 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15783 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15784 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15785 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15787 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15793 print_v850_note (Elf_Internal_Note
* pnote
)
15797 if (pnote
->descsz
!= 4)
15799 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15803 printf (_("not set\n"));
15807 switch (pnote
->type
)
15809 case V850_NOTE_ALIGNMENT
:
15812 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15813 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15817 case V850_NOTE_DATA_SIZE
:
15820 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15821 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15825 case V850_NOTE_FPU_INFO
:
15828 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15829 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15833 case V850_NOTE_MMU_INFO
:
15834 case V850_NOTE_CACHE_INFO
:
15835 case V850_NOTE_SIMD_INFO
:
15836 if (val
== EF_RH850_SIMD
)
15838 printf (_("yes\n"));
15844 /* An 'unknown note type' message will already have been displayed. */
15848 printf (_("unknown value: %x\n"), val
);
15853 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15855 unsigned int version
;
15857 switch (pnote
->type
)
15859 case NT_NETBSD_IDENT
:
15860 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15861 if ((version
/ 10000) % 100)
15862 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15863 version
, version
/ 100000000, (version
/ 1000000) % 100,
15864 (version
/ 10000) % 100 > 26 ? "Z" : "",
15865 'A' + (version
/ 10000) % 26);
15867 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15868 version
, version
/ 100000000, (version
/ 1000000) % 100,
15869 (version
/ 100) % 100);
15872 case NT_NETBSD_MARCH
:
15873 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15881 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15886 static const char *
15887 get_freebsd_elfcore_note_type (unsigned e_type
)
15891 case NT_FREEBSD_THRMISC
:
15892 return _("NT_THRMISC (thrmisc structure)");
15893 case NT_FREEBSD_PROCSTAT_PROC
:
15894 return _("NT_PROCSTAT_PROC (proc data)");
15895 case NT_FREEBSD_PROCSTAT_FILES
:
15896 return _("NT_PROCSTAT_FILES (files data)");
15897 case NT_FREEBSD_PROCSTAT_VMMAP
:
15898 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15899 case NT_FREEBSD_PROCSTAT_GROUPS
:
15900 return _("NT_PROCSTAT_GROUPS (groups data)");
15901 case NT_FREEBSD_PROCSTAT_UMASK
:
15902 return _("NT_PROCSTAT_UMASK (umask data)");
15903 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15904 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15905 case NT_FREEBSD_PROCSTAT_OSREL
:
15906 return _("NT_PROCSTAT_OSREL (osreldate data)");
15907 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15908 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15909 case NT_FREEBSD_PROCSTAT_AUXV
:
15910 return _("NT_PROCSTAT_AUXV (auxv data)");
15912 return get_note_type (e_type
);
15915 static const char *
15916 get_netbsd_elfcore_note_type (unsigned e_type
)
15918 static char buff
[64];
15920 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15922 /* NetBSD core "procinfo" structure. */
15923 return _("NetBSD procinfo structure");
15926 /* As of Jan 2002 there are no other machine-independent notes
15927 defined for NetBSD core files. If the note type is less
15928 than the start of the machine-dependent note types, we don't
15931 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15933 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15937 switch (elf_header
.e_machine
)
15939 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15940 and PT_GETFPREGS == mach+2. */
15945 case EM_SPARC32PLUS
:
15949 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15950 return _("PT_GETREGS (reg structure)");
15951 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15952 return _("PT_GETFPREGS (fpreg structure)");
15958 /* On all other arch's, PT_GETREGS == mach+1 and
15959 PT_GETFPREGS == mach+3. */
15963 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15964 return _("PT_GETREGS (reg structure)");
15965 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15966 return _("PT_GETFPREGS (fpreg structure)");
15972 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15973 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15977 static const char *
15978 get_stapsdt_note_type (unsigned e_type
)
15980 static char buff
[64];
15985 return _("NT_STAPSDT (SystemTap probe descriptors)");
15991 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15996 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15998 int addr_size
= is_32bit_elf
? 4 : 8;
15999 char *data
= pnote
->descdata
;
16000 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16001 bfd_vma pc
, base_addr
, semaphore
;
16002 char *provider
, *probe
, *arg_fmt
;
16004 pc
= byte_get ((unsigned char *) data
, addr_size
);
16006 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16008 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16012 data
+= strlen (data
) + 1;
16014 data
+= strlen (data
) + 1;
16016 data
+= strlen (data
) + 1;
16018 printf (_(" Provider: %s\n"), provider
);
16019 printf (_(" Name: %s\n"), probe
);
16020 printf (_(" Location: "));
16021 print_vma (pc
, FULL_HEX
);
16022 printf (_(", Base: "));
16023 print_vma (base_addr
, FULL_HEX
);
16024 printf (_(", Semaphore: "));
16025 print_vma (semaphore
, FULL_HEX
);
16027 printf (_(" Arguments: %s\n"), arg_fmt
);
16029 return data
== data_end
;
16032 static const char *
16033 get_ia64_vms_note_type (unsigned e_type
)
16035 static char buff
[64];
16040 return _("NT_VMS_MHD (module header)");
16042 return _("NT_VMS_LNM (language name)");
16044 return _("NT_VMS_SRC (source files)");
16046 return "NT_VMS_TITLE";
16048 return _("NT_VMS_EIDC (consistency check)");
16049 case NT_VMS_FPMODE
:
16050 return _("NT_VMS_FPMODE (FP mode)");
16051 case NT_VMS_LINKTIME
:
16052 return "NT_VMS_LINKTIME";
16053 case NT_VMS_IMGNAM
:
16054 return _("NT_VMS_IMGNAM (image name)");
16056 return _("NT_VMS_IMGID (image id)");
16057 case NT_VMS_LINKID
:
16058 return _("NT_VMS_LINKID (link id)");
16059 case NT_VMS_IMGBID
:
16060 return _("NT_VMS_IMGBID (build id)");
16061 case NT_VMS_GSTNAM
:
16062 return _("NT_VMS_GSTNAM (sym table name)");
16063 case NT_VMS_ORIG_DYN
:
16064 return "NT_VMS_ORIG_DYN";
16065 case NT_VMS_PATCHTIME
:
16066 return "NT_VMS_PATCHTIME";
16068 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16074 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16076 switch (pnote
->type
)
16079 if (pnote
->descsz
> 36)
16081 size_t l
= strlen (pnote
->descdata
+ 34);
16082 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16083 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16084 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16085 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16088 printf (_(" Invalid size\n"));
16091 printf (_(" Language: %s\n"), pnote
->descdata
);
16094 case NT_VMS_FPMODE
:
16095 printf (_(" Floating Point mode: "));
16096 printf ("0x%016" BFD_VMA_FMT
"x\n",
16097 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16099 case NT_VMS_LINKTIME
:
16100 printf (_(" Link time: "));
16102 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16105 case NT_VMS_PATCHTIME
:
16106 printf (_(" Patch time: "));
16108 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16111 case NT_VMS_ORIG_DYN
:
16112 printf (_(" Major id: %u, minor id: %u\n"),
16113 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16114 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16115 printf (_(" Last modified : "));
16117 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16118 printf (_("\n Link flags : "));
16119 printf ("0x%016" BFD_VMA_FMT
"x\n",
16120 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16121 printf (_(" Header flags: 0x%08x\n"),
16122 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16123 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16126 case NT_VMS_IMGNAM
:
16127 printf (_(" Image name: %s\n"), pnote
->descdata
);
16129 case NT_VMS_GSTNAM
:
16130 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16133 printf (_(" Image id: %s\n"), pnote
->descdata
);
16135 case NT_VMS_LINKID
:
16136 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16144 /* Note that by the ELF standard, the name field is already null byte
16145 terminated, and namesz includes the terminating null byte.
16146 I.E. the value of namesz for the name "FSF" is 4.
16148 If the value of namesz is zero, there is no name present. */
16150 process_note (Elf_Internal_Note
* pnote
,
16151 FILE * file ATTRIBUTE_UNUSED
,
16152 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16154 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16157 if (pnote
->namesz
== 0)
16158 /* If there is no note name, then use the default set of
16159 note type strings. */
16160 nt
= get_note_type (pnote
->type
);
16162 else if (const_strneq (pnote
->namedata
, "GNU"))
16163 /* GNU-specific object file notes. */
16164 nt
= get_gnu_elf_note_type (pnote
->type
);
16166 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16167 /* FreeBSD-specific core file notes. */
16168 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16170 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16171 /* NetBSD-specific core file notes. */
16172 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16174 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16175 /* NetBSD-specific core file notes. */
16176 return process_netbsd_elf_note (pnote
);
16178 else if (strneq (pnote
->namedata
, "SPU/", 4))
16180 /* SPU-specific core file notes. */
16181 nt
= pnote
->namedata
+ 4;
16185 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16186 /* VMS/ia64-specific file notes. */
16187 nt
= get_ia64_vms_note_type (pnote
->type
);
16189 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16190 nt
= get_stapsdt_note_type (pnote
->type
);
16193 /* Don't recognize this note name; just use the default set of
16194 note type strings. */
16195 nt
= get_note_type (pnote
->type
);
16198 print_symbol (-20, name
);
16199 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16201 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16202 return print_ia64_vms_note (pnote
);
16203 else if (const_strneq (pnote
->namedata
, "GNU"))
16204 return print_gnu_note (pnote
);
16205 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16206 return print_stapsdt_note (pnote
);
16207 else if (const_strneq (pnote
->namedata
, "CORE"))
16208 return print_core_note (pnote
);
16210 else if (pnote
->descsz
)
16214 printf (_(" description data: "));
16215 for (i
= 0; i
< pnote
->descsz
; i
++)
16216 printf ("%02x ", pnote
->descdata
[i
]);
16224 process_notes_at (FILE * file
,
16225 Elf_Internal_Shdr
* section
,
16229 Elf_External_Note
* pnotes
;
16230 Elf_External_Note
* external
;
16239 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16241 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16244 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16246 if (pnotes
== NULL
)
16252 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16254 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16255 (unsigned long) offset
, (unsigned long) length
);
16257 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16259 end
= (char *) pnotes
+ length
;
16260 while ((char *) external
< end
)
16262 Elf_Internal_Note inote
;
16265 char * temp
= NULL
;
16266 size_t data_remaining
= end
- (char *) external
;
16268 if (!is_ia64_vms ())
16270 /* PR binutils/15191
16271 Make sure that there is enough data to read. */
16272 min_notesz
= offsetof (Elf_External_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
);
16279 inote
.type
= BYTE_GET (external
->type
);
16280 inote
.namesz
= BYTE_GET (external
->namesz
);
16281 inote
.namedata
= external
->name
;
16282 inote
.descsz
= BYTE_GET (external
->descsz
);
16283 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16284 /* PR 17531: file: 3443835e. */
16285 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16287 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16288 inote
.descdata
= inote
.namedata
;
16292 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16293 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16297 Elf64_External_VMS_Note
*vms_external
;
16299 /* PR binutils/15191
16300 Make sure that there is enough data to read. */
16301 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16302 if (data_remaining
< min_notesz
)
16304 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16305 (int) data_remaining
);
16309 vms_external
= (Elf64_External_VMS_Note
*) external
;
16310 inote
.type
= BYTE_GET (vms_external
->type
);
16311 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16312 inote
.namedata
= vms_external
->name
;
16313 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16314 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16315 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16316 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16319 if (inote
.descdata
< (char *) external
+ min_notesz
16320 || next
< (char *) external
+ min_notesz
16321 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16322 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16323 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16324 || data_remaining
< (size_t)(next
- (char *) external
))
16326 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16327 (unsigned long) ((char *) external
- (char *) pnotes
));
16328 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16329 inote
.type
, inote
.namesz
, inote
.descsz
);
16333 external
= (Elf_External_Note
*) next
;
16335 /* Verify that name is null terminated. It appears that at least
16336 one version of Linux (RedHat 6.0) generates corefiles that don't
16337 comply with the ELF spec by failing to include the null byte in
16339 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16341 temp
= (char *) malloc (inote
.namesz
+ 1);
16344 error (_("Out of memory allocating space for inote name\n"));
16349 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16350 temp
[inote
.namesz
] = 0;
16352 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16353 inote
.namedata
= temp
;
16356 res
&= process_note (& inote
, file
, section
);
16371 process_corefile_note_segments (FILE * file
)
16373 Elf_Internal_Phdr
* segment
;
16377 if (! get_program_headers (file
))
16380 for (i
= 0, segment
= program_headers
;
16381 i
< elf_header
.e_phnum
;
16384 if (segment
->p_type
== PT_NOTE
)
16385 res
&= process_notes_at (file
, NULL
,
16386 (bfd_vma
) segment
->p_offset
,
16387 (bfd_vma
) segment
->p_filesz
);
16394 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16396 Elf_External_Note
* pnotes
;
16397 Elf_External_Note
* external
;
16404 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16406 if (pnotes
== NULL
)
16410 end
= (char*) pnotes
+ length
;
16412 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16413 (unsigned long) offset
, (unsigned long) length
);
16415 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16417 Elf_External_Note
* next
;
16418 Elf_Internal_Note inote
;
16420 inote
.type
= BYTE_GET (external
->type
);
16421 inote
.namesz
= BYTE_GET (external
->namesz
);
16422 inote
.namedata
= external
->name
;
16423 inote
.descsz
= BYTE_GET (external
->descsz
);
16424 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16425 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16427 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16429 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16430 inote
.descdata
= inote
.namedata
;
16434 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16436 if ( ((char *) next
> end
)
16437 || ((char *) next
< (char *) pnotes
))
16439 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16440 (unsigned long) ((char *) external
- (char *) pnotes
));
16441 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16442 inote
.type
, inote
.namesz
, inote
.descsz
);
16448 /* Prevent out-of-bounds indexing. */
16449 if ( inote
.namedata
+ inote
.namesz
> end
16450 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16452 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16453 (unsigned long) ((char *) external
- (char *) pnotes
));
16454 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16455 inote
.type
, inote
.namesz
, inote
.descsz
);
16459 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16461 if (! print_v850_note (& inote
))
16464 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16465 inote
.namesz
, inote
.descsz
);
16475 process_note_sections (FILE * file
)
16477 Elf_Internal_Shdr
* section
;
16482 for (i
= 0, section
= section_headers
;
16483 i
< elf_header
.e_shnum
&& section
!= NULL
;
16486 if (section
->sh_type
== SHT_NOTE
)
16488 res
&= process_notes_at (file
, section
,
16489 (bfd_vma
) section
->sh_offset
,
16490 (bfd_vma
) section
->sh_size
);
16494 if (( elf_header
.e_machine
== EM_V800
16495 || elf_header
.e_machine
== EM_V850
16496 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16497 && section
->sh_type
== SHT_RENESAS_INFO
)
16499 res
&= process_v850_notes (file
,
16500 (bfd_vma
) section
->sh_offset
,
16501 (bfd_vma
) section
->sh_size
);
16507 /* Try processing NOTE segments instead. */
16508 return process_corefile_note_segments (file
);
16514 process_notes (FILE * file
)
16516 /* If we have not been asked to display the notes then do nothing. */
16520 if (elf_header
.e_type
!= ET_CORE
)
16521 return process_note_sections (file
);
16523 /* No program headers means no NOTE segment. */
16524 if (elf_header
.e_phnum
> 0)
16525 return process_corefile_note_segments (file
);
16527 printf (_("No note segments present in the core file.\n"));
16532 process_arch_specific (FILE * file
)
16537 switch (elf_header
.e_machine
)
16540 return process_arm_specific (file
);
16542 case EM_MIPS_RS3_LE
:
16543 return process_mips_specific (file
);
16546 return process_nds32_specific (file
);
16550 return process_power_specific (file
);
16554 return process_s390_specific (file
);
16557 case EM_SPARC32PLUS
:
16559 return process_sparc_specific (file
);
16562 return process_tic6x_specific (file
);
16565 return process_msp430x_specific (file
);
16573 get_file_header (FILE * file
)
16575 /* Read in the identity array. */
16576 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16579 /* Determine how to read the rest of the header. */
16580 switch (elf_header
.e_ident
[EI_DATA
])
16585 byte_get
= byte_get_little_endian
;
16586 byte_put
= byte_put_little_endian
;
16589 byte_get
= byte_get_big_endian
;
16590 byte_put
= byte_put_big_endian
;
16594 /* For now we only support 32 bit and 64 bit ELF files. */
16595 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16597 /* Read in the rest of the header. */
16600 Elf32_External_Ehdr ehdr32
;
16602 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16605 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16606 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16607 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16608 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16609 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16610 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16611 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16612 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16613 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16614 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16615 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16616 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16617 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16621 Elf64_External_Ehdr ehdr64
;
16623 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16624 we will not be able to cope with the 64bit data found in
16625 64 ELF files. Detect this now and abort before we start
16626 overwriting things. */
16627 if (sizeof (bfd_vma
) < 8)
16629 error (_("This instance of readelf has been built without support for a\n\
16630 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16634 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16637 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16638 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16639 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16640 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16641 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16642 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16643 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16644 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16645 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16646 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16647 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16648 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16649 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16652 if (elf_header
.e_shoff
)
16654 /* There may be some extensions in the first section header. Don't
16655 bomb if we can't read it. */
16657 get_32bit_section_headers (file
, TRUE
);
16659 get_64bit_section_headers (file
, TRUE
);
16665 /* Process one ELF object file according to the command line options.
16666 This file may actually be stored in an archive. The file is
16667 positioned at the start of the ELF object. */
16670 process_object (char * file_name
, FILE * file
)
16674 if (! get_file_header (file
))
16676 error (_("%s: Failed to read file header\n"), file_name
);
16680 /* Initialise per file variables. */
16681 for (i
= ARRAY_SIZE (version_info
); i
--;)
16682 version_info
[i
] = 0;
16684 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16685 dynamic_info
[i
] = 0;
16686 dynamic_info_DT_GNU_HASH
= 0;
16688 /* Process the file. */
16690 printf (_("\nFile: %s\n"), file_name
);
16692 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16693 Note we do this even if cmdline_dump_sects is empty because we
16694 must make sure that the dump_sets array is zeroed out before each
16695 object file is processed. */
16696 if (num_dump_sects
> num_cmdline_dump_sects
)
16697 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16699 if (num_cmdline_dump_sects
> 0)
16701 if (num_dump_sects
== 0)
16702 /* A sneaky way of allocating the dump_sects array. */
16703 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16705 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16706 memcpy (dump_sects
, cmdline_dump_sects
,
16707 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16710 if (! process_file_header ())
16713 if (! process_section_headers (file
))
16715 /* Without loaded section headers we cannot process lots of
16717 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16719 if (! do_using_dynamic
)
16720 do_syms
= do_dyn_syms
= do_reloc
= 0;
16723 if (! process_section_groups (file
))
16725 /* Without loaded section groups we cannot process unwind. */
16729 if (process_program_headers (file
))
16730 process_dynamic_section (file
);
16732 process_relocs (file
);
16734 process_unwind (file
);
16736 process_symbol_table (file
);
16738 process_syminfo (file
);
16740 process_version_sections (file
);
16742 process_section_contents (file
);
16744 process_notes (file
);
16746 process_gnu_liblist (file
);
16748 process_arch_specific (file
);
16750 if (program_headers
)
16752 free (program_headers
);
16753 program_headers
= NULL
;
16756 if (section_headers
)
16758 free (section_headers
);
16759 section_headers
= NULL
;
16764 free (string_table
);
16765 string_table
= NULL
;
16766 string_table_length
= 0;
16769 if (dynamic_strings
)
16771 free (dynamic_strings
);
16772 dynamic_strings
= NULL
;
16773 dynamic_strings_length
= 0;
16776 if (dynamic_symbols
)
16778 free (dynamic_symbols
);
16779 dynamic_symbols
= NULL
;
16780 num_dynamic_syms
= 0;
16783 if (dynamic_syminfo
)
16785 free (dynamic_syminfo
);
16786 dynamic_syminfo
= NULL
;
16789 if (dynamic_section
)
16791 free (dynamic_section
);
16792 dynamic_section
= NULL
;
16795 if (section_headers_groups
)
16797 free (section_headers_groups
);
16798 section_headers_groups
= NULL
;
16801 if (section_groups
)
16803 struct group_list
* g
;
16804 struct group_list
* next
;
16806 for (i
= 0; i
< group_count
; i
++)
16808 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16815 free (section_groups
);
16816 section_groups
= NULL
;
16819 free_debug_memory ();
16824 /* Process an ELF archive.
16825 On entry the file is positioned just after the ARMAG string. */
16828 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16830 struct archive_info arch
;
16831 struct archive_info nested_arch
;
16837 /* The ARCH structure is used to hold information about this archive. */
16838 arch
.file_name
= NULL
;
16840 arch
.index_array
= NULL
;
16841 arch
.sym_table
= NULL
;
16842 arch
.longnames
= NULL
;
16844 /* The NESTED_ARCH structure is used as a single-item cache of information
16845 about a nested archive (when members of a thin archive reside within
16846 another regular archive file). */
16847 nested_arch
.file_name
= NULL
;
16848 nested_arch
.file
= NULL
;
16849 nested_arch
.index_array
= NULL
;
16850 nested_arch
.sym_table
= NULL
;
16851 nested_arch
.longnames
= NULL
;
16853 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16859 if (do_archive_index
)
16861 if (arch
.sym_table
== NULL
)
16862 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16865 unsigned long i
, l
;
16866 unsigned long current_pos
;
16868 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16869 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16870 current_pos
= ftell (file
);
16872 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16874 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16876 char * member_name
;
16878 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16880 if (member_name
!= NULL
)
16882 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16884 if (qualified_name
!= NULL
)
16886 printf (_("Contents of binary %s at offset "), qualified_name
);
16887 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16889 free (qualified_name
);
16894 if (l
>= arch
.sym_size
)
16896 error (_("%s: end of the symbol table reached before the end of the index\n"),
16900 /* PR 17531: file: 0b6630b2. */
16901 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16902 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16905 if (arch
.uses_64bit_indicies
)
16910 if (l
< arch
.sym_size
)
16911 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16912 file_name
, arch
.sym_size
- l
);
16914 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16916 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16922 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16923 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16924 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16925 && !do_section_groups
&& !do_dyn_syms
)
16927 ret
= 0; /* Archive index only. */
16938 char * qualified_name
;
16940 /* Read the next archive header. */
16941 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16943 error (_("%s: failed to seek to next archive header\n"), file_name
);
16946 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16947 if (got
!= sizeof arch
.arhdr
)
16951 error (_("%s: failed to read archive header\n"), file_name
);
16955 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16957 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16962 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16964 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16965 if (archive_file_size
& 01)
16966 ++archive_file_size
;
16968 name
= get_archive_member_name (&arch
, &nested_arch
);
16971 error (_("%s: bad archive file name\n"), file_name
);
16975 namelen
= strlen (name
);
16977 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16978 if (qualified_name
== NULL
)
16980 error (_("%s: bad archive file name\n"), file_name
);
16985 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16987 /* This is a proxy for an external member of a thin archive. */
16988 FILE * member_file
;
16989 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16990 if (member_file_name
== NULL
)
16996 member_file
= fopen (member_file_name
, "rb");
16997 if (member_file
== NULL
)
16999 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17000 free (member_file_name
);
17005 archive_file_offset
= arch
.nested_member_origin
;
17007 ret
|= process_object (qualified_name
, member_file
);
17009 fclose (member_file
);
17010 free (member_file_name
);
17012 else if (is_thin_archive
)
17014 /* PR 15140: Allow for corrupt thin archives. */
17015 if (nested_arch
.file
== NULL
)
17017 error (_("%s: contains corrupt thin archive: %s\n"),
17023 /* This is a proxy for a member of a nested archive. */
17024 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17026 /* The nested archive file will have been opened and setup by
17027 get_archive_member_name. */
17028 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17030 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17035 ret
|= process_object (qualified_name
, nested_arch
.file
);
17039 archive_file_offset
= arch
.next_arhdr_offset
;
17040 arch
.next_arhdr_offset
+= archive_file_size
;
17042 ret
|= process_object (qualified_name
, file
);
17045 if (dump_sects
!= NULL
)
17049 num_dump_sects
= 0;
17052 free (qualified_name
);
17056 if (nested_arch
.file
!= NULL
)
17057 fclose (nested_arch
.file
);
17058 release_archive (&nested_arch
);
17059 release_archive (&arch
);
17065 process_file (char * file_name
)
17068 struct stat statbuf
;
17069 char armag
[SARMAG
];
17072 if (stat (file_name
, &statbuf
) < 0)
17074 if (errno
== ENOENT
)
17075 error (_("'%s': No such file\n"), file_name
);
17077 error (_("Could not locate '%s'. System error message: %s\n"),
17078 file_name
, strerror (errno
));
17082 if (! S_ISREG (statbuf
.st_mode
))
17084 error (_("'%s' is not an ordinary file\n"), file_name
);
17088 file
= fopen (file_name
, "rb");
17091 error (_("Input file '%s' is not readable.\n"), file_name
);
17095 if (fread (armag
, SARMAG
, 1, file
) != 1)
17097 error (_("%s: Failed to read file's magic number\n"), file_name
);
17102 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17104 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17105 ret
= process_archive (file_name
, file
, FALSE
);
17106 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17107 ret
= process_archive (file_name
, file
, TRUE
);
17110 if (do_archive_index
)
17111 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17115 archive_file_size
= archive_file_offset
= 0;
17116 ret
= process_object (file_name
, file
);
17121 current_file_size
= 0;
17125 #ifdef SUPPORT_DISASSEMBLY
17126 /* Needed by the i386 disassembler. For extra credit, someone could
17127 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17131 print_address (unsigned int addr
, FILE * outfile
)
17133 fprintf (outfile
,"0x%8.8x", addr
);
17136 /* Needed by the i386 disassembler. */
17138 db_task_printsym (unsigned int addr
)
17140 print_address (addr
, stderr
);
17145 main (int argc
, char ** argv
)
17149 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17150 setlocale (LC_MESSAGES
, "");
17152 #if defined (HAVE_SETLOCALE)
17153 setlocale (LC_CTYPE
, "");
17155 bindtextdomain (PACKAGE
, LOCALEDIR
);
17156 textdomain (PACKAGE
);
17158 expandargv (&argc
, &argv
);
17160 parse_args (argc
, argv
);
17162 if (num_dump_sects
> 0)
17164 /* Make a copy of the dump_sects array. */
17165 cmdline_dump_sects
= (dump_type
*)
17166 malloc (num_dump_sects
* sizeof (* dump_sects
));
17167 if (cmdline_dump_sects
== NULL
)
17168 error (_("Out of memory allocating dump request table.\n"));
17171 memcpy (cmdline_dump_sects
, dump_sects
,
17172 num_dump_sects
* sizeof (* dump_sects
));
17173 num_cmdline_dump_sects
= num_dump_sects
;
17177 if (optind
< (argc
- 1))
17179 else if (optind
>= argc
)
17181 warn (_("Nothing to do.\n"));
17186 while (optind
< argc
)
17187 err
|= process_file (argv
[optind
++]);
17189 if (dump_sects
!= NULL
)
17191 if (cmdline_dump_sects
!= NULL
)
17192 free (cmdline_dump_sects
);